Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.cc

 // Copyright 2014 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/login/users/wallpaper/wallpaper_manager.h"
 
 #include <stdint.h>
 #include <numeric>
 #include <utility>
 #include <vector>
@@ skipping 359 matching lines @@
 }
 
 void WallpaperManager::InitializeWallpaper() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 
   // Apply device customization.
   if (ShouldUseCustomizedDefaultWallpaper()) {
     SetDefaultWallpaperPath(GetCustomizedWallpaperDefaultRescaledFileName(
                                 wallpaper::kSmallWallpaperSuffix),
-                            scoped_ptr<gfx::ImageSkia>(),
+                            std::unique_ptr<gfx::ImageSkia>(),
                             GetCustomizedWallpaperDefaultRescaledFileName(
                                 wallpaper::kLargeWallpaperSuffix),
-                            scoped_ptr<gfx::ImageSkia>());
+                            std::unique_ptr<gfx::ImageSkia>());
   }
 
   base::CommandLine* command_line = GetCommandLine();
   if (command_line->HasSwitch(chromeos::switches::kGuestSession)) {
     // Guest wallpaper should be initialized when guest login.
     // Note: This maybe called before login. So IsLoggedInAsGuest can not be
     // used here to determine if current user is guest.
     return;
   }
 
@@ skipping 74 matching lines @@
   GetUserWallpaperInfo(account_id, &info);
   DictionaryPrefUpdate prefs_wallpapers_info_update(
       prefs, wallpaper::kUsersWallpaperInfo);
   prefs_wallpapers_info_update->RemoveWithoutPathExpansion(
       account_id.GetUserEmail(), NULL);
   DeleteUserWallpapers(account_id, info.location);
 }
 
 void WallpaperManager::OnPolicyFetched(const std::string& policy,
                                        const AccountId& account_id,
-                                       scoped_ptr<std::string> data) {
+                                       std::unique_ptr<std::string> data) {
   if (!data)
     return;
 
   user_image_loader::StartWithData(
       task_runner_, std::move(data), ImageDecoder::ROBUST_JPEG_CODEC,
       0,  // Do not crop.
       base::Bind(&WallpaperManager::SetPolicyControlledWallpaper,
                  weak_factory_.GetWeakPtr(), account_id));
 }
 
