Files.app: random code clean up.

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 "apps/launcher.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.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/chromeos/fileapi/file_system_backend.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "chrome/browser/drive/drive_app_registry.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/webui/extensions/extension_icon_source.h"
 #include "chrome/common/extensions/api/file_browser_handlers/file_browser_handler.h"
 #include "chrome/common/extensions/api/file_browser_private.h"
+#include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/extension_util.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/extension_set.h"
-#include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
 using extensions::Extension;
 using extensions::app_file_handler_util::FindFileHandlersForFiles;
 using fileapi::FileSystemURL;
 
 namespace file_manager {
 namespace file_tasks {
 
 namespace {
@@ skipping 76 matching lines @@
       if (it->task_descriptor().app_id == kFileManagerAppId &&
           it->task_descriptor().action_id == "gallery") {
         it = task_list->erase(it);
       } else {
         ++it;
       }
     }
   }
 }
 
+// Returns true if the given task is a handler by built-in apps like Files.app
+// itself or QuickOffice etc. They are used as the initial default app.
+bool IsFallbackFileHandler(const file_tasks::TaskDescriptor& task) {
+  if (task.task_type != file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER &&
+      task.task_type != file_tasks::TASK_TYPE_FILE_HANDLER)
+    return false;
+
+  const char* kBuiltInApps[] = {
+    kFileManagerAppId,
+    kVideoPlayerAppId,
+    kGalleryAppId,
+    extension_misc::kQuickOfficeComponentExtensionId,
+    extension_misc::kQuickOfficeInternalExtensionId,
+    extension_misc::kQuickOfficeExtensionId,
+  };
+
+  for (size_t i = 0; i < arraysize(kBuiltInApps); ++i) {
+    if (task.app_id == kBuiltInApps[i])
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 FullTaskDescriptor::FullTaskDescriptor(
     const TaskDescriptor& task_descriptor,
     const std::string& task_title,
     const GURL& icon_url,
     bool is_default)
     : task_descriptor_(task_descriptor),
       task_title_(task_title),
       icon_url_(icon_url),
@@ skipping 61 matching lines @@
 
 std::string MakeTaskID(const std::string& app_id,
                        TaskType task_type,
                        const std::string& action_id) {
   return base::StringPrintf("%s|%s|%s",
                             app_id.c_str(),
                             TaskTypeToString(task_type).c_str(),
                             action_id.c_str());
 }
 
-std::string MakeDriveAppTaskId(const std::string& app_id) {
-  return MakeTaskID(app_id, TASK_TYPE_DRIVE_APP, kDriveAppActionID);
-}
-
 std::string TaskDescriptorToId(const TaskDescriptor& task_descriptor) {
   return MakeTaskID(task_descriptor.app_id,
                     task_descriptor.task_type,
                     task_descriptor.action_id);
 }
 
 bool ParseTaskID(const std::string& task_id, TaskDescriptor* task) {
   DCHECK(task);
 
   std::vector<std::string> result;
@@ skipping 53 matching lines @@
   // Execute the task.
   if (task.task_type == TASK_TYPE_FILE_BROWSER_HANDLER) {
     return file_browser_handlers::ExecuteFileBrowserHandler(
         profile,
         extension,
         task.action_id,
         file_urls,
         done);
   } else if (task.task_type == TASK_TYPE_FILE_HANDLER) {
     std::vector<base::FilePath> paths;
-    for (size_t i = 0; i != file_urls.size(); ++i) {
+    for (size_t i = 0; i != file_urls.size(); ++i)
       paths.push_back(file_urls[i].path());
-    }
     apps::LaunchPlatformAppWithFileHandler(
         profile, extension, task.action_id, paths);
     if (!done.is_null())
       done.Run(extensions::api::file_browser_private::TASK_RESULT_MESSAGE_SENT);
     return true;
   }
   NOTREACHED();
   return false;
 }
 
@@ skipping 213 matching lines @@
       task->set_is_default(true);
       return;
     }
   }
 
   // No default tasks found. If there is any fallback file browser handler,
   // make it as default task, so it's selected by default.
   for (size_t i = 0; i < tasks->size(); ++i) {
     FullTaskDescriptor* task = &tasks->at(i);
     DCHECK(!task->is_default());
-    if (file_browser_handlers::IsFallbackFileBrowserHandler(
-            task->task_descriptor())) {
+    if (IsFallbackFileHandler(task->task_descriptor())) {
       task->set_is_default(true);
       return;
     }
   }
 }
 
 }  // namespace file_tasks
 }  // namespace file_manager