ChromeOS: Use file extensions in Files app to decide which apps to use.

chrome/browser/chromeos/extensions/file_manager/file_browser_private_api.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_browser_private_api.h"
 
 #include <sys/stat.h>
 #include <sys/statvfs.h>
 #include <sys/types.h>
 #include <utime.h>
@@ skipping 65 matching lines @@
 #include "ui/shell_dialogs/selected_file_info.h"
 #include "ui/webui/web_ui_util.h"
 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_file_util.h"
 #include "webkit/fileapi/file_system_operation_context.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
 
-using extensions::app_file_handler_util::FindFileHandlersForMimeTypes;
+using extensions::app_file_handler_util::FindFileHandlersForFiles;
+using extensions::app_file_handler_util::PathAndMimeTypeSet;
 using chromeos::disks::DiskMountManager;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 using extensions::ZipFileCreator;
 using file_handler_util::FileTaskExecutor;
 using fileapi::FileSystemURL;
@@ skipping 289 matching lines @@
     property_dict->SetString("contentUrl", entry_proto.download_url());
 
   property_dict->SetBoolean("isHosted",
                             file_specific_info.is_hosted_document());
 
   property_dict->SetString("contentMimeType",
                            file_specific_info.content_mime_type());
 }
 
 void GetMimeTypesForFileURLs(const std::vector<base::FilePath>& file_paths,
-                             std::set<std::string>* mime_types) {
+                             PathAndMimeTypeSet* files) {
   for (std::vector<base::FilePath>::const_iterator iter = file_paths.begin();
        iter != file_paths.end(); ++iter) {
     const base::FilePath::StringType file_extension =
         StringToLowerASCII(iter->Extension());
 
     // TODO(thorogood): Rearchitect this call so it can run on the File thread;
     // GetMimeTypeFromFile requires this on Linux. Right now, we use
     // Chrome-level knowledge only.
     std::string mime_type;
     if (file_extension.empty() ||
         !net::GetWellKnownMimeTypeFromExtension(file_extension.substr(1),
                                                 &mime_type)) {
       // If the file doesn't have an extension or its mime-type cannot be
       // determined, then indicate that it has the empty mime-type. This will
       // only be matched if the Web Intents accepts "*" or "*/*".
-      mime_types->insert("");
+      files->insert(std::make_pair(*iter, ""));
     } else {
-      mime_types->insert(mime_type);
+      files->insert(std::make_pair(*iter, mime_type));
     }
   }
 }
 
 // Retrieves the maximum file name length of the file system of |path|.
 // Returns 0 if it could not be queried.
 size_t GetFileNameMaxLengthOnBlockingPool(const std::string& path) {
   struct statvfs stat = {};
   if (statvfs(path.c_str(), &stat) != 0) {
     // The filesystem seems not supporting statvfs(). Assume it to be a commonly
@@ skipping 466 matching lines @@
 }
 
 bool GetFileTasksFileBrowserFunction::FindAppTasks(
     const std::vector<base::FilePath>& file_paths,
     ListValue* result_list) {
   DCHECK(!file_paths.empty());
   ExtensionService* service = profile_->GetExtensionService();
   if (!service)
     return false;
 
-  std::set<std::string> mime_types;
-  GetMimeTypesForFileURLs(file_paths, &mime_types);
+  PathAndMimeTypeSet files;
+  GetMimeTypesForFileURLs(file_paths, &files);
 
   for (ExtensionSet::const_iterator iter = service->extensions()->begin();
        iter != service->extensions()->end();
        ++iter) {
     const Extension* extension = *iter;
 
     // 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 =
-        FindFileHandlersForMimeTypes(*extension, mime_types);
-    // TODO(benwells): also support matching by file extension.
+    FileHandlerList file_handlers = FindFileHandlersForFiles(*extension, files);
     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_handler_util::MakeTaskID(extension->id(),
           file_handler_util::kTaskApp, (*i)->id);
       task->SetString("taskId", task_id);
       task->SetString("title", (*i)->title);
@@ skipping 2228 matching lines @@
 OpenNewWindowFunction::OpenNewWindowFunction() {}
 
 OpenNewWindowFunction::~OpenNewWindowFunction() {}
 
 bool OpenNewWindowFunction::RunImpl() {
   std::string url;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &url));
   file_manager_util::OpenNewWindow(profile_, GURL(url));
   return true;
 }