Remove all use of FileHandlersInfo from desktop shortcut creation.

chrome/browser/web_applications/web_app.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/web_applications/web_app.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 70 matching lines @@
 
 base::FilePath GetShortcutDataDir(const web_app::ShortcutInfo& shortcut_info) {
   return web_app::GetWebAppDataDirectory(shortcut_info.profile_path,
                                          shortcut_info.extension_id,
                                          shortcut_info.url);
 }
 
 void UpdateAllShortcutsForShortcutInfo(
     const base::string16& old_app_title,
     const base::Closure& callback,
-    std::unique_ptr<web_app::ShortcutInfo> shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info) {
+    std::unique_ptr<web_app::ShortcutInfo> shortcut_info) {
   base::FilePath shortcut_data_dir = GetShortcutDataDir(*shortcut_info);
-  base::Closure task = base::Bind(
-      &web_app::internals::UpdatePlatformShortcuts, shortcut_data_dir,
-      old_app_title, base::Passed(&shortcut_info), file_handlers_info);
+  base::Closure task = base::Bind(&web_app::internals::UpdatePlatformShortcuts,
+                                  shortcut_data_dir, old_app_title,
+                                  base::Passed(&shortcut_info));
   if (callback.is_null()) {
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, task);
   } else {
     BrowserThread::PostTaskAndReply(BrowserThread::FILE, FROM_HERE, task,
                                     callback);
   }
 }
 
 void OnImageLoaded(std::unique_ptr<web_app::ShortcutInfo> shortcut_info,
-                   extensions::FileHandlersInfo file_handlers_info,
-                   web_app::InfoCallback callback,
+                   web_app::ShortcutInfoCallback callback,
                    const gfx::ImageFamily& image_family) {
   // If the image failed to load (e.g. if the resource being loaded was empty)
   // use the standard application icon.
   if (image_family.empty()) {
     gfx::Image default_icon =
         ResourceBundle::GetSharedInstance().GetImageNamed(IDR_APP_DEFAULT_ICON);
     int size = kDesiredSizes[kNumDesiredSizes - 1];
     SkBitmap bmp = skia::ImageOperations::Resize(
           *default_icon.ToSkBitmap(), skia::ImageOperations::RESIZE_BEST,
           size, size);
     gfx::ImageSkia image_skia = gfx::ImageSkia::CreateFrom1xBitmap(bmp);
     // We are on the UI thread, and this image is needed from the FILE thread,
     // for creating shortcut icon files.
     image_skia.MakeThreadSafe();
     shortcut_info->favicon.Add(gfx::Image(image_skia));
   } else {
     shortcut_info->favicon = image_family;
   }
 
-  callback.Run(std::move(shortcut_info), file_handlers_info);
-}
-
-void IgnoreFileHandlersInfo(
-    const web_app::ShortcutInfoCallback& shortcut_info_callback,
-    std::unique_ptr<web_app::ShortcutInfo> shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info) {
-  shortcut_info_callback.Run(std::move(shortcut_info));
+  callback.Run(std::move(shortcut_info));
 }
 
 void ScheduleCreatePlatformShortcut(
     web_app::ShortcutCreationReason reason,
     const web_app::ShortcutLocations& locations,
-    std::unique_ptr<web_app::ShortcutInfo> shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info) {
+    std::unique_ptr<web_app::ShortcutInfo> shortcut_info) {
   base::FilePath shortcut_data_dir = GetShortcutDataDir(*shortcut_info);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(
           base::IgnoreResult(&web_app::internals::CreatePlatformShortcuts),
-          shortcut_data_dir, base::Passed(&shortcut_info), file_handlers_info,
-          locations, reason));
+          shortcut_data_dir, base::Passed(&shortcut_info), locations, reason));
 }
 
 }  // namespace
 
 namespace web_app {
 
 // The following string is used to build the directory name for
 // shortcuts to chrome applications (the kind which are installed
 // from a CRX).  Application shortcuts to URLs use the {host}_{path}
 // for the name of this directory.  Hosts can't include an underscore.
@@ skipping 72 matching lines @@
   shortcut_info->title = base::UTF8ToUTF16(app->name());
   shortcut_info->description = base::UTF8ToUTF16(app->description());
   shortcut_info->extension_path = app->path();
   shortcut_info->profile_path = profile->GetPath();
   shortcut_info->profile_name =
       profile->GetPrefs()->GetString(prefs::kProfileName);
   shortcut_info->version_for_display = app->GetVersionForDisplay();
   return shortcut_info;
 }
 
