Made File Manager respect the user-selected launch type (tab/pinned tab/window/fullscreen)

chrome/browser/chromeos/extensions/file_manager_util.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/extensions/file_handler_util.h"
 #include "chrome/browser/chromeos/gdata/gdata_operation_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/simple_message_box.h"
+#include "chrome/browser/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_window.h"
+#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/plugin_service.h"
 #include "content/public/browser/user_metrics.h"
+#include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_CHROMEOS)
@@ skipping 314 matching lines @@
           IDS_FILE_BROWSER_SELECT_OPEN_MULTI_FILE_TITLE);
       break;
 
     default:
       NOTREACHED();
   }
 
   return title;
 }
 
-void ViewRemovableDrive(const FilePath& dir) {
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser)
+enum TAB_REUSE_MODE {
+  REUSE_ANY_FILE_MANAGER,
+  REUSE_SAME_PATH,
+  REUSE_NEVER
+};
+
+bool FileManageTabExists(const FilePath& path, TAB_REUSE_MODE mode) {
+  if (mode == REUSE_NEVER)
+    return false;
+
+  // We always open full-tab File Manager via chrome://files URL, never
+  // chrome-extension://, so we only check against chrome://files
+  const GURL origin(chrome::kChromeUIFileManagerURL);
+  const std::string ref = std::string("/") + path.value();
+
+  for (BrowserList::const_iterator browser_iterator = BrowserList::begin();
+       browser_iterator != BrowserList::end(); ++browser_iterator) {
+    Browser* browser = *browser_iterator;
+    TabStripModel* tab_strip = browser->tabstrip_model();
+    for (int idx = 0; idx < tab_strip->count(); idx++) {
+      content::WebContents* web_contents =
+          tab_strip->GetTabContentsAt(idx)->web_contents();
+      const GURL& url = web_contents->GetURL();
+      if (origin == url.GetOrigin()) {
+        if (mode == REUSE_ANY_FILE_MANAGER || ref == url.ref()) {
+          if (mode == REUSE_SAME_PATH && tab_strip->active_index() != idx) {
+            browser->window()->Show();
+            tab_strip->ActivateTabAt(idx, false);
+          }
+          return true;
+        }
+      }
+    }
+  }
+
+  return false;
+}
+
+void OpenFileBrowser(const FilePath& path,
+                     TAB_REUSE_MODE mode,
+                     const std::string& flag_name) {
+  if (FileManageTabExists(path, mode))
     return;
 
+  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
+
   FilePath virtual_path;
-  if (!ConvertFileToRelativeFileSystemPath(browser->profile(), dir,
-                                           &virtual_path)) {
+  if (!ConvertFileToRelativeFileSystemPath(profile, path, &virtual_path))
     return;
-  }
-
-  DictionaryValue arg_value;
-  arg_value.SetBoolean("mountTriggered", true);
-
-  std::string json_args;
-  base::JSONWriter::Write(&arg_value, &json_args);
 
   std::string url = chrome::kChromeUIFileManagerURL;
-  url += "?" + json_args + "#/" +
-      net::EscapeUrlEncodedData(virtual_path.value(), false);
+  if (flag_name.size()) {
+    DictionaryValue arg_value;
+    arg_value.SetBoolean(flag_name, "true");
+    std::string query;
+    base::JSONWriter::Write(&arg_value, &query);
+    url += "?" + net::EscapeUrlEncodedData(query, false);
+  }
+  url += "#/" + net::EscapeUrlEncodedData(virtual_path.value(), false);
+
+  ExtensionService* service = profile->GetExtensionService();
+  if (!service)
+    return;
+
+  const Extension* extension =
+      service->GetExtensionById(kFileBrowserDomain, false);
+  if (!extension)
+    return;
+
+  extension_misc::LaunchContainer launch_container =
+      service->extension_prefs()->
+          GetLaunchContainer(extension, ExtensionPrefs::LAUNCH_DEFAULT);
 
   content::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
-  browser->ShowSingletonTabRespectRef(GURL(url));
+  Browser::OpenApplication(
+      profile, extension, launch_container, GURL(url), NEW_FOREGROUND_TAB);
 }
 
