Files app: Prepare all information necessary for Arc task execution.

chrome/browser/chromeos/file_manager/file_tasks.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/file_manager/file_tasks.h"
 
 #include <stddef.h>
 
 #include <map>
 
 #include "apps/launcher.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/file_task_executor.h"
 #include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "chrome/browser/chromeos/file_manager/file_browser_handlers.h"
 #include "chrome/browser/chromeos/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/file_manager/open_util.h"
+#include "chrome/browser/extensions/api/file_handlers/mime_util.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/extensions/api/file_browser_handlers/file_browser_handler.h"
 #include "chrome/common/extensions/api/file_manager_private.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
@@ skipping 101 matching lines @@
     extension_misc::kQuickOfficeExtensionId,
   };
 
   for (size_t i = 0; i < arraysize(kBuiltInApps); ++i) {
     if (task.app_id == kBuiltInApps[i])
       return true;
   }
   return false;
 }
 
+void FindArcTasks(Profile* profile,
+                  const std::vector<extensions::EntryInfo>& entries,
+                  std::unique_ptr<std::vector<FullTaskDescriptor>> result_list,
+                  const FindTasksCallback& callback) {
+  // TODO(kinaba): implement.
+  callback.Run(std::move(result_list));
+}
+
+void ExecuteByArcAfterMimeTypesCollected(
+    Profile* profile,
+    const TaskDescriptor& task,
+    const std::vector<FileSystemURL>& file_urls,
+    const FileTaskFinishedCallback& done,
+    extensions::app_file_handler_util::MimeTypeCollector* mime_collector,
+    std::unique_ptr<std::vector<std::string>> mime_types) {
+  // TODO(kinaba): implement.
+  NOTIMPLEMENTED();
+  done.Run(extensions::api::file_manager_private::TASK_RESULT_FAILED);
+}
+
+void PostProcessFoundTasks(
+    Profile* profile,
+    const std::vector<extensions::EntryInfo>& entries,
+    const FindTasksCallback& callback,
+    std::unique_ptr<std::vector<FullTaskDescriptor>> result_list) {
+  // Google documents can only be handled by internal handlers.
+  if (ContainsGoogleDocument(entries))
+    KeepOnlyFileManagerInternalTasks(result_list.get());
+  ChooseAndSetDefaultTask(*profile->GetPrefs(), entries, result_list.get());
+  callback.Run(std::move(result_list));
+}
+
 }  // namespace
 
 FullTaskDescriptor::FullTaskDescriptor(
     const TaskDescriptor& task_descriptor,
     const std::string& task_title,
     const GURL& icon_url,
     bool is_default,
     bool is_generic_file_handler)
     : task_descriptor_(task_descriptor),
       task_title_(task_title),
@@ skipping 115 matching lines @@
   task->action_id = result[2];
 
   return true;
 }
 
 bool ExecuteFileTask(Profile* profile,
                      const GURL& source_url,
                      const TaskDescriptor& task,
                      const std::vector<FileSystemURL>& file_urls,
                      const FileTaskFinishedCallback& done) {
+  // ARC apps needs mime types for launching. Retrieve them first.
   if (task.task_type == TASK_TYPE_ARC_APP) {
-    NOTIMPLEMENTED();
-    return false;
+    extensions::app_file_handler_util::MimeTypeCollector* mime_collector =
+        new extensions::app_file_handler_util::MimeTypeCollector(profile);
+    mime_collector->CollectForURLs(
+        file_urls,
+        base::Bind(&ExecuteByArcAfterMimeTypesCollected, profile, task,
+                   file_urls, done, base::Owned(mime_collector)));
+    return true;
   }
 
   // drive::FileTaskExecutor is responsible to handle drive tasks.
   if (task.task_type == TASK_TYPE_DRIVE_APP) {
     DCHECK_EQ(kDriveAppActionID, task.action_id);
     drive::FileTaskExecutor* executor =
         new drive::FileTaskExecutor(profile, task.app_id);
     executor->Execute(file_urls, done);
     return true;
   }
@@ skipping 227 matching lines @@
         false /* is_generic_file_handler */));
   }
 }
 
 void FindAllTypesOfTasks(Profile* profile,
                          const drive::DriveAppRegistry* drive_app_registry,
                          const std::vector<extensions::EntryInfo>& entries,
                          const std::vector<GURL>& file_urls,
                          const FindTasksCallback& callback) {
   DCHECK(profile);
-  std::vector<FullTaskDescriptor> result_list;
+  std::unique_ptr<std::vector<FullTaskDescriptor>> result_list(
+      new std::vector<FullTaskDescriptor>);
 
   // Find Drive app tasks, if the drive app registry is present.
   if (drive_app_registry)
-    FindDriveAppTasks(*drive_app_registry, entries, &result_list);
+    FindDriveAppTasks(*drive_app_registry, entries, result_list.get());
 
   // Find and append file handler tasks. We know there aren't duplicates
   // because Drive apps and platform apps are entirely different kinds of
   // tasks.
-  FindFileHandlerTasks(profile, entries, &result_list);
+  FindFileHandlerTasks(profile, entries, result_list.get());
 
   // Find and append file browser handler tasks. We know there aren't
   // duplicates because "file_browser_handlers" and "file_handlers" shouldn't
   // be used in the same manifest.json.
-  FindFileBrowserHandlerTasks(profile, file_urls, &result_list);
+  FindFileBrowserHandlerTasks(profile, file_urls, result_list.get());
 
-  // Google documents can only be handled by internal handlers.
-  if (ContainsGoogleDocument(entries))
-    KeepOnlyFileManagerInternalTasks(&result_list);
-
-  ChooseAndSetDefaultTask(*profile->GetPrefs(), entries, &result_list);
-
-  callback.Run(result_list);
+  // Find and append ARC handler tasks.
+  FindArcTasks(profile, entries, std::move(result_list),
+               base::Bind(&PostProcessFoundTasks, profile, entries, callback));
 }
 
 void ChooseAndSetDefaultTask(const PrefService& pref_service,
                              const std::vector<extensions::EntryInfo>& entries,
                              std::vector<FullTaskDescriptor>* tasks) {
   // Collect the task IDs of default tasks from the preferences into a set.
   std::set<std::string> default_task_ids;
   for (std::vector<extensions::EntryInfo>::const_iterator it = entries.begin();
        it != entries.end(); ++it) {
     const base::FilePath& file_path = it->path;
@@ skipping 22 matching lines @@
     DCHECK(!task->is_default());
     if (IsFallbackFileHandler(task->task_descriptor())) {
       task->set_is_default(true);
       return;
     }
   }
 }
 
 }  // namespace file_tasks
 }  // namespace file_manager