file_manager: Introduce FullTaskDescriptor

chrome/browser/chromeos/extensions/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/extensions/file_manager/file_tasks.h"
 
 #include "apps/launcher.h"
 #include "base/bind.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/stringprintf.h"
@@ skipping 93 matching lines @@
         !backend->IsAccessAllowed(files[i])) {
       return false;
     }
   }
 
   return true;
 }
 
 }  // 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),
+      is_default_(is_default){
+}
+
+scoped_ptr<base::DictionaryValue>
+FullTaskDescriptor::AsDictionaryValue() const {
+  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue);
+  dictionary->SetString("taskId", TaskDescriptorToId(task_descriptor_));
+  if (!icon_url_.is_empty())
+    dictionary->SetString("iconUrl", icon_url_.spec());
+  dictionary->SetBoolean("driveApp",
+                         task_descriptor_.task_type == TASK_TYPE_DRIVE_APP);
+  dictionary->SetString("title", task_title_);
+  dictionary->SetBoolean("isDefault", is_default_);
+  return dictionary.Pass();
+}
+
 void UpdateDefaultTask(PrefService* pref_service,
                        const std::string& task_id,
                        const std::set<std::string>& suffixes,
                        const std::set<std::string>& mime_types) {
   if (!pref_service)
     return;
 
   if (!mime_types.empty()) {
     DictionaryPrefUpdate mime_type_pref(pref_service,
                                         prefs::kDefaultTasksByMimeType);
@@ skipping 39 matching lines @@
       pref_service.GetDictionary(prefs::kDefaultTasksBySuffix);
   DCHECK(suffix_task_prefs);
   LOG_IF(ERROR, !suffix_task_prefs) << "Unable to open suffix prefs";
   std::string lower_suffix = StringToLowerASCII(suffix);
   if (suffix_task_prefs)
     suffix_task_prefs->GetStringWithoutPathExpansion(lower_suffix, &task_id);
   VLOG_IF(1, !task_id.empty()) << "Found suffix default handler: " << task_id;
   return task_id;
 }
 
-std::string MakeTaskID(const std::string& extension_id,
+std::string MakeTaskID(const std::string& app_id,
                        TaskType task_type,
                        const std::string& action_id) {
   return base::StringPrintf("%s|%s|%s",
-                            extension_id.c_str(),
+                            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, "open-with");
 }
 
+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;
   int count = Tokenize(task_id, std::string("|"), &result);
 
   // Parse a legacy task ID that only contain two parts. Drive tasks are
   // identified by a prefix "drive-app:" on the extension ID. The legacy task
   // IDs can be stored in preferences.
   // TODO(satorux): We should get rid of this code: crbug.com/267359.
@@ skipping 150 matching lines @@
     std::string task_id = file_tasks::GetDefaultTaskIdFromPrefs(
         pref_service, mime_type, file_path.Extension());
     if (task_info_map.find(task_id) != task_info_map.end())
       default_tasks->insert(task_id);
   }
 }
 
 void CreateDriveTasks(
     const TaskInfoMap& task_info_map,
     const std::set<std::string>& default_tasks,
-    ListValue* result_list,
+    std::vector<FullTaskDescriptor>* result_list,
     bool* default_already_set) {
   DCHECK(result_list);
   DCHECK(default_already_set);
 
   for (TaskInfoMap::const_iterator iter = task_info_map.begin();
        iter != task_info_map.end(); ++iter) {
-    DictionaryValue* task = new DictionaryValue;
-    task->SetString("taskId", iter->first);
-    task->SetString("title", iter->second.app_name);
-
-    const GURL& icon_url = iter->second.icon_url;
-    if (!icon_url.is_empty())
-      task->SetString("iconUrl", icon_url.spec());
-
-    task->SetBoolean("driveApp", true);
-
+    bool is_default = false;
     // Once we set a default app, we don't want to set any more.
     if (!(*default_already_set) &&
         default_tasks.find(iter->first) != default_tasks.end()) {
-      task->SetBoolean("isDefault", true);
+      is_default = true;
       *default_already_set = true;
-    } else {
-      task->SetBoolean("isDefault", false);
     }
-    result_list->Append(task);
+
+    TaskDescriptor descriptor;
+    DCHECK(ParseTaskID(iter->first, &descriptor));
+    result_list->push_back(
+        FullTaskDescriptor(descriptor,
+                           iter->second.app_name,
+                           iter->second.icon_url,
+                           is_default));
   }
 }
 
 void FindDriveAppTasks(
     Profile* profile,
     const PathAndMimeTypeSet& path_mime_set,
-    ListValue* result_list,
+    std::vector<FullTaskDescriptor>* result_list,
     bool* default_already_set) {
   DCHECK(!path_mime_set.empty());
   DCHECK(result_list);
   DCHECK(default_already_set);
 
   drive::DriveIntegrationService* integration_service =
       drive::DriveIntegrationServiceFactory::GetForProfile(profile);
   // |integration_service| is NULL if Drive is disabled.
   if (!integration_service || !integration_service->drive_app_registry())
     return;
 
   // Map of task_id to TaskInfo of available tasks.
   TaskInfoMap task_info_map;
   GetAvailableDriveTasks(*integration_service->drive_app_registry(),
                          path_mime_set,
                          &task_info_map);
 
   std::set<std::string> default_tasks;
   FindDefaultDriveTasks(*profile->GetPrefs(),
                         path_mime_set,
                         task_info_map,
                         &default_tasks);
   CreateDriveTasks(
       task_info_map, default_tasks, result_list, default_already_set);
 }
 
 void FindFileHandlerTasks(
     Profile* profile,
     const PathAndMimeTypeSet& path_mime_set,
-    ListValue* result_list,
+    std::vector<FullTaskDescriptor>* result_list,
     bool* default_already_set) {
   DCHECK(!path_mime_set.empty());
   DCHECK(result_list);
   DCHECK(default_already_set);
 
   ExtensionService* service = profile->GetExtensionService();
   if (!service)
     return;
 
   std::set<std::string> default_tasks;
@@ skipping 17 matching lines @@
       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);
