Make web_app::ShortcutInfo RefCountedThreadSafe (1)

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) {
+    scoped_refptr<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));
+  base::Closure task =
+      base::Bind(&web_app::internals::UpdatePlatformShortcuts,
+                 shortcut_data_dir, old_app_title, std::move(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,
+void OnImageLoaded(scoped_refptr<web_app::ShortcutInfo> shortcut_info,
                    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));
 }
 
 void ScheduleCreatePlatformShortcut(
     web_app::ShortcutCreationReason reason,
     const web_app::ShortcutLocations& locations,
-    std::unique_ptr<web_app::ShortcutInfo> shortcut_info) {
+    scoped_refptr<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), locations, reason));
+          shortcut_data_dir, std::move(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 18 matching lines @@
 ShortcutInfo::ShortcutInfo() {}
 ShortcutInfo::~ShortcutInfo() {}
 
 ShortcutLocations::ShortcutLocations()
     : on_desktop(false),
       applications_menu_location(APP_MENU_LOCATION_NONE),
       in_quick_launch_bar(false) {
 }
 
 #if defined(TOOLKIT_VIEWS)
-std::unique_ptr<ShortcutInfo> GetShortcutInfoForTab(
+scoped_refptr<ShortcutInfo> GetShortcutInfoForTab(
     content::WebContents* web_contents) {
   const favicon::FaviconDriver* favicon_driver =
       favicon::ContentFaviconDriver::FromWebContents(web_contents);
   const extensions::TabHelper* extensions_tab_helper =
       extensions::TabHelper::FromWebContents(web_contents);
   const WebApplicationInfo& app_info = extensions_tab_helper->web_app_info();
 
-  std::unique_ptr<ShortcutInfo> info(new ShortcutInfo);
+  scoped_refptr<ShortcutInfo> info(new ShortcutInfo);
   info->url = app_info.app_url.is_empty() ? web_contents->GetURL() :
                                             app_info.app_url;
   info->title = app_info.title.empty() ?
       (web_contents->GetTitle().empty() ? base::UTF8ToUTF16(info->url.spec()) :
                                           web_contents->GetTitle()) :
       app_info.title;
   info->description = app_info.description;
   info->favicon.Add(favicon_driver->GetFavicon());
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   info->profile_path = profile->GetPath();
 
   return info;
 }
 #endif
 
 #if !defined(OS_WIN)
 void UpdateShortcutForTabContents(content::WebContents* web_contents) {}
 #endif
 
-std::unique_ptr<ShortcutInfo> ShortcutInfoForExtensionAndProfile(
+scoped_refptr<ShortcutInfo> ShortcutInfoForExtensionAndProfile(
     const extensions::Extension* app,
     Profile* profile) {
-  std::unique_ptr<ShortcutInfo> shortcut_info(new ShortcutInfo);
+  scoped_refptr<ShortcutInfo> shortcut_info(new ShortcutInfo);
   shortcut_info->extension_id = app->id();
   shortcut_info->is_platform_app = app->is_platform_app();
 
   // Some default-installed apps are converted into bookmark apps on Chrome
   // first run. These should not be considered as being created (by the user)
   // from a web page.
   shortcut_info->from_bookmark =
       app->from_bookmark() && !app->was_installed_by_default();
 
   shortcut_info->url = extensions::AppLaunchInfo::GetLaunchWebURL(app);
   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 GetShortcutInfoForApp(const extensions::Extension* extension,
                            Profile* profile,
                            const ShortcutInfoCallback& callback) {
-  std::unique_ptr<web_app::ShortcutInfo> shortcut_info(
+  scoped_refptr<web_app::ShortcutInfo> shortcut_info(
       web_app::ShortcutInfoForExtensionAndProfile(extension, profile));
 
   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(
@@ skipping 135 matching lines @@
 
 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) {
+                             scoped_refptr<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);
@@ skipping 20 matching lines @@
   if (!ShouldCreateShortcutFor(reason, profile, app))
     return;
 
   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(
+  scoped_refptr<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,
@@ skipping 43 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