-void GetInfoForApp(const extensions::Extension* extension,
-                   Profile* profile,
-                   const InfoCallback& callback) {
+void GetShortcutInfoForApp(const extensions::Extension* extension,
+                           Profile* profile,
+                           const ShortcutInfoCallback& callback) {
   std::unique_ptr<web_app::ShortcutInfo> shortcut_info(
       web_app::ShortcutInfoForExtensionAndProfile(extension, profile));
-  const std::vector<extensions::FileHandlerInfo>* file_handlers =
-      extensions::FileHandlers::GetFileHandlers(extension);
-  extensions::FileHandlersInfo file_handlers_info =
-      file_handlers ? *file_handlers : extensions::FileHandlersInfo();
 
   std::vector<extensions::ImageLoader::ImageRepresentation> info_list;
   for (size_t i = 0; i < kNumDesiredSizes; ++i) {
     int size = kDesiredSizes[i];
     extensions::ExtensionResource resource =
         extensions::IconsInfo::GetIconResource(
             extension, size, ExtensionIconSet::MATCH_EXACTLY);
     if (!resource.empty()) {
       info_list.push_back(extensions::ImageLoader::ImageRepresentation(
           resource,
@@ skipping 22 matching lines @@
         extensions::ImageLoader::ImageRepresentation::ALWAYS_RESIZE,
         gfx::Size(size, size),
         ui::SCALE_FACTOR_100P));
   }
 
   // |info_list| may still be empty at this point, in which case
   // LoadImageFamilyAsync will call the OnImageLoaded callback with an empty
   // image and exit immediately.
   extensions::ImageLoader::Get(profile)->LoadImageFamilyAsync(
       extension, info_list,
-      base::Bind(&OnImageLoaded, base::Passed(&shortcut_info),
-                 file_handlers_info, callback));
-}
-
-void GetShortcutInfoForApp(const extensions::Extension* extension,
-                           Profile* profile,
-                           const ShortcutInfoCallback& callback) {
-  GetInfoForApp(
-      extension, profile, base::Bind(&IgnoreFileHandlersInfo, callback));
+      base::Bind(&OnImageLoaded, base::Passed(&shortcut_info), callback));
 }
 
 bool ShouldCreateShortcutFor(web_app::ShortcutCreationReason reason,
                              Profile* profile,
                              const extensions::Extension* extension) {
   // Shortcuts should never be created for component apps, or for apps that
   // cannot be shown in the launcher.
   if (extension->location() == extensions::Manifest::COMPONENT ||
       !extensions::ui_util::CanDisplayInAppLauncher(extension, profile)) {
     return false;
@@ skipping 89 matching lines @@
   return t;
 }
 
 std::string GetExtensionIdFromApplicationName(const std::string& app_name) {
   std::string prefix(kCrxAppPrefix);
   if (app_name.substr(0, prefix.length()) != prefix)
     return std::string();
   return app_name.substr(prefix.length());
 }
 
-void CreateShortcutsWithInfo(
-    ShortcutCreationReason reason,
-    const ShortcutLocations& locations,
-    std::unique_ptr<ShortcutInfo> shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info) {
+void CreateShortcutsWithInfo(ShortcutCreationReason reason,
+                             const ShortcutLocations& locations,
+                             std::unique_ptr<ShortcutInfo> shortcut_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // If the shortcut is for an application shortcut with the new bookmark app
   // flow disabled, there will be no corresponding extension.
   if (!shortcut_info->extension_id.empty()) {
     // It's possible for the extension to be deleted before we get here.
     // For example, creating a hosted app from a website. Double check that
     // it still exists.
     Profile* profile = g_browser_process->profile_manager()->GetProfileByPath(
         shortcut_info->profile_path);
     if (!profile)
       return;
 
     extensions::ExtensionRegistry* registry =
         extensions::ExtensionRegistry::Get(profile);
     const extensions::Extension* extension = registry->GetExtensionById(
         shortcut_info->extension_id, extensions::ExtensionRegistry::EVERYTHING);
     if (!extension)
       return;
   }
 
-  ScheduleCreatePlatformShortcut(reason, locations, std::move(shortcut_info),
-                                 file_handlers_info);
+  ScheduleCreatePlatformShortcut(reason, locations, std::move(shortcut_info));
 }
 
 void CreateShortcuts(ShortcutCreationReason reason,
                      const ShortcutLocations& locations,
                      Profile* profile,
                      const extensions::Extension* app) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!ShouldCreateShortcutFor(reason, profile, app))
     return;
 
-  GetInfoForApp(
+  GetShortcutInfoForApp(
       app, profile, base::Bind(&CreateShortcutsWithInfo, reason, locations));
 }
 
 void DeleteAllShortcuts(Profile* profile, const extensions::Extension* app) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::unique_ptr<ShortcutInfo> shortcut_info(
       ShortcutInfoForExtensionAndProfile(app, profile));
   base::FilePath shortcut_data_dir = GetShortcutDataDir(*shortcut_info);
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&web_app::internals::DeletePlatformShortcuts,
                  shortcut_data_dir, base::Passed(&shortcut_info)));
 }
 
 void UpdateAllShortcuts(const base::string16& old_app_title,
                         Profile* profile,
                         const extensions::Extension* app,
                         const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
-  GetInfoForApp(app, profile, base::Bind(&UpdateAllShortcutsForShortcutInfo,
-                                         old_app_title, callback));
+  GetShortcutInfoForApp(
+      app, profile,
+      base::Bind(&UpdateAllShortcutsForShortcutInfo, old_app_title, callback));
 }
 
 bool IsValidUrl(const GURL& url) {
   static const char* const kValidUrlSchemes[] = {
       url::kFileScheme,
       url::kFileSystemScheme,
       url::kFtpScheme,
       url::kHttpScheme,
       url::kHttpsScheme,
       extensions::kExtensionScheme,
@@ skipping 26 matching lines @@
 
 #if defined(OS_LINUX)
 std::string GetWMClassFromAppName(std::string app_name) {
   base::i18n::ReplaceIllegalCharactersInPath(&app_name, '_');
   base::TrimString(app_name, "_", &app_name);
   return app_name;
 }
 #endif
 
 }  // namespace web_app