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/file_util.h"
 #include "base/json/json_file_value_serializer.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_system_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 "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/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_operation.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/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;
 
 #define FILEBROWSER_EXTENSON_ID "hhaomjibdihmijegdhdafkllkbggdgoj"
 const char kFileBrowserDomain[] = FILEBROWSER_EXTENSON_ID;
 
 const char kFileBrowserGalleryTaskId[] = "gallery";
 const char kFileBrowserMountArchiveTaskId[] = "mount-archive";
 const char kFileBrowserWatchTaskId[] = "watch";
@@ skipping 250 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);
 }
 
 void OpenFileBrowserImpl(const base::FilePath& path,
                          TAB_REUSE_MODE mode,
                          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, 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;
   }
 
   std::string url = chrome::kChromeUIFileManagerURL;
   if (action_id.size()) {
     DictionaryValue arg_value;
     arg_value.SetString("action", action_id);
     std::string query;
     base::JSONWriter::Write(&arg_value, &query);
     url += "?" +
@@ skipping 34 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 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;
+
+  PathAndMimeTypeSet files;
+  files.insert(std::make_pair(path, mime_type));
+  const extensions::FileHandlerInfo* first_handler = NULL;
+  const extensions::Extension* extension_for_first_handler = NULL;
+
+  for (ExtensionSet::const_iterator iter = service->extensions()->begin();

[Matt Giuca, 2013/05/09 04:58:22]

Explain the algorithm overall.

// 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.

[Sam McNally, 2013/05/09 07:31:35]

Done.

+       iter != service->extensions()->end();
+       ++iter) {
+    const Extension* extension = *iter;
+
+    // We don't support using hosted apps to open files.
+    if (!extension->is_platform_app())
+      continue;
+
+    if (profile->IsOffTheRecord() &&

[Matt Giuca, 2013/05/09 04:58:22]

What does this mean? Can you add a comment?

[Sam McNally, 2013/05/09 07:31:35]

Done.

[Matt Giuca, 2013/05/09 08:56:58]

Can you put quotes around "incognito: split". It's hard to read as is.

[Sam McNally, 2013/05/09 23:27:44]

Done.

+        !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 ExecuteDefaultHandler(Profile* profile, const base::FilePath& path) {
   GURL url;
   if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &url))
     return false;
 
+  std::string mime_type = GetMimeTypeForPath(path);

[Matt Giuca, 2013/05/09 04:58:22]

Explain the approach you are taking in comments here.

[Sam McNally, 2013/05/09 07:31:35]

Done.

+  std::string default_task_id = file_handler_util::GetDefaultTaskIdFromPrefs(
+      profile, mime_type, path.Extension());
   const FileBrowserHandler* handler;
-  if (!file_handler_util::GetTaskForURLAndPath(profile, url, path, &handler))
-    return false;
+  if (!file_handler_util::GetTaskForURLAndPath(profile, url, path, &handler)) {

[Matt Giuca, 2013/05/09 04:58:22]

I think this could be clearer. It seems as though there are two possibilities:
1. It is handled by an extension.
2. Else, it is handled by an app.
3. Else, fail.

The code currently (in this CL) is structured like this:

if (it can not be handled by an extension) {
  do app handling stuff in a subroutine (succeed or fail)
}
do extension handling stuff right here (succeed or fail)

It seems like a more readable approach would be:

if (it can be handled by an extension) {
  do extension handling stuff in a subroutine (succeed or fail)
} else {
  do app handling stuff in a subroutine (succeed or fail)
}

This would involve moving all of the code after this if statement out into
another function, ExecuteDefaultExtensionHandler, but I think it would be more
understandable.

[Sam McNally, 2013/05/09 07:31:35]

Done.

+    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 && ExecuteDefaultAppHandler(
+      profile, path, url, mime_type, default_task_id)) {
+    return true;
+  }
 
   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;
 }
 
 // Reads JSON from a Google Docs file and extracts a document url. When the file
 // is not in GDoc format, returns a file URL for |file_path| as fallback.
 GURL ReadUrlFromGDocOnBlockingPool(const base::FilePath& file_path) {
   const int64 kMaxGDocSize = 4096;
   int64 file_size = 0;
   if (!file_util::GetFileSize(file_path, &file_size) ||
       file_size > kMaxGDocSize) {
@@ skipping 429 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