-void OpenFileBrowser(const FilePath& full_path) {
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser)
-    return;
-
-  FilePath virtual_path;
-  if (!ConvertFileToRelativeFileSystemPath(browser->profile(), full_path,
-                                           &virtual_path)) {
-    return;
-  }
-
-  std::string url = chrome::kChromeUIFileManagerURL;
-  url += "#/" + net::EscapeUrlEncodedData(virtual_path.value(), false);
-
-  content::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
-  browser->ShowSingletonTabRespectRef(GURL(url));
+void ViewRemovableDrive(const FilePath& path) {
+  OpenFileBrowser(path, REUSE_ANY_FILE_MANAGER, "mountTriggered");
 }
 
-void ViewFolder(const FilePath& dir) {
-  OpenFileBrowser(dir);
+void ShowFileInFolder(const FilePath& path) {
+  // This action changes the selection so we do not reuse existing tabs.
+  OpenFileBrowser(path, REUSE_NEVER, "selectOnly");
+}
+
+void ViewFolder(const FilePath& path) {
+  OpenFileBrowser(path, REUSE_SAME_PATH, "");
 }
 
 class StandaloneExecutor : public FileTaskExecutor {
  public:
   StandaloneExecutor(Profile * profile,
                      const GURL& source_url,
                      const std::string& extension_id,
                      const std::string& action_id)
     : FileTaskExecutor(profile, source_url, extension_id, action_id)
   {}
 
  protected :
   // FileTaskExecutor overrides.
-  virtual Browser* browser() { return BrowserList::GetLastActive(); }
+  virtual Browser* browser() {
+    return Browser::GetOrCreateTabbedBrowser(profile());
+  }
   virtual void Done(bool) {}
 };
 
-bool TryOpeningFileBrowser(const FilePath& full_path) {
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser)
-    return false;
-
-  Profile* profile = browser->profile();
-
+bool TryOpeningFileBrowser(Profile* profile, const FilePath& path) {
   GURL url;
-  if (!ConvertFileToFileSystemUrl(profile, full_path,
+  if (!ConvertFileToFileSystemUrl(profile, path,
       GetFileBrowserExtensionUrl().GetOrigin(), &url))
     return false;
 
   const FileBrowserHandler* handler;
   if (!file_handler_util::GetDefaultTask(profile, url, &handler))
     return false;
 
   std::string extension_id = handler->extension_id();
   std::string action_id = handler->id();
   if (extension_id == kFileBrowserDomain) {
     // Only two of the built-in File Browser tasks require opening the File
     // Browser tab. Others just end up calling TryViewingFile.
     if (action_id == kFileBrowserGalleryTaskId ||
         action_id == kFileBrowserMountArchiveTaskId) {
-      OpenFileBrowser(full_path);
+      // Tab reuse currently does not work for these two tasks.
+      // |gallery| tries to put the file url into the tab url but it does not
+      // work on Chrome OS.
+      // |mount-archive| does not even try.
+      OpenFileBrowser(path, REUSE_SAME_PATH, "");
       return true;
     }
   } else {
     // We are executing the task on behalf of File Browser extension.
     const GURL source_url(kBaseFileBrowserUrl);
 
     // If File Browser has not been open yet then it did not request access
     // to the file system. Do it now.
     fileapi::ExternalFileSystemMountPointProvider* external_provider =
         BrowserContext::GetFileSystemContext(profile)->external_provider();
     if (!external_provider)
       return false;
     external_provider->GrantFullAccessToExtension(source_url.host());
 
     std::vector<GURL> urls;
     urls.push_back(url);
     scoped_refptr<StandaloneExecutor> executor = new StandaloneExecutor(
         profile, source_url, extension_id, action_id);
     executor->Execute(urls);
     return true;
   }
   return false;
 }
 
-void ViewFile(const FilePath& full_path, bool enqueue) {
-  if (!TryOpeningFileBrowser(full_path) && !TryViewingFile(full_path)) {
-    Browser* browser = BrowserList::GetLastActive();
-    if (!browser)
-      return;
+void ViewFile(const FilePath& path) {
+  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
+  if (!TryOpeningFileBrowser(profile, path) &&
+      !TryViewingFile(profile, path)) {
+    Browser* browser = Browser::GetOrCreateTabbedBrowser(profile);
     browser::ShowErrorBox(
         browser->window()->GetNativeHandle(),
         l10n_util::GetStringFUTF16(
             IDS_FILE_BROWSER_ERROR_VIEWING_FILE_TITLE,
-            UTF8ToUTF16(full_path.BaseName().value())),
+            UTF8ToUTF16(path.BaseName().value())),
         l10n_util::GetStringUTF16(
             IDS_FILE_BROWSER_ERROR_VIEWING_FILE));
   }
 }
 
 // Reads an entire file into a string. Fails is the file is 4K or longer.
 bool ReadSmallFileToString(const FilePath& path, std::string* contents) {
   FILE* file = file_util::OpenFile(path, "rb");
   if (!file) {
     return false;
   }
 
   char buf[1 << 12];  // 4K
   size_t len = fread(buf, 1, sizeof(buf), file);
   if (len > 0) {
     contents->append(buf, len);
   }
   file_util::CloseFile(file);
 
   return len < sizeof(buf);
 }
 
 void OpenUrlOnUIThread(const GURL& url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser)
-    return;
+  Browser* browser = Browser::GetOrCreateTabbedBrowser(
+      ProfileManager::GetDefaultProfileOrOffTheRecord());
   browser->AddSelectedTabWithURL(url, content::PAGE_TRANSITION_LINK);
 }
 
 // Reads JSON from a Google Docs file, extracts a document url and opens it
 // in a tab.
 void ReadUrlFromGDocOnFileThread(const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   std::string contents;
   if (!ReadSmallFileToString(file_path, &contents)) {
     LOG(ERROR) << "Error reading " << file_path.value();
     return;
   }
 
   scoped_ptr<base::Value> root_value;
   root_value.reset(base::JSONReader::Read(contents));
 
   DictionaryValue* dictionary_value;
   std::string edit_url_string;
   if (!root_value.get() ||
       !root_value->GetAsDictionary(&dictionary_value) ||
       !dictionary_value->GetString("url", &edit_url_string)) {
     LOG(ERROR) << "Invalid JSON in " << file_path.value();
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(OpenUrlOnUIThread, GURL(edit_url_string)));
 }
 
-bool TryViewingFile(const FilePath& full_path) {
+bool TryViewingFile(Profile* profile, const FilePath& path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // There is nothing we can do if the browser is not present.
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser)
-    return true;
+  Browser* browser = Browser::GetOrCreateTabbedBrowser(profile);
 
-  std::string file_extension = full_path.Extension();
+  std::string file_extension = path.Extension();
   // For things supported natively by the browser, we should open it
   // in a tab.
   if (IsSupportedBrowserExtension(file_extension.data()) ||
-      ShouldBeOpenedWithPdfPlugin(file_extension.data())) {
-    GURL page_url =  net::FilePathToFileURL(full_path);
+      ShouldBeOpenedWithPdfPlugin(profile, file_extension.data())) {
+    GURL page_url = net::FilePathToFileURL(path);
 #if defined(OS_CHROMEOS)
     // Override gdata resource to point to internal handler instead of file:
     // URL.
-    // There is nothing we can do if the browser is not present.
-    if (gdata::util::GetSpecialRemoteRootPath().IsParent(full_path)) {
+    if (gdata::util::GetSpecialRemoteRootPath().IsParent(path)) {
       gdata::GDataSystemService* system_service =
-          gdata::GDataSystemServiceFactory::GetForProfile(browser->profile());
+          gdata::GDataSystemServiceFactory::GetForProfile(profile);
       if (!system_service)
         return false;
 
       GetFilePropertiesDelegate delegate;
       system_service->file_system()->FindFileByPathSync(
-          gdata::util::ExtractGDataPath(full_path), &delegate);
+          gdata::util::ExtractGDataPath(path), &delegate);
       if (delegate.resource_id().empty())
         return false;
-      page_url =  gdata::util::GetFileResourceUrl(delegate.resource_id(),
-                                                  delegate.file_name());
+      page_url = gdata::util::GetFileResourceUrl(delegate.resource_id(),
+                                                 delegate.file_name());
     }
 #endif
     browser->AddSelectedTabWithURL(page_url,
                                    content::PAGE_TRANSITION_LINK);
     return true;
   }
 
   if (IsSupportedGDocsExtension(file_extension.data())) {
-    if (gdata::util::GetSpecialRemoteRootPath().IsParent(full_path)) {
+    if (gdata::util::GetSpecialRemoteRootPath().IsParent(path)) {
       // The file is on Google Docs. Get the Docs from the GData service.
       gdata::GDataSystemService* system_service =
-          gdata::GDataSystemServiceFactory::GetForProfile(browser->profile());
+          gdata::GDataSystemServiceFactory::GetForProfile(profile);
       if (!system_service)
         return false;
 
       GetFilePropertiesDelegate delegate;
       system_service->file_system()->FindFileByPathSync(
-          gdata::util::ExtractGDataPath(full_path), &delegate);
+          gdata::util::ExtractGDataPath(path), &delegate);
       if (delegate.edit_url().spec().empty())
         return false;
 
       browser->AddSelectedTabWithURL(delegate.edit_url(),
                                      content::PAGE_TRANSITION_LINK);
     } else {
       // The file is local (downloaded from an attachment or otherwise copied).
       // Parse the file to extract the Docs url and open this url.
       BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-          base::Bind(&ReadUrlFromGDocOnFileThread, full_path));
+          base::Bind(&ReadUrlFromGDocOnFileThread, path));
     }
     return true;
   }
 
 #if defined(OS_CHROMEOS)
   if (IsSupportedAVExtension(file_extension.data())) {
+    GURL url;
+    if (!ConvertFileToFileSystemUrl(profile, path,
+        GetFileBrowserExtensionUrl().GetOrigin(), &url))
+      return false;
     MediaPlayer* mediaplayer = MediaPlayer::GetInstance();
-    mediaplayer->PopupMediaPlayer(browser);
-    mediaplayer->ForcePlayMediaFile(browser->profile(), full_path);
+    mediaplayer->PopupMediaPlayer();
+    mediaplayer->ForcePlayMediaURL(url);
     return true;
   }
 #endif  // OS_CHROMEOS
 
   if (IsCRXFile(file_extension.data())) {
-    InstallCRX(browser->profile(), full_path);
+    InstallCRX(profile, path);
     return true;
   }
 
   // Unknown file type. Record UMA and show an error message.
   size_t extension_index = UMAExtensionIndex(file_extension.data(),
                                              kUMATrackingExtensions,
                                              arraysize(kUMATrackingExtensions));
   UMA_HISTOGRAM_ENUMERATION("FileBrowser.OpeningFileType",
                             extension_index,
                             arraysize(kUMATrackingExtensions) - 1);
   return false;
 }
 
-void InstallCRX(Profile* profile, const FilePath& full_path) {
+void InstallCRX(Profile* profile, const FilePath& path) {
   ExtensionService* service = profile->GetExtensionService();
   CHECK(service);
   if (!service)
     return;
 
   scoped_refptr<CrxInstaller> installer(CrxInstaller::Create(service,
                                             new ExtensionInstallUI(profile)));
   installer->set_is_gallery_install(false);
   installer->set_allow_silent_install(false);
-  installer->InstallCrx(full_path);
+  installer->InstallCrx(path);
 }
 
 // If pdf plugin is enabled, we should open pdf files in a tab.
-bool ShouldBeOpenedWithPdfPlugin(const char* file_extension) {
+bool ShouldBeOpenedWithPdfPlugin(Profile* profile, const char* file_extension) {
   if (base::strcasecmp(file_extension, kPdfExtension) != 0)
     return false;
 
-  Browser* browser = BrowserList::GetLastActive();
-  if (!browser)
-    return false;
-
   FilePath pdf_path;
   PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_path);
 
   webkit::WebPluginInfo plugin;
   if (!PluginService::GetInstance()->GetPluginInfoByPath(pdf_path, &plugin))
     return false;
 
-  PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(browser->profile());
+  PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(profile);
   if (!plugin_prefs)
     return false;
 
   return plugin_prefs->IsPluginEnabled(plugin);
 }
 
 ListValue* ProgressStatusVectorToListValue(
     Profile* profile, const GURL& origin_url,
     const std::vector<GDataOperationRegistry::ProgressStatus>& list) {
   scoped_ptr<ListValue> result_list(new ListValue());
   for (std::vector<
           GDataOperationRegistry::ProgressStatus>::const_iterator iter =
               list.begin();
        iter != list.end(); ++iter) {
     result_list->Append(
         ProgessStatusToDictionaryValue(profile, origin_url, *iter));
   }
   return result_list.release();
 }
 
 }  // namespace file_manager_util