Fixed thread-unsafe use of gfx::Image in app 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 <Carbon/Carbon.h>
 #import <Cocoa/Cocoa.h>
 
 #include "base/command_line.h"
@@ skipping 201 matching lines @@
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   DCHECK(!user_data_dir.empty());
   return StartsWithASCII(
       base::SysNSStringToUTF8(
           [plist valueForKey:app_mode::kCrAppModeUserDataDirKey]),
       user_data_dir.value(),
       true /* case_sensitive */);
 }
 
-void LaunchShimOnFileThread(const web_app::ShortcutInfo& shortcut_info,
+void LaunchShimOnFileThread(scoped_ptr<web_app::ShortcutInfo> shortcut_info,
                             bool launched_after_rebuild) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  base::FilePath shim_path = web_app::GetAppInstallPath(shortcut_info);
+  base::FilePath shim_path = web_app::GetAppInstallPath(*shortcut_info);
 
   if (shim_path.empty() ||
       !base::PathExists(shim_path) ||
       !HasSameUserDataDir(shim_path)) {
     // The user may have deleted the copy in the Applications folder, use the
     // one in the web app's |app_data_dir_|.
     base::FilePath app_data_dir = web_app::GetWebAppDataDirectory(
-        shortcut_info.profile_path, shortcut_info.extension_id, GURL());
+        shortcut_info->profile_path, shortcut_info->extension_id, GURL());
     shim_path = app_data_dir.Append(shim_path.BaseName());
   }
 
   if (!base::PathExists(shim_path))
     return;
 
   base::CommandLine command_line(base::CommandLine::NO_PROGRAM);
   command_line.AppendSwitchASCII(
       app_mode::kLaunchedByChromeProcessId,
       base::IntToString(base::GetCurrentProcId()));
   if (launched_after_rebuild)
     command_line.AppendSwitch(app_mode::kLaunchedAfterRebuild);
   // Launch without activating (kLSLaunchDontSwitch).
   base::mac::OpenApplicationWithPath(
       shim_path, command_line, kLSLaunchDefaults | kLSLaunchDontSwitch, NULL);
 }
 
 base::FilePath GetAppLoaderPath() {
   return base::mac::PathForFrameworkBundleResource(
       base::mac::NSToCFCast(@"app_mode_loader.app"));
 }
 
-void UpdateAndLaunchShimOnFileThread(
+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) {
+  DCHECK(content::BrowserThread::CurrentlyOn(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);
+  shortcut_creator.UpdateShortcuts();
+}
+
+void UpdateAndLaunchShimOnFileThread(
+    scoped_ptr<web_app::ShortcutInfo> shortcut_info,
+    const extensions::FileHandlersInfo& file_handlers_info) {
   base::FilePath shortcut_data_dir = web_app::GetWebAppDataDirectory(
-      shortcut_info.profile_path, shortcut_info.extension_id, GURL());
-  web_app::internals::UpdatePlatformShortcuts(
-      shortcut_data_dir, base::string16(), shortcut_info, file_handlers_info);
-  LaunchShimOnFileThread(shortcut_info, true);
+      shortcut_info->profile_path, shortcut_info->extension_id, GURL());
+  UpdatePlatformShortcutsInternal(shortcut_data_dir, base::string16(),
+                                  *shortcut_info, file_handlers_info);
+  LaunchShimOnFileThread(shortcut_info.Pass(), true);
 }
 
 void UpdateAndLaunchShim(
-    const web_app::ShortcutInfo& shortcut_info,
+    scoped_ptr<web_app::ShortcutInfo> shortcut_info,
     const extensions::FileHandlersInfo& file_handlers_info) {
   content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(
-          &UpdateAndLaunchShimOnFileThread, shortcut_info, file_handlers_info));
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&UpdateAndLaunchShimOnFileThread, base::Passed(&shortcut_info),
+                 file_handlers_info));
 }
 
