ChromeOS: Support opening files with apps from the downloads page.

chrome/browser/chromeos/extensions/file_manager/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/file_manager_util.h"
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.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"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/drive/file_system.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_browser_handler.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_handler_util.h"
 #include "chrome/browser/chromeos/media/media_player.h"
+#include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/google_apis/task_util.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_iterator.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/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/chromeos_switches.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"
+#include "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/screen.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_mount_point_provider.h"
 #include "webkit/browser/fileapi/file_system_operation.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 #include "webkit/common/fileapi/file_system_util.h"
 #include "webkit/plugins/webplugininfo.h"
 
 using base::DictionaryValue;
 using base::ListValue;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::PluginService;
 using content::UserMetricsAction;
+using extensions::app_file_handler_util::FindFileHandlersForFiles;
+using extensions::app_file_handler_util::PathAndMimeTypeSet;
 using extensions::Extension;
 using file_handler_util::FileTaskExecutor;
 using fileapi::FileSystemURL;
 
 const char kFileBrowserDomain[] = "hhaomjibdihmijegdhdafkllkbggdgoj";
 
 const char kFileBrowserGalleryTaskId[] = "gallery";
 const char kFileBrowserMountArchiveTaskId[] = "mount-archive";
 const char kFileBrowserWatchTaskId[] = "watch";
 const char kFileBrowserPlayTaskId[] = "play";
@@ skipping 229 matching lines @@
   if (!external_provider)
     return false;
   external_provider->GrantFullAccessToExtension(GetFileBrowserUrl().host());
   return true;
 }
 
 // Executes handler specifed with |extension_id| and |action_id| for |url|.
 void ExecuteHandler(Profile* profile,
                     std::string extension_id,
                     std::string action_id,
-                    const GURL& url) {
+                    const GURL& url,
+                    const std::string& task_type) {
   // If File Browser has not been open yet then it did not request access
   // to the file system. Do it now.
   if (!GrantFileSystemAccessToFileBrowser(profile))
     return;
 
   GURL site = extensions::ExtensionSystem::Get(profile)->extension_service()->
       GetSiteForExtensionId(kFileBrowserDomain);
   fileapi::FileSystemContext* file_system_context =
       BrowserContext::GetStoragePartitionForSite(profile, site)->
           GetFileSystemContext();
 
   // We are executing the task on behalf of File Browser extension.
   const GURL source_url = GetFileBrowserUrl();
   std::vector<FileSystemURL> urls;
   urls.push_back(file_system_context->CrackURL(url));
   scoped_refptr<FileTaskExecutor> executor = FileTaskExecutor::Create(profile,
       source_url, kFileBrowserDomain, 0 /* no tab id */, extension_id,
-      file_handler_util::kTaskFile, action_id);
+      task_type, action_id);
   executor->Execute(urls);
 }
 
 // The |mode| argument is only for legacy Files.app. Files.app V2 has the
 // reusing logic in background.js.
 void OpenFileBrowserImpl(const base::FilePath& path,
                          TAB_REUSE_MODE mode,
                          const std::string& action_id) {
   content::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
   Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
 
   if (IsFileManagerPackaged() && !path.value().empty()) {
     GURL url;
     if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &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);
+    ExecuteHandler(profile, kFileBrowserDomain, action_id, url,
+                   file_handler_util::kTaskFile);
     return;
   }
 
   if (FileManagerTabExists(path, mode))
     return;
 
   std::string url = chrome::kChromeUIFileManagerURL;
   if (action_id.size()) {
     DictionaryValue arg_value;
     arg_value.SetString("action", action_id);
@@ skipping 37 matching lines @@
     for (int idx = 0; idx < tab_strip->count(); idx++) {
       content::WebContents* web_contents = tab_strip->GetWebContentsAt(idx);
       const GURL& url = web_contents->GetURL();
       if (url == target_url)
         return browser;
     }
   }
   return NULL;
 }
 
