Introduce a FileHandlerInfo structure seperate to web intents for platform apps.

For now we check both intents and file handlers in the platform app launching
code, but once intents go away from extensions entirely we can remove the extra
check.

R=benwells@chromium.org
TBR=jhawkins@chromium.org

Review URL: https://chromiumcodereview.appspot.com/11312034

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@169191 0039d316-1c4b-4281-b951-d872f2087c98

4 files changed, 167 insertions, 18 deletions

diff --git a/chrome/browser/chromeos/extensions/file_browser_private_api.cc b/chrome/browser/chromeos/extensions/file_browser_private_api.cc
index da0cbeb..f5e4cad 100644
--- a/chrome/browser/chromeos/extensions/file_browser_private_api.cc
+++ b/chrome/browser/chromeos/extensions/file_browser_private_api.cc
@@ -34,6 +34,7 @@
 #include "chrome/browser/chromeos/extensions/file_handler_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/chromeos/system/statistics_provider.h"
+#include "chrome/browser/extensions/app_file_handler_util.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
@@ -75,6 +76,7 @@
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/glue/web_intent_service_data.h"
 
+using app_file_handler_util::FindFileHandlersForMimeTypes;
 using chromeos::disks::DiskMountManager;
 using content::BrowserContext;
 using content::BrowserThread;
@@ -793,17 +795,8 @@ bool GetFileTasksFileBrowserFunction::FindDriveAppTasks(
   return true;
 }
 