-void RebuildAppAndLaunch(const web_app::ShortcutInfo& shortcut_info) {
+void RebuildAppAndLaunch(scoped_ptr<web_app::ShortcutInfo> shortcut_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (shortcut_info.extension_id == app_mode::kAppListModeId) {
+  if (shortcut_info->extension_id == app_mode::kAppListModeId) {
     AppListService* app_list_service =
         AppListService::Get(chrome::HOST_DESKTOP_TYPE_NATIVE);
     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);
+      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);
+      shortcut_info->extension_id, extensions::ExtensionRegistry::ENABLED);
   if (!extension || !extension->is_platform_app())
     return;
 
   web_app::GetInfoForApp(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";
@@ skipping 155 matching lines @@
                                   base::FileEnumerator::DIRECTORIES);
   for (base::FilePath bundle_path = enumerator.Next();
        !bundle_path.empty(); bundle_path = enumerator.Next()) {
     if (IsShimForProfile(bundle_path.BaseName(), profile_base_name))
       bundle_paths.push_back(bundle_path);
   }
 
   return bundle_paths;
 }
 
-web_app::ShortcutInfo BuildShortcutInfoFromBundle(
+scoped_ptr<web_app::ShortcutInfo> BuildShortcutInfoFromBundle(
     const base::FilePath& bundle_path) {
   NSDictionary* plist = ReadPlist(GetPlistPath(bundle_path));
 
-  web_app::ShortcutInfo shortcut_info;
-  shortcut_info.extension_id = base::SysNSStringToUTF8(
+  scoped_ptr<web_app::ShortcutInfo> shortcut_info(new web_app::ShortcutInfo);
+  shortcut_info->extension_id = base::SysNSStringToUTF8(
       [plist valueForKey:app_mode::kCrAppModeShortcutIDKey]);
-  shortcut_info.is_platform_app = true;
-  shortcut_info.url = GURL(base::SysNSStringToUTF8(
+  shortcut_info->is_platform_app = true;
+  shortcut_info->url = GURL(base::SysNSStringToUTF8(
       [plist valueForKey:app_mode::kCrAppModeShortcutURLKey]));
-  shortcut_info.title = base::SysNSStringToUTF16(
+  shortcut_info->title = base::SysNSStringToUTF16(
       [plist valueForKey:app_mode::kCrAppModeShortcutNameKey]);
-  shortcut_info.profile_name = base::SysNSStringToUTF8(
+  shortcut_info->profile_name = base::SysNSStringToUTF8(
       [plist valueForKey:app_mode::kCrAppModeProfileNameKey]);
 
   // Figure out the profile_path. Since the user_data_dir could contain the
   // path to the web app data dir.
   base::FilePath user_data_dir = base::mac::NSStringToFilePath(
       [plist valueForKey:app_mode::kCrAppModeUserDataDirKey]);
   base::FilePath profile_base_name = base::mac::NSStringToFilePath(
       [plist valueForKey:app_mode::kCrAppModeProfileDirKey]);
   if (user_data_dir.DirName().DirName().BaseName() == profile_base_name)
-    shortcut_info.profile_path = user_data_dir.DirName().DirName();
+    shortcut_info->profile_path = user_data_dir.DirName().DirName();
   else
-    shortcut_info.profile_path = user_data_dir.Append(profile_base_name);
+    shortcut_info->profile_path = user_data_dir.Append(profile_base_name);
 
   return shortcut_info;
 }
 
-web_app::ShortcutInfo RecordAppShimErrorAndBuildShortcutInfo(
+scoped_ptr<web_app::ShortcutInfo> RecordAppShimErrorAndBuildShortcutInfo(
     const base::FilePath& bundle_path) {
   NSDictionary* plist = ReadPlist(GetPlistPath(bundle_path));
   NSString* version_string = [plist valueForKey:app_mode::kCrBundleVersionKey];
   if (!version_string) {
     // Older bundles have the Chrome version in the following key.
     version_string =
         [plist valueForKey:app_mode::kCFBundleShortVersionStringKey];
   }
   base::Version full_version(base::SysNSStringToUTF8(version_string));
   uint32_t major_version = 0;
@@ skipping 41 matching lines @@
       app_mode::kCFBundleTypeRoleKey : app_mode::kBundleTypeRoleViewer
     };
     [document_types addObject:type_dictionary];
   }
 
   [plist setObject:document_types
             forKey:app_mode::kCFBundleDocumentTypesKey];
 }
 
 void RevealAppShimInFinderForAppOnFileThread(
-    const web_app::ShortcutInfo& shortcut_info,
+    scoped_ptr<web_app::ShortcutInfo> shortcut_info,
     const base::FilePath& app_path) {
   web_app::WebAppShortcutCreator shortcut_creator(
-      app_path, shortcut_info, extensions::FileHandlersInfo());
+      app_path, shortcut_info.get(), extensions::FileHandlersInfo());
   shortcut_creator.RevealAppShimInFinder();
 }
 
 }  // namespace
 
 @interface CrCreateAppShortcutCheckboxObserver : NSObject {
  @private
   NSButton* checkbox_;
   NSButton* continueButton_;
 }
@@ skipping 33 matching lines @@
                        context:(void*)context {
   [continueButton_ setEnabled:([checkbox_ state] == NSOnState)];
 }
 
 @end
 
 namespace web_app {
 
 WebAppShortcutCreator::WebAppShortcutCreator(
     const base::FilePath& app_data_dir,
-    const ShortcutInfo& shortcut_info,
+    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) {}
+      file_handlers_info_(file_handlers_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());
 }
 
 base::FilePath WebAppShortcutCreator::GetInternalShortcutPath() const {
   return app_data_dir_.Append(GetShortcutBasename());
 }
 
 base::FilePath WebAppShortcutCreator::GetShortcutBasename() const {
   std::string app_name;
   // Check if there should be a separate shortcut made for different profiles.
   // Such shortcuts will have a |profile_name| set on the ShortcutInfo,
   // otherwise it will be empty.
-  if (!info_.profile_name.empty()) {
-    app_name += info_.profile_path.BaseName().value();
+  if (!info_->profile_name.empty()) {
+    app_name += info_->profile_path.BaseName().value();
     app_name += ' ';
   }
-  app_name += info_.extension_id;
+  app_name += info_->extension_id;
   return base::FilePath(app_name).ReplaceExtension("app");
 }
 
 bool WebAppShortcutCreator::BuildShortcut(
     const base::FilePath& staging_path) const {
   // Update the app's plist and icon in a temp directory. This works around
   // a Finder bug where the app's icon doesn't properly update.
   if (!base::CopyDirectory(GetAppLoaderPath(), staging_path, true)) {
     LOG(ERROR) << "Copying app to staging path: " << staging_path.value()
                << " failed.";
@@ skipping 57 matching lines @@
 
   // If non-nil, this path is added to the OSX Dock after creating shortcuts.
   NSString* path_to_add_to_dock = nil;
 
   std::vector<base::FilePath> paths;
 
   // The app list shim is not tied to a particular profile, so omit the copy
   // placed under the profile path. For shims, this copy is used when the
   // version under Applications is removed, and not needed for app list because
   // setting LSUIElement means there is no Dock "running" status to show.
-  const bool is_app_list = info_.extension_id == app_mode::kAppListModeId;
+  const bool is_app_list = info_->extension_id == app_mode::kAppListModeId;
   if (is_app_list) {
     path_to_add_to_dock = base::SysUTF8ToNSString(
         applications_dir.Append(GetShortcutBasename()).AsUTF8Unsafe());
   } else {
     paths.push_back(app_data_dir_);
   }
 
   bool shortcut_visible =
       creation_locations.applications_menu_location != APP_MENU_LOCATION_HIDDEN;
   if (shortcut_visible)
@@ skipping 70 matching lines @@
 
 base::FilePath WebAppShortcutCreator::GetApplicationsDirname() const {
   base::FilePath path = GetWritableApplicationsDirectory();
   if (path.empty())
     return path;
 
   return path.Append(GetLocalizableAppShortcutsSubdirName());
 }
 
 bool WebAppShortcutCreator::UpdatePlist(const base::FilePath& app_path) const {
-  NSString* extension_id = base::SysUTF8ToNSString(info_.extension_id);
-  NSString* extension_title = base::SysUTF16ToNSString(info_.title);
-  NSString* extension_url = base::SysUTF8ToNSString(info_.url.spec());
+  NSString* extension_id = base::SysUTF8ToNSString(info_->extension_id);
+  NSString* extension_title = base::SysUTF16ToNSString(info_->title);
+  NSString* extension_url = base::SysUTF8ToNSString(info_->url.spec());
   NSString* chrome_bundle_id =
       base::SysUTF8ToNSString(base::mac::BaseBundleID());
   NSDictionary* replacement_dict =
       [NSDictionary dictionaryWithObjectsAndKeys:
           extension_id, app_mode::kShortcutIdPlaceholder,
           extension_title, app_mode::kShortcutNamePlaceholder,
           extension_url, app_mode::kShortcutURLPlaceholder,
           chrome_bundle_id, app_mode::kShortcutBrowserBundleIDPlaceholder,
           nil];
 
@@ skipping 12 matching lines @@
         [value substringWithRange:NSMakeRange(1, [value length] - 2)];
 
     NSString* substitution = [replacement_dict valueForKey:variable];
     if (substitution)
       [plist setObject:substitution forKey:key];
   }
 
   // 2. Fill in other values.
   [plist setObject:base::SysUTF8ToNSString(chrome::VersionInfo().Version())
             forKey:app_mode::kCrBundleVersionKey];
-  [plist setObject:base::SysUTF8ToNSString(info_.version_for_display)
+  [plist setObject:base::SysUTF8ToNSString(info_->version_for_display)
             forKey:app_mode::kCFBundleShortVersionStringKey];
   [plist setObject:base::SysUTF8ToNSString(GetBundleIdentifier())
             forKey:base::mac::CFToNSCast(kCFBundleIdentifierKey)];
   [plist setObject:base::mac::FilePathToNSString(app_data_dir_)
             forKey:app_mode::kCrAppModeUserDataDirKey];
-  [plist setObject:base::mac::FilePathToNSString(info_.profile_path.BaseName())
+  [plist setObject:base::mac::FilePathToNSString(info_->profile_path.BaseName())
             forKey:app_mode::kCrAppModeProfileDirKey];
-  [plist setObject:base::SysUTF8ToNSString(info_.profile_name)
+  [plist setObject:base::SysUTF8ToNSString(info_->profile_name)
             forKey:app_mode::kCrAppModeProfileNameKey];
   [plist setObject:[NSNumber numberWithBool:YES]
             forKey:app_mode::kLSHasLocalizedDisplayNameKey];
-  if (info_.extension_id == app_mode::kAppListModeId) {
+  if (info_->extension_id == app_mode::kAppListModeId) {
     // Prevent the app list from bouncing in the dock, and getting a run light.
     [plist setObject:[NSNumber numberWithBool:YES]
               forKey:kLSUIElement];
   }
 
   base::FilePath app_name = app_path.BaseName().RemoveExtension();
   [plist setObject:base::mac::FilePathToNSString(app_name)
             forKey:base::mac::CFToNSCast(kCFBundleNameKey)];
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAppsFileAssociations)) {
     UpdateFileTypes(plist, file_handlers_info_);
   }
 
   return [plist writeToFile:plist_path
                  atomically:YES];
 }
 
 bool WebAppShortcutCreator::UpdateDisplayName(
     const base::FilePath& app_path) const {
   // OSX searches for the best language in the order of preferred languages.
   // Since we only have one localization directory, it will choose this one.
   base::FilePath localized_dir = GetResourcesPath(app_path).Append("en.lproj");
   if (!base::CreateDirectory(localized_dir))
     return false;
 
-  NSString* bundle_name = base::SysUTF16ToNSString(info_.title);
-  NSString* display_name = base::SysUTF16ToNSString(info_.title);
-  if (HasExistingExtensionShim(GetApplicationsDirname(),
-                               info_.extension_id,
+  NSString* bundle_name = base::SysUTF16ToNSString(info_->title);
+  NSString* display_name = base::SysUTF16ToNSString(info_->title);
+  if (HasExistingExtensionShim(GetApplicationsDirname(), info_->extension_id,
                                app_path.BaseName())) {
     display_name = [bundle_name
         stringByAppendingString:base::SysUTF8ToNSString(
-            " (" + info_.profile_name + ")")];
+            " (" + info_->profile_name + ")")];
   }
 
   NSDictionary* strings_plist = @{
     base::mac::CFToNSCast(kCFBundleNameKey) : bundle_name,
     app_mode::kCFBundleDisplayNameKey : display_name
   };
 
   NSString* localized_path = base::mac::FilePathToNSString(
       localized_dir.Append("InfoPlist.strings"));
   return [strings_plist writeToFile:localized_path
                          atomically:YES];
 }
 
 bool WebAppShortcutCreator::UpdateIcon(const base::FilePath& app_path) const {
-  if (info_.favicon.empty())
+  if (info_->favicon.empty())
     return true;
 
   ScopedCarbonHandle icon_family(0);
   bool image_added = false;
-  for (gfx::ImageFamily::const_iterator it = info_.favicon.begin();
-       it != info_.favicon.end(); ++it) {
+  for (gfx::ImageFamily::const_iterator it = info_->favicon.begin();
+       it != info_->favicon.end(); ++it) {
     if (it->IsEmpty())
       continue;
 
     // Missing an icon size is not fatal so don't fail if adding the bitmap
     // doesn't work.
     if (!AddGfxImageToIconFamily(icon_family.GetAsIconFamilyHandle(), *it))
       continue;
 
     image_added = true;
   }
@@ skipping 29 matching lines @@
     return base::FilePath();
 
   base::ScopedCFTypeRef<CFURLRef> url(url_ref);
   NSString* path_string = [base::mac::CFToNSCast(url.get()) path];
   return base::FilePath([path_string fileSystemRepresentation]);
 }
 
 std::string WebAppShortcutCreator::GetBundleIdentifier() const {
   // Replace spaces in the profile path with hyphen.
   std::string normalized_profile_path;
-  base::ReplaceChars(info_.profile_path.BaseName().value(),
-                     " ", "-", &normalized_profile_path);
+  base::ReplaceChars(info_->profile_path.BaseName().value(), " ", "-",
+                     &normalized_profile_path);
 
   // This matches APP_MODE_APP_BUNDLE_ID in chrome/chrome.gyp.
-  std::string bundle_id =
-      base::mac::BaseBundleID() + std::string(".app.") +
-      normalized_profile_path + "-" + info_.extension_id;
+  std::string bundle_id = base::mac::BaseBundleID() + std::string(".app.") +
+                          normalized_profile_path + "-" + info_->extension_id;
 
   return bundle_id;
 }
 
 std::string WebAppShortcutCreator::GetInternalBundleIdentifier() const {
   return GetBundleIdentifier() + "-internal";
 }
 
 void WebAppShortcutCreator::RevealAppShimInFinder() const {
   base::FilePath app_path = GetApplicationsShortcutPath();
@@ skipping 15 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,
+                                         extensions::FileHandlersInfo());
   return shortcut_creator.GetApplicationsShortcutPath();
 }
 
-void MaybeLaunchShortcut(const ShortcutInfo& shortcut_info) {
+void MaybeLaunchShortcut(scoped_ptr<ShortcutInfo> shortcut_info) {
   if (AppShimsDisabledForTest() &&
       !g_app_shims_allow_update_and_launch_in_tests) {
     return;
   }
 
   content::BrowserThread::PostTask(
-      content::BrowserThread::FILE,
-      FROM_HERE,
-      base::Bind(&LaunchShimOnFileThread, shortcut_info, false));
+      content::BrowserThread::FILE, FROM_HERE,
+      base::Bind(&LaunchShimOnFileThread, base::Passed(&shortcut_info), false));
 }
 
 bool MaybeRebuildShortcut(const base::CommandLine& command_line) {
   if (!command_line.HasSwitch(app_mode::kAppShimError))
     return false;
 
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool(),
       FROM_HERE,
       base::Bind(&RecordAppShimErrorAndBuildShortcutInfo,
                  command_line.GetSwitchValuePath(app_mode::kAppShimError)),
       base::Bind(&RebuildAppAndLaunch));
   return true;
 }
 
 // Called when the app's ShortcutInfo (with icon) is loaded when creating app
 // shortcuts.
 void CreateAppShortcutInfoLoaded(
     Profile* profile,
     const extensions::Extension* app,
     const base::Callback<void(bool)>& close_callback,
-    const ShortcutInfo& shortcut_info) {
+    scoped_ptr<ShortcutInfo> shortcut_info) {
   base::scoped_nsobject<NSAlert> alert([[NSAlert alloc] init]);
 
   NSButton* continue_button = [alert
       addButtonWithTitle:l10n_util::GetNSString(IDS_CREATE_SHORTCUTS_COMMIT)];
   [continue_button setKeyEquivalent:kKeyEquivalentReturn];
 
   NSButton* cancel_button =
       [alert addButtonWithTitle:l10n_util::GetNSString(IDS_CANCEL)];
   [cancel_button setKeyEquivalent:kKeyEquivalentEscape];
 
@@ skipping 11 matching lines @@
   base::scoped_nsobject<CrCreateAppShortcutCheckboxObserver> checkbox_observer(
       [[CrCreateAppShortcutCheckboxObserver alloc]
           initWithCheckbox:application_folder_checkbox
             continueButton:continue_button]);
   [checkbox_observer startObserving];
 
   [alert setAccessoryView:application_folder_checkbox];
 
   const int kIconPreviewSizePixels = 128;
   const int kIconPreviewTargetSize = 64;
-  const gfx::Image* icon = shortcut_info.favicon.GetBest(
+  const gfx::Image* icon = shortcut_info->favicon.GetBest(
       kIconPreviewSizePixels, kIconPreviewSizePixels);
 
   if (icon && !icon->IsEmpty()) {
     NSImage* icon_image = icon->ToNSImage();
     [icon_image
         setSize:NSMakeSize(kIconPreviewTargetSize, kIconPreviewTargetSize)];
     [alert setIcon:icon_image];
   }
 
   bool dialog_accepted = false;
@@ skipping 28 matching lines @@
                                          it->get())) {
       web_app::UpdateAllShortcuts(base::string16(), profile, it->get());
     }
   }
 
   callback.Run();
 }
 
 void RevealAppShimInFinderForApp(Profile* profile,
                                  const extensions::Extension* app) {
-  const web_app::ShortcutInfo shortcut_info =
+  scoped_ptr<web_app::ShortcutInfo> shortcut_info =
       ShortcutInfoForExtensionAndProfile(app, profile);
   content::BrowserThread::PostTask(
       content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&RevealAppShimInFinderForAppOnFileThread, shortcut_info,
-                 app->path()));
+      base::Bind(&RevealAppShimInFinderForAppOnFileThread,
+                 base::Passed(&shortcut_info), app->path()));
 }
 
 namespace internals {
 
 bool CreatePlatformShortcuts(
     const base::FilePath& app_data_path,
-    const ShortcutInfo& shortcut_info,
+    scoped_ptr<ShortcutInfo> shortcut_info,
     const extensions::FileHandlersInfo& file_handlers_info,
     const ShortcutLocations& creation_locations,
     ShortcutCreationReason creation_reason) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
   if (AppShimsDisabledForTest())
     return true;
 
-  WebAppShortcutCreator shortcut_creator(
-      app_data_path, shortcut_info, file_handlers_info);
+  WebAppShortcutCreator shortcut_creator(app_data_path, shortcut_info.get(),
+                                         file_handlers_info);
   return shortcut_creator.CreateShortcuts(creation_reason, creation_locations);
 }
 
 void DeletePlatformShortcuts(const base::FilePath& app_data_path,
-                             const ShortcutInfo& shortcut_info) {
+                             scoped_ptr<ShortcutInfo> shortcut_info) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  WebAppShortcutCreator shortcut_creator(
-      app_data_path, shortcut_info, extensions::FileHandlersInfo());
+  WebAppShortcutCreator shortcut_creator(app_data_path, shortcut_info.get(),
+                                         extensions::FileHandlersInfo());
   shortcut_creator.DeleteShortcuts();
 }
 
 void UpdatePlatformShortcuts(
     const base::FilePath& app_data_path,
     const base::string16& old_app_title,
-    const ShortcutInfo& shortcut_info,
+    scoped_ptr<ShortcutInfo> shortcut_info,
     const extensions::FileHandlersInfo& file_handlers_info) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
-  if (AppShimsDisabledForTest() &&
-      !g_app_shims_allow_update_and_launch_in_tests) {
-    return;
-  }
-
-  WebAppShortcutCreator shortcut_creator(
-      app_data_path, shortcut_info, file_handlers_info);
-  shortcut_creator.UpdateShortcuts();
+  UpdatePlatformShortcutsInternal(app_data_path, old_app_title, *shortcut_info,
+                                  file_handlers_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) {
-    web_app::ShortcutInfo shortcut_info =
+    scoped_ptr<web_app::ShortcutInfo> shortcut_info =
         BuildShortcutInfoFromBundle(*it);
-    WebAppShortcutCreator shortcut_creator(
-        it->DirName(), shortcut_info, extensions::FileHandlersInfo());
+    WebAppShortcutCreator shortcut_creator(it->DirName(), shortcut_info.get(),
+                                           extensions::FileHandlersInfo());
     shortcut_creator.DeleteShortcuts();
   }
 }
 
 }  // namespace internals
 
 }  // namespace web_app
 
 namespace chrome {
 
 void ShowCreateChromeAppShortcutsDialog(
     gfx::NativeWindow /*parent_window*/,
     Profile* profile,
     const extensions::Extension* app,
     const base::Callback<void(bool)>& close_callback) {
   web_app::GetShortcutInfoForApp(
       app,
       profile,
       base::Bind(&web_app::CreateAppShortcutInfoLoaded,
                  profile,
                  app,
                  close_callback));
 }
 
 }  // namespace chrome