-bool ExecuteDefaultHandler(Profile* profile, const base::FilePath& path) {
-  GURL url;
-  if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &url))
+bool ExecuteDefaultAppHandler(Profile* profile,
+                              const base::FilePath& path,
+                              const GURL& url,
+                              const std::string& mime_type,
+                              const std::string& default_task_id) {
+  ExtensionService* service = profile->GetExtensionService();
+  if (!service)
     return false;
 
-  const FileBrowserHandler* handler;
-  if (!file_handler_util::GetTaskForURLAndPath(profile, url, path, &handler))
-    return false;
+  PathAndMimeTypeSet files;
+  files.insert(std::make_pair(path, mime_type));
+  const extensions::FileHandlerInfo* first_handler = NULL;
+  const extensions::Extension* extension_for_first_handler = NULL;
 
-  std::string extension_id = handler->extension_id();
-  std::string action_id = handler->id();
+  // If we find the default handler, we execute it immediately, but otherwise,
+  // we remember the first handler, and if there was no default handler, simply
+  // execute the first one.
+  for (ExtensionSet::const_iterator iter = service->extensions()->begin();
+       iter != service->extensions()->end();
+       ++iter) {
+    const Extension* extension = *iter;
+
+    // We don't support using hosted apps to open files.

[mtomasz, 2013/06/07 02:36:00]

This comment is misleading. is_platform_app disallows not only hosted apps but
also legacy packaged apps? Do we want to disallow legacy packaged apps?

[Sam McNally, 2013/06/07 05:29:13]

This is copied from the check in file_manager_private_api. It looks like this
check is correct; file handlers aren't supported by legacy packaged apps.

+    if (!extension->is_platform_app())
+      continue;
+
+    // We only support apps that specify "incognito: split" if in incognito

[mtomasz, 2013/06/07 02:36:00]

I'm wondering if this behavior is documented somewhere so 3rd party engineers
will know why their state-less simple app is never handling files in incognito.

[Sam McNally, 2013/06/07 05:29:13]

Same as above. This check may be unnecessary though; incognito: spanning isn't
allowed for non-legacy packaged apps.

+    // mode.
+    if (profile->IsOffTheRecord() &&
+        !service->IsIncognitoEnabled(extension->id()))
+      continue;
+
+    typedef std::vector<const extensions::FileHandlerInfo*> FileHandlerList;
+    FileHandlerList file_handlers = FindFileHandlersForFiles(*extension, files);
+    for (FileHandlerList::iterator i = file_handlers.begin();
+         i != file_handlers.end(); ++i) {
+      const extensions::FileHandlerInfo* handler = *i;
+      std::string task_id = file_handler_util::MakeTaskID(extension->id(),
+          file_handler_util::kTaskApp, handler->id);
+      if (task_id == default_task_id) {
+        ExecuteHandler(profile, extension->id(), handler->id, url,
+                       file_handler_util::kTaskApp);
+        return true;
+
+      } else if (!first_handler) {
+        first_handler = handler;
+        extension_for_first_handler = extension;
+      }
+    }
+  }
+  if (first_handler) {
+    ExecuteHandler(profile, extension_for_first_handler->id(),
+                   first_handler->id, url, file_handler_util::kTaskApp);
+    return true;
+  }
+  return false;
+}
+
+bool ExecuteExtensionHandler(Profile* profile,
+                             const base::FilePath& path,
+                             const FileBrowserHandler& handler,
+                             const GURL& url) {
+  std::string extension_id = handler.extension_id();
+  std::string action_id = handler.id();
   Browser* browser = chrome::FindLastActiveWithProfile(profile,
       chrome::HOST_DESKTOP_TYPE_ASH);
 
   // 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);
+        ExecuteHandler(profile, extension_id, action_id, url,
+                       file_handler_util::kTaskFile);
         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.
       OpenFileBrowserImpl(path, REUSE_SAME_PATH, "");
       return true;
     }
     return ExecuteBuiltinHandler(browser, path, action_id);
   }
 
-  ExecuteHandler(profile, extension_id, action_id, url);
+  ExecuteHandler(profile, extension_id, action_id, url,
+                 file_handler_util::kTaskFile);
   return true;
 }
 
+bool ExecuteDefaultHandler(Profile* profile, const base::FilePath& path) {
+  GURL url;
+  if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &url))
+    return false;
+
+  std::string mime_type = GetMimeTypeForPath(path);
+  std::string default_task_id = file_handler_util::GetDefaultTaskIdFromPrefs(
+      profile, mime_type, path.Extension());
+  const FileBrowserHandler* handler;
+
+  // We choose the file handler from the following in decreasing priority or
+  // fail if none support the file type:
+  // 1. default extension

[mtomasz, 2013/06/07 02:36:00]

default extensions before apps, but non-default apps before non-default
extensions? Is it correct?

[Sam McNally, 2013/06/07 05:29:13]

Yes, but there can be at most one default handler.

+  // 2. default app
+  // 3. a fallback handler (e.g. opening in the browser)
+  // 4. non-default app
+  // 5. non-default extension
+  // Note that there can be at most one of default extension and default app.
+  if (!file_handler_util::GetTaskForURLAndPath(profile, url, path, &handler)) {
+    return ExecuteDefaultAppHandler(
+        profile, path, url, mime_type, default_task_id);
+  }
+
+  std::string handler_task_id = file_handler_util::MakeTaskID(
+        handler->extension_id(), file_handler_util::kTaskFile, handler->id());
+  if (handler_task_id != default_task_id &&
+      !file_handler_util::IsFallbackTask(handler) &&
+      ExecuteDefaultAppHandler(
+          profile, path, url, mime_type, default_task_id)) {
+    return true;
+  }
+  return ExecuteExtensionHandler(profile, path, *handler, url);
+}
+
 // Reads the alternate URL from a GDoc file. When it fails, returns a file URL
 // for |file_path| as fallback.
 // Note that an alternate url is a URL to open a hosted document.
 GURL ReadUrlFromGDocOnBlockingPool(const base::FilePath& file_path) {
   GURL url = drive::util::ReadUrlFromGDocFile(file_path);
   if (url.is_empty())
     url = net::FilePathToFileURL(file_path);
   return url;
 }
 
@@ skipping 411 matching lines @@
 
 // If a bundled plugin is enabled, we should open pdf/swf files in a tab.
 bool ShouldBeOpenedWithPlugin(Profile* profile, const char* file_extension) {
   if (LowerCaseEqualsASCII(file_extension, kPdfExtension))
     return IsPdfPluginEnabled(profile);
   if (LowerCaseEqualsASCII(file_extension, kSwfExtension))
     return IsFlashPluginEnabled(profile);
   return false;
 }
 
+std::string GetMimeTypeForPath(const base::FilePath& file_path) {
+  const base::FilePath::StringType file_extension =
+      StringToLowerASCII(file_path.Extension());
+
+  // TODO(thorogood): Rearchitect this call so it can run on the File thread;
+  // GetMimeTypeFromFile requires this on Linux. Right now, we use
+  // Chrome-level knowledge only.
+  std::string mime_type;
+  if (file_extension.empty() ||
+      !net::GetWellKnownMimeTypeFromExtension(file_extension.substr(1),
+                                              &mime_type)) {
+    // If the file doesn't have an extension or its mime-type cannot be
+    // determined, then indicate that it has the empty mime-type. This will
+    // only be matched if the Web Intents accepts "*" or "*/*".
+    return "";
+  } else {
+    return mime_type;
+  }
+}
+
 }  // namespace file_manager_util