Reland 220012: Move the functions of filebrowserPrivateApi from the file_manager namespace to the e…

chrome/browser/chromeos/extensions/file_manager/private_api_tasks.cc

 // Copyright 2013 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/private_api_tasks.h"
 
 #include "chrome/browser/chromeos/drive/drive_app_registry.h"
 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_browser_handlers.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_tasks.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
 using content::BrowserContext;
 using extensions::app_file_handler_util::FindFileHandlersForFiles;
 using extensions::Extension;
 using fileapi::FileSystemURL;
 
-namespace file_manager {
+namespace extensions {
 namespace {
 
 // Error messages.
 const char kInvalidFileUrl[] = "Invalid file URL";
 
 // Default icon path for drive docs.
 const char kDefaultIcon[] = "images/filetype_generic.png";
 
 // Logs the default task for debugging.
 void LogDefaultTask(const std::set<std::string>& mime_types,
@@ skipping 78 matching lines @@
 
   // TODO(kaznacheev): Crack the task_id here, store it in the Executor
   // and avoid passing it around.
 
   // The second param is the list of files that need to be executed with this
   // task.
   ListValue* files_list = NULL;
   if (!args_->GetList(1, &files_list))
     return false;
 
-  file_tasks::TaskDescriptor task;
-  if (!file_tasks::ParseTaskID(task_id, &task)) {
+  file_manager::file_tasks::TaskDescriptor task;
+  if (!file_manager::file_tasks::ParseTaskID(task_id, &task)) {
     LOG(WARNING) << "Invalid task " << task_id;
     return false;
   }
 
   if (!files_list->GetSize())
     return true;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
-      util::GetFileSystemContextForRenderViewHost(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   std::vector<FileSystemURL> file_urls;
   for (size_t i = 0; i < files_list->GetSize(); i++) {
     std::string file_url_str;
     if (!files_list->GetString(i, &file_url_str)) {
       error_ = kInvalidFileUrl;
       return false;
     }
     FileSystemURL url = file_system_context->CrackURL(GURL(file_url_str));
     if (!chromeos::FileSystemBackend::CanHandleURL(url)) {
       error_ = kInvalidFileUrl;
       return false;
     }
     file_urls.push_back(url);
   }
 
-  int32 tab_id = util::GetTabId(dispatcher());
-  return file_tasks::ExecuteFileTask(
+  int32 tab_id = file_manager::util::GetTabId(dispatcher());
+  return file_manager::file_tasks::ExecuteFileTask(
       profile(),
       source_url(),
       extension_->id(),
       tab_id,
       task,
       file_urls,
       base::Bind(&ExecuteTaskFunction::OnTaskExecuted, this));
 }
 
 void ExecuteTaskFunction::OnTaskExecuted(bool success) {
@@ skipping 33 matching lines @@
     if (file_path.empty())
       continue;
 
     ScopedVector<drive::DriveAppInfo> app_info_list;
     registry->GetAppsForFile(file_path, mime_type, &app_info_list);
 
     if (is_first) {
       // For the first file, we store all the info.
       for (size_t j = 0; j < app_info_list.size(); ++j) {
         const drive::DriveAppInfo& app_info = *app_info_list[j];
-        GURL icon_url = util::FindPreferredIcon(app_info.app_icons,
-                                                util::kPreferredIconSize);
+        GURL icon_url = file_manager::util::FindPreferredIcon(
+            app_info.app_icons, file_manager::util::kPreferredIconSize);
         task_info_map->insert(std::pair<std::string, TaskInfo>(
-            file_tasks::MakeDriveAppTaskId(app_info.app_id),
+            file_manager::file_tasks::MakeDriveAppTaskId(app_info.app_id),
             TaskInfo(app_info.app_name, icon_url)));
       }
     } else {
       // For remaining files, take the intersection with the current result,
       // based on the task id.
       std::set<std::string> task_id_set;
       for (size_t j = 0; j < app_info_list.size(); ++j) {
-        task_id_set.insert(
-            file_tasks::MakeDriveAppTaskId(app_info_list[j]->app_id));
+        task_id_set.insert(file_manager::file_tasks::MakeDriveAppTaskId(
+            app_info_list[j]->app_id));
       }
       for (TaskInfoMap::iterator iter = task_info_map->begin();
            iter != task_info_map->end(); ) {
         if (task_id_set.find(iter->first) == task_id_set.end()) {
           task_info_map->erase(iter++);
         } else {
           ++iter;
         }
       }
     }
 
     is_first = false;
   }
 }
 
 void GetFileTasksFunction::FindDefaultDriveTasks(
     const PathAndMimeTypeSet& path_mime_set,
     const TaskInfoMap& task_info_map,
     std::set<std::string>* default_tasks) {
   DCHECK(default_tasks);
 
   for (PathAndMimeTypeSet::const_iterator it = path_mime_set.begin();
        it != path_mime_set.end(); ++it) {
     const base::FilePath& file_path = it->first;
     const std::string& mime_type = it->second;
-    std::string task_id = file_tasks::GetDefaultTaskIdFromPrefs(
+    std::string task_id = file_manager::file_tasks::GetDefaultTaskIdFromPrefs(
         profile_, mime_type, file_path.Extension());
     if (task_info_map.find(task_id) != task_info_map.end())
       default_tasks->insert(task_id);
   }
 }
 
 // static
 void GetFileTasksFunction::CreateDriveTasks(
     const TaskInfoMap& task_info_map,
     const std::set<std::string>& default_tasks,
@@ skipping 63 matching lines @@
   DCHECK(result_list);
   DCHECK(default_already_set);
 
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return;
 
   std::set<std::string> default_tasks;
   for (PathAndMimeTypeSet::iterator it = path_mime_set.begin();
        it != path_mime_set.end(); ++it) {
-    default_tasks.insert(file_tasks::GetDefaultTaskIdFromPrefs(
+    default_tasks.insert(file_manager::file_tasks::GetDefaultTaskIdFromPrefs(
         profile_, it->second, it->first.Extension()));
   }
 
   for (ExtensionSet::const_iterator iter = service->extensions()->begin();
        iter != service->extensions()->end();
        ++iter) {
     const Extension* extension = iter->get();
 
     // 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 extensions::FileHandlerInfo*> FileHandlerList;
     FileHandlerList file_handlers =
         FindFileHandlersForFiles(*extension, path_mime_set);
     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_tasks::MakeTaskID(
-          extension->id(), file_tasks::TASK_TYPE_FILE_HANDLER, (*i)->id);
+      std::string task_id = file_manager::file_tasks::MakeTaskID(
+          extension->id(),
+          file_manager::file_tasks::TASK_TYPE_FILE_HANDLER,
+          (*i)->id);
       task->SetString("taskId", task_id);
       task->SetString("title", (*i)->title);
       if (!(*default_already_set) && ContainsKey(default_tasks, task_id)) {
         task->SetBoolean("isDefault", true);
         *default_already_set = true;
       } else {
         task->SetBoolean("isDefault", false);
       }
 
       GURL best_icon = extensions::ExtensionIconSource::GetIconURL(
           extension,
-          util::kPreferredIconSize,
+          file_manager::util::kPreferredIconSize,
           ExtensionIconSet::MATCH_BIGGER,
           false,  // grayscale
           NULL);  // exists
       if (!best_icon.is_empty())
         task->SetString("iconUrl", best_icon.spec());
       else
         task->SetString("iconUrl", kDefaultIcon);
 
       task->SetBoolean("driveApp", false);
       result_list->Append(task);
     }
   }
 }
 
 void GetFileTasksFunction::FindFileBrowserHandlerTasks(
     const std::vector<GURL>& file_urls,
     const std::vector<base::FilePath>& file_paths,
     ListValue* result_list,
     bool* default_already_set) {
   DCHECK(!file_paths.empty());
   DCHECK(!file_urls.empty());
   DCHECK(result_list);
   DCHECK(default_already_set);
 
-  file_browser_handlers::FileBrowserHandlerList common_tasks =
-      file_browser_handlers::FindCommonFileBrowserHandlers(profile_, file_urls);
+  file_manager::file_browser_handlers::FileBrowserHandlerList common_tasks =
+      file_manager::file_browser_handlers::FindCommonFileBrowserHandlers(
+          profile_, file_urls);
   if (common_tasks.empty())
     return;
-  file_browser_handlers::FileBrowserHandlerList default_tasks =
-      file_browser_handlers::FindDefaultFileBrowserHandlers(
+  file_manager::file_browser_handlers::FileBrowserHandlerList default_tasks =
+      file_manager::file_browser_handlers::FindDefaultFileBrowserHandlers(
           profile_, file_paths, common_tasks);
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
-  for (file_browser_handlers::FileBrowserHandlerList::const_iterator iter =
-           common_tasks.begin();
+  for (file_manager::file_browser_handlers::FileBrowserHandlerList::
+           const_iterator iter = common_tasks.begin();
        iter != common_tasks.end();
        ++iter) {
     const FileBrowserHandler* handler = *iter;
     const std::string extension_id = handler->extension_id();
     const Extension* extension = service->GetExtensionById(extension_id, false);
     CHECK(extension);
     DictionaryValue* task = new DictionaryValue;
-    task->SetString("taskId", file_tasks::MakeTaskID(
+    task->SetString("taskId", file_manager::file_tasks::MakeTaskID(
         extension_id,
-        file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER,
+        file_manager::file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER,
         handler->id()));
     task->SetString("title", handler->title());
     // TODO(zelidrag): Figure out how to expose icon URL that task defined in
     // manifest instead of the default extension icon.
     GURL icon = extensions::ExtensionIconSource::GetIconURL(
         extension,
         extension_misc::EXTENSION_ICON_BITTY,
         ExtensionIconSet::MATCH_BIGGER,
         false,  // grayscale
         NULL);  // exists
@@ skipping 27 matching lines @@
   ListValue* mime_types_list = NULL;
   if (!args_->GetList(1, &mime_types_list))
     return false;
 
   // MIME types can either be empty, or there needs to be one for each file.
   if (mime_types_list->GetSize() != files_list->GetSize() &&
       mime_types_list->GetSize() != 0)
     return false;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
-      util::GetFileSystemContextForRenderViewHost(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   // Collect all the URLs, convert them to GURLs, and crack all the urls into
   // file paths.
   PathAndMimeTypeSet path_mime_set;
   std::vector<GURL> file_urls;
   std::vector<base::FilePath> file_paths;
   bool has_google_document = false;
   for (size_t i = 0; i < files_list->GetSize(); ++i) {
     std::string file_url_str;
@@ skipping 10 matching lines @@
         file_system_context->CrackURL(file_url));
     if (!chromeos::FileSystemBackend::CanHandleURL(file_system_url))
       continue;
     const base::FilePath file_path = file_system_url.path();
 
     file_urls.push_back(file_url);
     file_paths.push_back(file_path);
 
     // If MIME type is not provided, guess it from the file path.
     if (mime_type.empty())
-      mime_type = util::GetMimeTypeForPath(file_path);
+      mime_type = file_manager::util::GetMimeTypeForPath(file_path);
 
     path_mime_set.insert(std::make_pair(file_path, mime_type));
 
     if (google_apis::ResourceEntry::ClassifyEntryKindByFileExtension(
             file_path) &
         google_apis::ResourceEntry::KIND_OF_GOOGLE_DOCUMENT) {
       has_google_document = true;
     }
   }
 
@@ skipping 34 matching lines @@
   // First param is task id that was to the extension with setDefaultTask call.
   std::string task_id;
   if (!args_->GetString(0, &task_id) || !task_id.size())
     return false;
 
   base::ListValue* file_url_list;
   if (!args_->GetList(1, &file_url_list))
     return false;
 
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
-      util::GetFileSystemContextForRenderViewHost(
+      file_manager::util::GetFileSystemContextForRenderViewHost(
           profile(), render_view_host());
 
   std::set<std::string> suffixes =
       GetUniqueSuffixes(file_url_list, file_system_context.get());
 
   // MIME types are an optional parameter.
   base::ListValue* mime_type_list;
   std::set<std::string> mime_types;
   if (args_->GetList(2, &mime_type_list) && !mime_type_list->empty()) {
     if (mime_type_list->GetSize() != file_url_list->GetSize())
       return false;
     mime_types = GetUniqueMimeTypes(mime_type_list);
   }
 
   if (VLOG_IS_ON(1))
     LogDefaultTask(mime_types, suffixes, task_id);
 
   // If there weren't any mime_types, and all the suffixes were blank,
   // then we "succeed", but don't actually associate with anything.
   // Otherwise, any time we set the default on a file with no extension
   // on the local drive, we'd fail.
   // TODO(gspencer): Fix file manager so that it never tries to set default in
   // cases where extensionless local files are part of the selection.
   if (suffixes.empty() && mime_types.empty()) {
     SetResult(new base::FundamentalValue(true));
     return true;
   }
 
-  file_tasks::UpdateDefaultTask(profile_, task_id, suffixes, mime_types);
+  file_manager::file_tasks::UpdateDefaultTask(
+      profile_, task_id, suffixes, mime_types);
 
   return true;
 }
 
-}  // namespace file_manager
+}  // namespace extensions