Add isGenericFileHandler property to FileTask.

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/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 115 matching lines @@
   }
   return false;
 }
 
 }  // namespace
 
 FullTaskDescriptor::FullTaskDescriptor(
     const TaskDescriptor& task_descriptor,
     const std::string& task_title,
     const GURL& icon_url,
-    bool is_default)
+    bool is_default,
+    bool is_generic_file_handler)
     : task_descriptor_(task_descriptor),
       task_title_(task_title),
       icon_url_(icon_url),
-      is_default_(is_default) {
+      is_default_(is_default),
+      is_generic_file_handler_(is_generic_file_handler) {
 }
 
 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()) {
@@ skipping 195 matching lines @@
     TaskDescriptor descriptor(app_info.app_id,
                               TASK_TYPE_DRIVE_APP,
                               kDriveAppActionID);
     GURL icon_url = drive::util::FindPreferredIcon(
         app_info.app_icons,
         drive::util::kPreferredIconSize);
     result_list->push_back(
         FullTaskDescriptor(descriptor,
                            app_info.app_name,
                            icon_url,
-                           false /* is_default */));
+                           false /* is_default */,
+                           false /* is_generic_file_handler */));
   }
 }
 
+bool IsGenericFileHandler(
+    const extensions::FileHandlerInfo& file_handler_info) {
+  return file_handler_info.extensions.count("*") > 0 ||
+      file_handler_info.types.count("*") > 0 ||
+      file_handler_info.types.count("*/*") > 0;
+}
+
 void FindFileHandlerTasks(
     Profile* profile,
     const PathAndMimeTypeSet& path_mime_set,
     std::vector<FullTaskDescriptor>* result_list) {
   DCHECK(!path_mime_set.empty());
   DCHECK(result_list);
 
   const extensions::ExtensionSet& enabled_extensions =
       extensions::ExtensionRegistry::Get(profile)->enabled_extensions();
+
   for (extensions::ExtensionSet::const_iterator iter =
            enabled_extensions.begin();
        iter != enabled_extensions.end();
        ++iter) {
     const Extension* extension = iter->get();
 
     // Check that the extension can be launched via an event. This includes all
     // platform apps plus whitelisted extensions.
     if (!CanLaunchViaEvent(extension))
       continue;
 
     // Ephemeral apps cannot be file handlers.
     if (extensions::util::IsEphemeralApp(extension->id(), profile))
       continue;
 
     if (profile->IsOffTheRecord() &&
         !extensions::util::IsIncognitoEnabled(extension->id(), profile))
       continue;
 
     typedef std::vector<const extensions::FileHandlerInfo*> FileHandlerList;
     FileHandlerList file_handlers =
         FindFileHandlersForFiles(*extension, path_mime_set);
     if (file_handlers.empty())
       continue;
 
-    // Only show the first matching handler from each app.
-    const extensions::FileHandlerInfo* file_handler = file_handlers.front();
+    // Show the first matching non-generic handler of each app. If there doesn't
+    // exist such handler, show the first matching handler of the app.
+    const extensions::FileHandlerInfo* file_handler = nullptr;
+    for (auto handler : file_handlers) {
+      if (!IsGenericFileHandler(*handler)) {
+        file_handler = handler;
+        break;
+      }
+    }
+    if (file_handler == nullptr) {
+      file_handler = file_handlers.front();
+    }
+
     std::string task_id = file_tasks::MakeTaskID(
         extension->id(), file_tasks::TASK_TYPE_FILE_HANDLER, file_handler->id);
 
     GURL best_icon = extensions::ExtensionIconSource::GetIconURL(
         extension,
         drive::util::kPreferredIconSize,
         ExtensionIconSet::MATCH_BIGGER,
         false,  // grayscale
         NULL);  // exists
 
     result_list->push_back(
         FullTaskDescriptor(TaskDescriptor(extension->id(),
                                           file_tasks::TASK_TYPE_FILE_HANDLER,
                                           file_handler->id),
                            extension->name(),
                            best_icon,
-                           false /* is_default */));
+                           false /* is_default */,
+                           IsGenericFileHandler(*file_handler)));
   }
 }
 
 void FindFileBrowserHandlerTasks(
     Profile* profile,
     const std::vector<GURL>& file_urls,
     std::vector<FullTaskDescriptor>* result_list) {
   DCHECK(!file_urls.empty());
   DCHECK(result_list);
 
@@ skipping 21 matching lines @@
         ExtensionIconSet::MATCH_BIGGER,
         false,  // grayscale
         NULL);  // exists
 
     result_list->push_back(FullTaskDescriptor(
         TaskDescriptor(extension_id,
                        file_tasks::TASK_TYPE_FILE_BROWSER_HANDLER,
                        handler->id()),
         handler->title(),
         icon_url,
-        false /* is_default */));
+        false /* is_default */,
+        false /* is_generic_file_handler */));
   }
 }
 
 void FindAllTypesOfTasks(
     Profile* profile,
     const drive::DriveAppRegistry* drive_app_registry,
     const PathAndMimeTypeSet& path_mime_set,
     const std::vector<GURL>& file_urls,
     std::vector<FullTaskDescriptor>* result_list) {
   DCHECK(profile);
@@ skipping 53 matching lines @@
     DCHECK(!task->is_default());
     if (IsFallbackFileHandler(task->task_descriptor())) {
       task->set_is_default(true);
       return;
     }
   }
 }
 
 }  // namespace file_tasks
 }  // namespace file_manager