Remove all use of FileHandlersInfo from desktop shortcut creation.

chrome/browser/web_applications/web_app_mac.mm

 // 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.
 
 #import "chrome/browser/web_applications/web_app_mac.h"
 
 #import <Cocoa/Cocoa.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 234 matching lines @@
 }
 
 base::FilePath GetAppLoaderPath() {
   return base::mac::PathForFrameworkBundleResource(
       base::mac::NSToCFCast(@"app_mode_loader.app"));
 }
 
 void UpdatePlatformShortcutsInternal(
     const base::FilePath& app_data_path,
     const base::string16& old_app_title,
-    const web_app::ShortcutInfo& shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info) {
+    const web_app::ShortcutInfo& shortcut_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   if (AppShimsDisabledForTest() &&
       !g_app_shims_allow_update_and_launch_in_tests) {
     return;
   }
 
-  web_app::WebAppShortcutCreator shortcut_creator(app_data_path, &shortcut_info,
-                                                  file_handlers_info);
+  web_app::WebAppShortcutCreator shortcut_creator(app_data_path,
+                                                  &shortcut_info);
   shortcut_creator.UpdateShortcuts();
 }
 
 void UpdateAndLaunchShimOnFileThread(
-    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 = web_app::GetWebAppDataDirectory(
       shortcut_info->profile_path, shortcut_info->extension_id, GURL());
   UpdatePlatformShortcutsInternal(shortcut_data_dir, base::string16(),
-                                  *shortcut_info, file_handlers_info);
+                                  *shortcut_info);
   LaunchShimOnFileThread(std::move(shortcut_info), true);
 }
 