-      task->SetString("taskId", task_id);
-      task->SetString("title", (*i)->title);
+
+      bool is_default = false;
       if (!(*default_already_set) && ContainsKey(default_tasks, task_id)) {
-        task->SetBoolean("isDefault", true);
+        is_default = true;
         *default_already_set = true;
-      } else {
-        task->SetBoolean("isDefault", false);
       }
 
       GURL best_icon = extensions::ExtensionIconSource::GetIconURL(
           extension,
           drive::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);
+      result_list->push_back(FullTaskDescriptor(
+          TaskDescriptor(extension->id(),
+                         file_tasks::TASK_TYPE_FILE_HANDLER,
+                         (*i)->id),
+          (*i)->title,
+          best_icon,
+          is_default));
     }
   }
 }
 
 void FindFileBrowserHandlerTasks(
     Profile* profile,
     const std::vector<GURL>& file_urls,
     const std::vector<base::FilePath>& file_paths,
-    ListValue* result_list,
+    std::vector<FullTaskDescriptor>* 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);
   if (common_tasks.empty())
     return;
   file_browser_handlers::FileBrowserHandlerList default_tasks =
       file_browser_handlers::FindDefaultFileBrowserHandlers(
           *profile->GetPrefs(), file_paths, common_tasks);
 
   ExtensionService* service =
       extensions::ExtensionSystem::Get(profile)->extension_service();
   for (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(
-        extension_id,
-        file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER,
-        handler->id()));
-    task->SetString("title", handler->title());
+    DCHECK(extension);
+
     // 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(
+    const GURL icon_url = extensions::ExtensionIconSource::GetIconURL(
         extension,
         extension_misc::EXTENSION_ICON_BITTY,
         ExtensionIconSet::MATCH_BIGGER,
         false,  // grayscale
         NULL);  // exists
-    task->SetString("iconUrl", icon.spec());
-    task->SetBoolean("driveApp", false);
 
     // Only set the default if there isn't already a default set.
+    bool is_default = false;
     if (!*default_already_set &&
         std::find(default_tasks.begin(), default_tasks.end(), *iter) !=
         default_tasks.end()) {
-      task->SetBoolean("isDefault", true);
+      is_default = true;
       *default_already_set = true;
-    } else {
-      task->SetBoolean("isDefault", false);
     }
 
-    result_list->Append(task);
+    result_list->push_back(FullTaskDescriptor(
+        TaskDescriptor(extension_id,
+                       file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER,
+                       handler->id()),
+        handler->title(),
+        icon_url,
+        is_default));
   }
 }
 
 void FindAllTypesOfTasks(
     Profile* profile,
     const PathAndMimeTypeSet& path_mime_set,
     const std::vector<GURL>& file_urls,
     const std::vector<base::FilePath>& file_paths,
-    ListValue* result_list) {
+    std::vector<FullTaskDescriptor>* result_list) {
+  DCHECK(profile);
+  DCHECK(result_list);
+
   // Check if file_paths contain a google document.
   bool has_google_document = false;
   for (size_t i = 0; i < file_paths.size(); ++i) {
     if (google_apis::ResourceEntry::ClassifyEntryKindByFileExtension(
             file_paths[i]) &
         google_apis::ResourceEntry::KIND_OF_GOOGLE_DOCUMENT) {
       has_google_document = true;
       break;
     }
   }
@@ skipping 22 matching lines @@
   // be used in the same manifest.json.
   FindFileBrowserHandlerTasks(profile,
                               file_urls,
                               file_paths,
                               result_list,
                               &default_already_set);
 }
 
 }  // namespace file_tasks
 }  // namespace file_manager