-// Find Web Intent platform apps that support the View task, and add them to
-// the |result_list|. These will be marked as kTaskWebIntent.
-bool GetFileTasksFileBrowserFunction::FindWebIntentTasks(
-    const std::vector<GURL>& file_urls,
-    ListValue* result_list) {
-  DCHECK(!file_urls.empty());
-  ExtensionService* service = profile_->GetExtensionService();
-  if (!service)
-    return false;
-
-  std::set<std::string> mime_types;
+static void GetMimeTypesForFileURLs(const std::vector<GURL>& file_urls,
+    std::set<std::string>* mime_types) {
   for (std::vector<GURL>::const_iterator iter = file_urls.begin();
        iter != file_urls.end(); ++iter) {
     const FilePath file = FilePath(GURL(iter->spec()).ExtractFileName());
@@ -819,12 +812,81 @@ bool GetFileTasksFileBrowserFunction::FindWebIntentTasks(
       // 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 "*/*".
-      mime_types.insert("");
+      mime_types->insert("");
     } else {
-      mime_types.insert(mime_type);
+      mime_types->insert(mime_type);
+    }
+  }
+}
+
+bool GetFileTasksFileBrowserFunction::FindAppTasks(
+    const std::vector<GURL>& file_urls,
+    ListValue* result_list) {
+  DCHECK(!file_urls.empty());
+  ExtensionService* service = profile_->GetExtensionService();
+  if (!service)
+    return false;
+
+  std::set<std::string> mime_types;
+  GetMimeTypesForFileURLs(file_urls, &mime_types);
+
+  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.
+    if (!extension->is_platform_app())
+      continue;
+
+    if (profile_->IsOffTheRecord() &&
+        !service->IsIncognitoEnabled(extension->id()))
+      continue;
+
+    typedef std::vector<const Extension::FileHandlerInfo*> FileHandlerList;
+    FileHandlerList file_handlers =
+        FindFileHandlersForMimeTypes(*extension, mime_types);
+    // TODO(benwells): also support matching by file extension.
+    if (file_handlers.empty())
+      continue;
+
+    for (FileHandlerList::iterator i = file_handlers.begin();
+         i != file_handlers.end(); ++i) {
+      DictionaryValue* task = new DictionaryValue;
+      std::string task_id = file_handler_util::MakeTaskID(extension->id(),
+          file_handler_util::kTaskApp, (*i)->id);
+      task->SetString("taskId", task_id);
+      task->SetString("title", (*i)->title);
+      task->SetBoolean("isDefault", false);
+
+      GURL best_icon = extension->GetIconURL(kPreferredIconSize,
+                                             ExtensionIconSet::MATCH_BIGGER);
+      if (!best_icon.is_empty())
+        task->SetString("iconUrl", best_icon.spec());
+      else
+        task->SetString("iconUrl", kDefaultIcon);
+
+      task->SetBoolean("driveApp", false);
+      result_list->Append(task);
     }
   }
 
+  return true;
+}
+
+// Find Web Intent platform apps that support the View task, and add them to
+// the |result_list|. These will be marked as kTaskWebIntent.
+bool GetFileTasksFileBrowserFunction::FindWebIntentTasks(
+    const std::vector<GURL>& file_urls,
+    ListValue* result_list) {
+  DCHECK(!file_urls.empty());
+  ExtensionService* service = profile_->GetExtensionService();
+  if (!service)
+    return false;
+
+  std::set<std::string> mime_types;
+  GetMimeTypesForFileURLs(file_urls, &mime_types);
+
   for (ExtensionSet::const_iterator iter = service->extensions()->begin();
        iter != service->extensions()->end();
        ++iter) {
@@ -958,9 +1020,15 @@ bool GetFileTasksFileBrowserFunction::RunImpl() {
     result_list->Append(task);
   }
 
-  // Take the union of Web Intents (that platform apps may accept) and all
-  // previous Drive and extension tasks. As above, we know there aren't
-  // duplicates because they're entirely different kinds of tasks.
+  // Take the union of platform app file handlers, Web Intents that platform
+  // apps may accept, and all previous Drive and extension tasks. As above, we
+  // know there aren't duplicates because they're entirely different kinds of
+  // tasks.
+  if (!FindAppTasks(file_urls, result_list))
+    return false;
+
+  // TODO(benwells): remove the web intents tasks once we no longer support
+  // them.
   if (!FindWebIntentTasks(file_urls, result_list))
     return false;
 
diff --git a/chrome/browser/chromeos/extensions/file_browser_private_api.h b/chrome/browser/chromeos/extensions/file_browser_private_api.h
index e70c8ba..7fc0b31 100644
--- a/chrome/browser/chromeos/extensions/file_browser_private_api.h
+++ b/chrome/browser/chromeos/extensions/file_browser_private_api.h
@@ -172,6 +172,11 @@ class GetFileTasksFileBrowserFunction : public AsyncExtensionFunction {
   // types, appending them to the |result_list|.
   bool FindWebIntentTasks(const std::vector<GURL>& file_urls,
                           ListValue* result_list);
+
+  // Find the list of app file handlers that can be used with the given file
+  // types, appending them to the |result_list|.
+  bool FindAppTasks(const std::vector<GURL>& file_urls,
+                    ListValue* result_list);
 };
 
 // Implements the chrome.fileBrowserPrivate.executeTask method.
diff --git a/chrome/browser/chromeos/extensions/file_handler_util.cc b/chrome/browser/chromeos/extensions/file_handler_util.cc
index ed6473f..26ee7cb 100644
--- a/chrome/browser/chromeos/extensions/file_handler_util.cc
+++ b/chrome/browser/chromeos/extensions/file_handler_util.cc
@@ -55,6 +55,7 @@ namespace file_handler_util {
 const char kTaskFile[] = "file";
 const char kTaskDrive[] = "drive";
 const char kTaskWebIntent[] = "web-intent";
+const char kTaskApp[] = "app";
 
 namespace {
 
@@ -263,7 +264,8 @@ std::string MakeTaskID(const std::string& extension_id,
                        const std::string& action_id) {
   DCHECK(task_type == kTaskFile ||
          task_type == kTaskDrive ||
-         task_type == kTaskWebIntent);
+         task_type == kTaskWebIntent ||
+         task_type == kTaskApp);
   return base::StringPrintf("%s|%s|%s",
                             extension_id.c_str(),
                             task_type.c_str(),
@@ -313,7 +315,8 @@ bool CrackTaskID(const std::string& task_id,
     *task_type = result[1];
     DCHECK(*task_type == kTaskFile ||
            *task_type == kTaskDrive ||
-           *task_type == kTaskWebIntent);
+           *task_type == kTaskWebIntent ||
+           *task_type == kTaskApp);
   }
 
   if (action_id)
@@ -562,6 +565,27 @@ class WebIntentTaskExecutor : public FileTaskExecutor {
   const std::string action_id_;
 };
 
+class AppTaskExecutor : public FileTaskExecutor {
+ public:
+  // FileTaskExecutor overrides.
+  virtual bool ExecuteAndNotify(const std::vector<GURL>& file_urls,
+                                const FileTaskFinishedCallback& done) OVERRIDE;
+
+ private:
+  // FileTaskExecutor is the only class allowed to create one.
+  friend class FileTaskExecutor;
+
+  AppTaskExecutor(Profile* profile,
+                  const std::string& extension_id,
+                  const std::string& action_id);
+  virtual ~AppTaskExecutor();
+
+  bool ExecuteForURL(const GURL& file_url);
+
+  const std::string extension_id_;
+  const std::string action_id_;
+};
+
 // static
 FileTaskExecutor* FileTaskExecutor::Create(Profile* profile,
                                            const GURL source_url,
@@ -587,6 +611,11 @@ FileTaskExecutor* FileTaskExecutor::Create(Profile* profile,
                                      extension_id,
                                      action_id);
 
+  if (task_type == kTaskApp)
+    return new AppTaskExecutor(profile,
+                               extension_id,
+                               action_id);
+
   NOTREACHED();
   return NULL;
 }
@@ -1066,4 +1095,50 @@ bool WebIntentTaskExecutor::ExecuteForURL(const GURL& file_url) {
   return true;
 }
 
+AppTaskExecutor::AppTaskExecutor(
+    Profile* profile,
+    const std::string& extension_id,
+    const std::string& action_id)
+    : FileTaskExecutor(profile, extension_id),
+      action_id_(action_id) {
+}
+
+AppTaskExecutor::~AppTaskExecutor() {}
+
+bool AppTaskExecutor::ExecuteAndNotify(
+    const std::vector<GURL>& file_urls,
+    const FileTaskFinishedCallback& done) {
+  bool success = true;
+
+  for (std::vector<GURL>::const_iterator i = file_urls.begin();
+       i != file_urls.end(); ++i) {
+    if (!ExecuteForURL(*i))
+      success = false;
+  }
+
+  if (!done.is_null())
+    done.Run(success);
+
+  return true;
+}
+
+bool AppTaskExecutor::ExecuteForURL(const GURL& file_url) {
+  fileapi::FileSystemURL url(file_url);
+  if (!chromeos::CrosMountPointProvider::CanHandleURL(url))
+    return false;
+
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetDefaultStoragePartition(profile())->
+      GetFileSystemContext();
+  fileapi::ExternalFileSystemMountPointProvider* external_provider =
+      file_system_context->external_provider();
+  if (!external_provider || !external_provider->IsAccessAllowed(url))
+    return false;
+
+  FilePath local_path = url.path();
+  extensions::LaunchPlatformAppWithFileHandler(profile(), GetExtension(),
+      action_id_, local_path);
+  return true;
+}
+
 } // namespace file_handler_util
diff --git a/chrome/browser/chromeos/extensions/file_handler_util.h b/chrome/browser/chromeos/extensions/file_handler_util.h
index d06b196..69fd2e7 100644
--- a/chrome/browser/chromeos/extensions/file_handler_util.h
+++ b/chrome/browser/chromeos/extensions/file_handler_util.h
@@ -29,6 +29,7 @@ namespace file_handler_util {
 extern const char kTaskFile[];
 extern const char kTaskDrive[];
 extern const char kTaskWebIntent[];
+extern const char kTaskApp[];
 
 void UpdateFileHandlerUsageStats(Profile* profile, const std::string& task_id);