Packaged Files app: open files from Downloads tab

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 "ash/shell.h"
 #include "base/bind.h"
+#include "base/command_line.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/drive/drive.pb.h"
@@ skipping 13 matching lines @@
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/browser/ui/simple_message_box.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/file_browser_handler.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/storage_partition.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/pepper_plugin_info.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
@@ skipping 389 matching lines @@
           }
           return true;
         }
       }
     }
   }
 
   return false;
 }
 
+bool IsFileManagerPackaged() {
+  const CommandLine* command_line = CommandLine::ForCurrentProcess();
+  return command_line->HasSwitch(switches::kFileManagerPackaged);
+}
+
+void ExecuteHandler(Profile* profile,
+                    std::string extension_id,
+                    std::string action_id,
+                    const GURL& url) {
+  // 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::GetDefaultStoragePartition(
+          profile)->GetFileSystemContext()->external_provider();
+  if (!external_provider)
+    return;
+  external_provider->GrantFullAccessToExtension(source_url.host());
+
+  std::vector<GURL> urls;
+  urls.push_back(url);
+  scoped_refptr<FileTaskExecutor> executor = FileTaskExecutor::Create(profile,
+      source_url, 0 /* no tab id */, extension_id,
+      file_handler_util::kTaskFile, action_id);
+  executor->Execute(urls);
+}
+
 void OpenFileBrowser(const FilePath& path,
                      TAB_REUSE_MODE mode,
-                     const std::string& flag_name) {
+                     const std::string& action_id) {
+  content::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
+
   if (FileManageTabExists(path, mode))
     return;
 
   Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
 
+  if (IsFileManagerPackaged() && !path.value().empty()) {
+    GURL url;
+    if (!ConvertFileToFileSystemUrl(profile, path,
+        GetFileBrowserExtensionUrl().GetOrigin(), &url))
+      return;
+
+    // Some values of |action_id| are not listed in the manifest and are used
+    // to parametrize the behavior when opening the Files app window.
+    ExecuteHandler(profile, kFileBrowserDomain, action_id, url);
+    return;
+  }
+
   std::string url = chrome::kChromeUIFileManagerURL;
-  if (flag_name.size()) {
+  if (action_id.size()) {
     DictionaryValue arg_value;
-    arg_value.SetBoolean(flag_name, "true");
+    arg_value.SetString("action", action_id);
     std::string query;
     base::JSONWriter::Write(&arg_value, &query);
     url += "?" + net::EscapeUrlEncodedData(query, false);
   }
   if (!path.empty()) {
     FilePath virtual_path;
     if (!ConvertFileToRelativeFileSystemPath(profile, path, &virtual_path))
       return;
     url += "#/" + net::EscapeUrlEncodedData(virtual_path.value(), false);
   }
 
   ExtensionService* service = profile->GetExtensionService();
   if (!service)
     return;
 
   const extensions::Extension* extension =
       service->GetExtensionById(kFileBrowserDomain, false);
   if (!extension)
     return;
 
-  content::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
   application_launch::LaunchParams params(profile, extension,
                                           extension_misc::LAUNCH_WINDOW,
                                           NEW_FOREGROUND_TAB);
   params.override_url = GURL(url);
   application_launch::OpenApplication(params);
 }
 
 Browser* GetBrowserForUrl(GURL target_url) {
   for (BrowserList::const_iterator browser_iterator = BrowserList::begin();
        browser_iterator != BrowserList::end(); ++browser_iterator) {
     Browser* browser = *browser_iterator;
     TabStripModel* tab_strip = browser->tab_strip_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 (url == target_url)
         return browser;
     }
   }
   return NULL;
 }
 
 void ViewRemovableDrive(const FilePath& path) {
-  OpenFileBrowser(path, REUSE_ANY_FILE_MANAGER, "mountTriggered");
+  OpenFileBrowser(path, REUSE_ANY_FILE_MANAGER, "auto-open");
 }
 
 void OpenActionChoiceDialog(const FilePath& path) {
   const int kDialogWidth = 394;
   // TODO(dgozman): remove 50, which is a title height once popup window
   // will have no title.
   const int kDialogHeight = 316 + 50;
 
   Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
 
@@ skipping 20 matching lines @@
                                             profile));
 
     chrome::AddSelectedTabWithURL(browser, dialog_url,
                                   content::PAGE_TRANSITION_LINK);
   }
   browser->window()->Show();
 }
 
 void ShowFileInFolder(const FilePath& path) {
   // This action changes the selection so we do not reuse existing tabs.
-  OpenFileBrowser(path, REUSE_NEVER, "selectOnly");
+  OpenFileBrowser(path, REUSE_NEVER, "select");
 }
 
 void ViewFolder(const FilePath& path) {
-  OpenFileBrowser(path, REUSE_SAME_PATH, std::string());
+  OpenFileBrowser(path, REUSE_SAME_PATH, "open");
 }
 
 void OpenApplication() {
-  OpenFileBrowser(FilePath(), REUSE_NEVER, std::string());
+  OpenFileBrowser(FilePath(), REUSE_NEVER, "");
 }
 
 bool ExecuteDefaultHandler(Profile* profile, const FilePath& path) {
   GURL url;
   if (!ConvertFileToFileSystemUrl(profile, path,
       GetFileBrowserExtensionUrl().GetOrigin(), &url))
     return false;
 
   const FileBrowserHandler* handler;
   if (!file_handler_util::GetTaskForURL(profile, url, &handler))
     return false;
 
   std::string extension_id = handler->extension_id();
   std::string action_id = handler->id();
   Browser* browser = browser::FindLastActiveWithProfile(profile);
 
   // If there is no browsers for the profile, bail out. Return true so warning
   // about file type not being supported is not displayed.
   if (!browser)
     return true;
 
   if (extension_id == kFileBrowserDomain) {
+    if (IsFileManagerPackaged()) {
+      if (action_id == kFileBrowserGalleryTaskId ||
+          action_id == kFileBrowserMountArchiveTaskId ||
+          action_id == kFileBrowserPlayTaskId ||
+          action_id == kFileBrowserWatchTaskId) {
+        ExecuteHandler(profile, extension_id, action_id, url);
+        return true;
+      }
+      return ExecuteBuiltinHandler(browser, path, action_id);
+    }
+
     // Only two of the built-in File Browser tasks require opening the File
     // Browser tab.
     if (action_id == kFileBrowserGalleryTaskId ||
         action_id == kFileBrowserMountArchiveTaskId) {
       // 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 {
-      return ExecuteBuiltinHandler(browser, path, action_id);
     }
-  } else {
-    // We are executing the task on behalf of File Browser extension.
-    const GURL source_url(kBaseFileBrowserUrl);
+    return ExecuteBuiltinHandler(browser, path, action_id);
+  }
 
-    // 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::GetDefaultStoragePartition(
-            profile)->GetFileSystemContext()->external_provider();
-    if (!external_provider)
-      return false;
-    external_provider->GrantFullAccessToExtension(source_url.host());
-
-    std::vector<GURL> urls;
-    urls.push_back(url);
-    scoped_refptr<FileTaskExecutor> executor = FileTaskExecutor::Create(profile,
-        source_url, 0 /* no tab id */, extension_id,
-        file_handler_util::kTaskFile, action_id);
-    executor->Execute(urls);
-    return true;
-  }
-  return ExecuteBuiltinHandler(browser, path, std::string());
+  ExecuteHandler(profile, extension_id, action_id, url);
+  return true;
 }
 
 void ViewFile(const FilePath& path) {
   Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
   if (!ExecuteDefaultHandler(profile, path))
     ShowWarningMessageBox(profile, path);
 }
 
 // Reads an entire file into a string. Fails is the file is 4K or longer.
 bool ReadSmallFileToString(const FilePath& path, std::string* contents) {
@@ skipping 82 matching lines @@
                      drive::HOSTED_DOCUMENT));
     } 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, path));
     }
     return true;
   }
 