@@ skipping 36 matching lines @@
 
   WallpaperInfo wallpaper_info = {
       wallpaper_path.value(),
       layout,
       type,
       // Date field is not used.
       base::Time::Now().LocalMidnight()
   };
   if (is_persistent) {
     image.EnsureRepsForSupportedScales();
-    scoped_ptr<gfx::ImageSkia> deep_copy(image.DeepCopy());
+    std::unique_ptr<gfx::ImageSkia> deep_copy(image.DeepCopy());
     // Block shutdown on this task. Otherwise, we may lose the custom wallpaper
     // that the user selected.
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
         BrowserThread::GetBlockingPool()
             ->GetSequencedTaskRunnerWithShutdownBehavior(
                 sequence_token_, base::SequencedWorkerPool::BLOCK_SHUTDOWN);
     // TODO(bshe): This may break if RawImage becomes RefCountedMemory.
     blocking_task_runner->PostTask(
         FROM_HERE,
         base::Bind(&WallpaperManager::SaveCustomWallpaper, wallpaper_files_id,
@@ skipping 274 matching lines @@
       break;
     }
   }
 
   if (loading_.empty())
     FOR_EACH_OBSERVER(Observer, observers_, OnPendingListEmptyForTesting());
 }
 
 void WallpaperManager::SetPolicyControlledWallpaper(
     const AccountId& account_id,
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   const user_manager::User* user =
       user_manager::UserManager::Get()->FindUser(account_id);
   if (!user) {
     NOTREACHED() << "Unknown user.";
     return;
   }
 
   const wallpaper::WallpaperFilesId wallpaper_files_id =
       GetKnownUserWallpaperFilesId(*user);
   if (!wallpaper_files_id.is_valid()) {
@@ skipping 99 matching lines @@
   info->type = static_cast<user_manager::User::WallpaperType>(type);
   info->date = base::Time::FromInternalValue(date_val);
   return true;
 }
 
 void WallpaperManager::OnWallpaperDecoded(
     const AccountId& account_id,
     wallpaper::WallpaperLayout layout,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   TRACE_EVENT_ASYNC_END0("ui", "LoadAndDecodeWallpaper", this);
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
   // Use default wallpaper in this case.
   if (user_image->image().isNull()) {
     // Updates user pref to default wallpaper.
     WallpaperInfo info = {"",
                           wallpaper::WALLPAPER_LAYOUT_CENTER_CROPPED,
                           user_manager::User::DEFAULT,
@@ skipping 32 matching lines @@
       task_runner_, wallpaper_path, ImageDecoder::ROBUST_JPEG_CODEC,
       0,  // Do not crop.
       base::Bind(&WallpaperManager::OnWallpaperDecoded,
                  weak_factory_.GetWeakPtr(), account_id, info.layout,
                  update_wallpaper, base::Passed(std::move(on_finish))));
 }
 
 void WallpaperManager::SetCustomizedDefaultWallpaperAfterCheck(
     const GURL& wallpaper_url,
     const base::FilePath& downloaded_file,
-    scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files) {
+    std::unique_ptr<CustomizedWallpaperRescaledFiles> rescaled_files) {
   PrefService* pref_service = g_browser_process->local_state();
 
   std::string current_url =
       pref_service->GetString(prefs::kCustomizationDefaultWallpaperURL);
   if (current_url != wallpaper_url.spec() || !rescaled_files->AllSizesExist()) {
     DCHECK(rescaled_files->downloaded_exists());
 
     // Either resized images do not exist or cached version is incorrect.
     // Need to start resize again.
     user_image_loader::StartWithFilePath(
         task_runner_, downloaded_file, ImageDecoder::ROBUST_JPEG_CODEC,
         0,  // Do not crop.
         base::Bind(&WallpaperManager::OnCustomizedDefaultWallpaperDecoded,
                    weak_factory_.GetWeakPtr(), wallpaper_url,
                    base::Passed(std::move(rescaled_files))));
   } else {
-    SetDefaultWallpaperPath(
-        rescaled_files->path_rescaled_small(), scoped_ptr<gfx::ImageSkia>(),
-        rescaled_files->path_rescaled_large(), scoped_ptr<gfx::ImageSkia>());
+    SetDefaultWallpaperPath(rescaled_files->path_rescaled_small(),
+                            std::unique_ptr<gfx::ImageSkia>(),
+                            rescaled_files->path_rescaled_large(),
+                            std::unique_ptr<gfx::ImageSkia>());
   }
 }
 
 void WallpaperManager::OnCustomizedDefaultWallpaperResized(
     const GURL& wallpaper_url,
-    scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
-    scoped_ptr<bool> success,
-    scoped_ptr<gfx::ImageSkia> small_wallpaper_image,
-    scoped_ptr<gfx::ImageSkia> large_wallpaper_image) {
+    std::unique_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
+    std::unique_ptr<bool> success,
+    std::unique_ptr<gfx::ImageSkia> small_wallpaper_image,
+    std::unique_ptr<gfx::ImageSkia> large_wallpaper_image) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(rescaled_files);
   DCHECK(success.get());
   if (!*success) {
     LOG(WARNING) << "Failed to save resized customized default wallpaper";
     return;
   }
   PrefService* pref_service = g_browser_process->local_state();
   pref_service->SetString(prefs::kCustomizationDefaultWallpaperURL,
                           wallpaper_url.spec());
@@ skipping 24 matching lines @@
   child_small_wallpaper_file_ = command_line->GetSwitchValuePath(
       chromeos::switches::kChildWallpaperSmall);
   child_large_wallpaper_file_ = command_line->GetSwitchValuePath(
       chromeos::switches::kChildWallpaperLarge);
   default_wallpaper_image_.reset();
 }
 
 void WallpaperManager::OnDefaultWallpaperDecoded(
     const base::FilePath& path,
     const wallpaper::WallpaperLayout layout,
-    scoped_ptr<user_manager::UserImage>* result_out,
+    std::unique_ptr<user_manager::UserImage>* result_out,
     MovableOnDestroyCallbackHolder on_finish,
-    scoped_ptr<user_manager::UserImage> user_image) {
+    std::unique_ptr<user_manager::UserImage> user_image) {
   *result_out = std::move(user_image);
   ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
       (*result_out)->image(), layout);
 }
 
 void WallpaperManager::StartLoadAndSetDefaultWallpaper(
     const base::FilePath& path,
     const wallpaper::WallpaperLayout layout,
     MovableOnDestroyCallbackHolder on_finish,
-    scoped_ptr<user_manager::UserImage>* result_out) {
+    std::unique_ptr<user_manager::UserImage>* result_out) {
   user_image_loader::StartWithFilePath(
       task_runner_, path, ImageDecoder::ROBUST_JPEG_CODEC,
       0,  // Do not crop.
       base::Bind(&WallpaperManager::OnDefaultWallpaperDecoded,
                  weak_factory_.GetWeakPtr(), path, layout,
                  base::Unretained(result_out),
                  base::Passed(std::move(on_finish))));
 }
 
 void WallpaperManager::SetDefaultWallpaperPath(
     const base::FilePath& default_small_wallpaper_file,
-    scoped_ptr<gfx::ImageSkia> small_wallpaper_image,
+    std::unique_ptr<gfx::ImageSkia> small_wallpaper_image,
     const base::FilePath& default_large_wallpaper_file,
-    scoped_ptr<gfx::ImageSkia> large_wallpaper_image) {
+    std::unique_ptr<gfx::ImageSkia> large_wallpaper_image) {
   default_small_wallpaper_file_ = default_small_wallpaper_file;
   default_large_wallpaper_file_ = default_large_wallpaper_file;
 
   ash::DesktopBackgroundController* dbc =
       ash::Shell::GetInstance()->desktop_background_controller();
 
   // |need_update_screen| is true if the previous default wallpaper is visible
   // now, so we need to update wallpaper on the screen.
   //
   // Layout is ignored here, so wallpaper::WALLPAPER_LAYOUT_CENTER is used
@@ skipping 23 matching lines @@
     DoSetDefaultWallpaper(EmptyAccountId(), MovableOnDestroyCallbackHolder());
   }
 }
 
 wallpaper::WallpaperFilesId WallpaperManager::GetFilesId(
     const user_manager::User& user) const {
   return GetKnownUserWallpaperFilesId(user);
 }
 
 }  // namespace chromeos