-void UpdateAndLaunchShim(
-    std::unique_ptr<web_app::ShortcutInfo> shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info) {
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&UpdateAndLaunchShimOnFileThread, base::Passed(&shortcut_info),
-                 file_handlers_info));
+void UpdateAndLaunchShim(std::unique_ptr<web_app::ShortcutInfo> shortcut_info) {
+  content::BrowserThread::PostTask(content::BrowserThread::FILE, FROM_HERE,
+                                   base::Bind(&UpdateAndLaunchShimOnFileThread,
+                                              base::Passed(&shortcut_info)));
 }
 
 void RebuildAppAndLaunch(std::unique_ptr<web_app::ShortcutInfo> shortcut_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (shortcut_info->extension_id == app_mode::kAppListModeId) {
     AppListService* app_list_service = AppListService::Get();
     app_list_service->CreateShortcut();
     app_list_service->Show();
     return;
   }
 
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   Profile* profile =
       profile_manager->GetProfileByPath(shortcut_info->profile_path);
   if (!profile || !profile_manager->IsValidProfile(profile))
     return;
 
   extensions::ExtensionRegistry* registry =
       extensions::ExtensionRegistry::Get(profile);
   const extensions::Extension* extension = registry->GetExtensionById(
       shortcut_info->extension_id, extensions::ExtensionRegistry::ENABLED);
   if (!extension || !extension->is_platform_app())
     return;
 
-  web_app::GetInfoForApp(extension, profile, base::Bind(&UpdateAndLaunchShim));
+  web_app::GetShortcutInfoForApp(extension, profile,
+                                 base::Bind(&UpdateAndLaunchShim));
 }
 
 base::FilePath GetLocalizableAppShortcutsSubdirName() {
   static const char kChromiumAppDirName[] = "Chromium Apps.localized";
   static const char kChromeAppDirName[] = "Chrome Apps.localized";
   static const char kChromeCanaryAppDirName[] = "Chrome Canary Apps.localized";
 
   switch (chrome::GetChannel()) {
     case version_info::Channel::UNKNOWN:
       return base::FilePath(kChromiumAppDirName);
@@ skipping 204 matching lines @@
   if (full_version.IsValid())
     major_version = full_version.components()[0];
   UMA_HISTOGRAM_SPARSE_SLOWLY("Apps.AppShimErrorVersion", major_version);
 
   return BuildShortcutInfoFromBundle(bundle_path);
 }
 
 void RevealAppShimInFinderForAppOnFileThread(
     std::unique_ptr<web_app::ShortcutInfo> shortcut_info,
     const base::FilePath& app_path) {
-  web_app::WebAppShortcutCreator shortcut_creator(
-      app_path, shortcut_info.get(), extensions::FileHandlersInfo());
+  web_app::WebAppShortcutCreator shortcut_creator(app_path,
+                                                  shortcut_info.get());
   shortcut_creator.RevealAppShimInFinder();
 }
 
 // Mac-specific version of web_app::ShouldCreateShortcutFor() used during batch
 // upgrades to ensure all shortcuts a user may still have are repaired when
 // required by a Chrome upgrade.
 bool ShouldUpgradeShortcutFor(Profile* profile,
                               const extensions::Extension* extension) {
   if (extension->location() == extensions::Manifest::COMPONENT ||
       !extensions::ui_util::CanDisplayInAppLauncher(extension, profile)) {
     return false;
   }
 
   return extension->is_app();
 }
 
 }  // namespace
 
 namespace web_app {
 
-WebAppShortcutCreator::WebAppShortcutCreator(
-    const base::FilePath& app_data_dir,
-    const ShortcutInfo* shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info)
-    : app_data_dir_(app_data_dir),
-      info_(shortcut_info),
-      file_handlers_info_(file_handlers_info) {
+WebAppShortcutCreator::WebAppShortcutCreator(const base::FilePath& app_data_dir,
+                                             const ShortcutInfo* shortcut_info)
+    : app_data_dir_(app_data_dir), info_(shortcut_info) {
   DCHECK(shortcut_info);
 }
 
 WebAppShortcutCreator::~WebAppShortcutCreator() {}
 
 base::FilePath WebAppShortcutCreator::GetApplicationsShortcutPath() const {
   base::FilePath applications_dir = GetApplicationsDirname();
   return applications_dir.empty() ?
       base::FilePath() : applications_dir.Append(GetShortcutBasename());
 }
@@ skipping 394 matching lines @@
   // Check if the Chrome apps folder exists, otherwise go up to ~/Applications.
   if (!base::PathExists(app_path))
     app_path = app_path.DirName();
   // Since |app_path| is a directory, use openFile to show the contents of
   // that directory in Finder.
   [[NSWorkspace sharedWorkspace]
       openFile:base::mac::FilePathToNSString(app_path)];
 }
 
 base::FilePath GetAppInstallPath(const ShortcutInfo& shortcut_info) {
-  WebAppShortcutCreator shortcut_creator(base::FilePath(), &shortcut_info,
-                                         extensions::FileHandlersInfo());
+  WebAppShortcutCreator shortcut_creator(base::FilePath(), &shortcut_info);
   return shortcut_creator.GetApplicationsShortcutPath();
 }
 
 void MaybeLaunchShortcut(std::unique_ptr<ShortcutInfo> shortcut_info) {
   if (AppShimsDisabledForTest() &&
       !g_app_shims_allow_update_and_launch_in_tests) {
     return;
   }
 
   content::BrowserThread::PostTask(
@@ skipping 45 matching lines @@
       content::BrowserThread::FILE, FROM_HERE,
       base::Bind(&RevealAppShimInFinderForAppOnFileThread,
                  base::Passed(&shortcut_info), app->path()));
 }
 
 namespace internals {
 
 bool CreatePlatformShortcuts(
     const base::FilePath& app_data_path,
     std::unique_ptr<ShortcutInfo> shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info,
     const ShortcutLocations& creation_locations,
     ShortcutCreationReason creation_reason) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
   if (AppShimsDisabledForTest())
     return true;
 
-  WebAppShortcutCreator shortcut_creator(app_data_path, shortcut_info.get(),
-                                         file_handlers_info);
+  WebAppShortcutCreator shortcut_creator(app_data_path, shortcut_info.get());
   return shortcut_creator.CreateShortcuts(creation_reason, creation_locations);
 }
 
 void DeletePlatformShortcuts(const base::FilePath& app_data_path,
                              std::unique_ptr<ShortcutInfo> shortcut_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
-  WebAppShortcutCreator shortcut_creator(app_data_path, shortcut_info.get(),
-                                         extensions::FileHandlersInfo());
+  WebAppShortcutCreator shortcut_creator(app_data_path, shortcut_info.get());
   shortcut_creator.DeleteShortcuts();
 }
 
-void UpdatePlatformShortcuts(
-    const base::FilePath& app_data_path,
-    const base::string16& old_app_title,
-    std::unique_ptr<ShortcutInfo> shortcut_info,
-    const extensions::FileHandlersInfo& file_handlers_info) {
-  UpdatePlatformShortcutsInternal(app_data_path, old_app_title, *shortcut_info,
-                                  file_handlers_info);
+void UpdatePlatformShortcuts(const base::FilePath& app_data_path,
+                             const base::string16& old_app_title,
+                             std::unique_ptr<ShortcutInfo> shortcut_info) {
+  UpdatePlatformShortcutsInternal(app_data_path, old_app_title, *shortcut_info);
 }
 
 void DeleteAllShortcutsForProfile(const base::FilePath& profile_path) {
   const std::string profile_base_name = profile_path.BaseName().value();
   std::vector<base::FilePath> bundles = GetAllAppBundlesInPath(
       profile_path.Append(chrome::kWebAppDirname), profile_base_name);
 
   for (std::vector<base::FilePath>::const_iterator it = bundles.begin();
        it != bundles.end(); ++it) {
     std::unique_ptr<web_app::ShortcutInfo> shortcut_info =
         BuildShortcutInfoFromBundle(*it);
-    WebAppShortcutCreator shortcut_creator(it->DirName(), shortcut_info.get(),
-                                           extensions::FileHandlersInfo());
+    WebAppShortcutCreator shortcut_creator(it->DirName(), shortcut_info.get());
     shortcut_creator.DeleteShortcuts();
   }
 }
 
 }  // namespace internals
 
 }  // namespace web_app