-  if (internal_task_id == kFileBrowserPlayTaskId) {
-    GURL url;
-    if (!ConvertFileToFileSystemUrl(profile, path,
-        GetFileBrowserExtensionUrl().GetOrigin(), &url))
-      return false;
-    MediaPlayer* mediaplayer = MediaPlayer::GetInstance();
-    mediaplayer->PopupMediaPlayer();
-    mediaplayer->ForcePlayMediaURL(url);
-    return true;
-  }
-  if (internal_task_id == kFileBrowserWatchTaskId) {
-    GURL url;
-    if (!ConvertFileToFileSystemUrl(profile, path,
-        GetFileBrowserExtensionUrl().GetOrigin(), &url))
-      return false;
+  if (!IsFileManagerPackaged()) {
+    if (internal_task_id == kFileBrowserPlayTaskId) {
+      GURL url;
+      if (!ConvertFileToFileSystemUrl(profile, path,
+          GetFileBrowserExtensionUrl().GetOrigin(), &url))
+        return false;
+      MediaPlayer* mediaplayer = MediaPlayer::GetInstance();
+      mediaplayer->PopupMediaPlayer();
+      mediaplayer->ForcePlayMediaURL(url);
+      return true;
+    }
+    if (internal_task_id == kFileBrowserWatchTaskId) {
+      GURL url;
+      if (!ConvertFileToFileSystemUrl(profile, path,
+          GetFileBrowserExtensionUrl().GetOrigin(), &url))
+        return false;
 
-    ExtensionService* service = profile->GetExtensionService();
-    if (!service)
-      return false;
+      ExtensionService* service = profile->GetExtensionService();
+      if (!service)
+        return false;
 
-    const extensions::Extension* extension =
-      service->GetExtensionById(kFileBrowserDomain, false);
-    if (!extension)
-      return false;
+      const extensions::Extension* extension =
+        service->GetExtensionById(kFileBrowserDomain, false);
+      if (!extension)
+        return false;
 
-    application_launch::LaunchParams params(profile, extension,
-                                            extension_misc::LAUNCH_WINDOW,
-                                            NEW_FOREGROUND_TAB);
-    params.override_url = GetVideoPlayerUrl(url);
-    application_launch::OpenApplication(params);
-    return true;
+      application_launch::LaunchParams params(profile, extension,
+                                              extension_misc::LAUNCH_WINDOW,
+                                              NEW_FOREGROUND_TAB);
+      params.override_url = GetVideoPlayerUrl(url);
+      application_launch::OpenApplication(params);
+      return true;
+    }
   }
 
   if (IsCRXFile(file_extension.data())) {
     if (drive::util::IsUnderDriveMountPoint(path)) {
       drive::DriveSystemService* system_service =
           drive::DriveSystemServiceFactory::GetForProfile(profile);
       if (!system_service)
         return false;
       system_service->file_system()->GetFileByPath(
           drive::util::ExtractDrivePath(path),
@@ skipping 58 matching lines @@
   for (google_apis::OperationProgressStatusList::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