Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/wallpaper/wallpaper_manager_base.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 "components/wallpaper/wallpaper_manager_base.h"
 
 #include <numeric>
 #include <vector>
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 475 matching lines @@
   // TODO(bshe): Lifetime of WallpaperManagerBase needs more consideration.
   // http://crbug.com/171694
   weak_factory_.InvalidateWeakPtrs();
 }
 
 // static
 void WallpaperManagerBase::SaveCustomWallpaper(
     const WallpaperFilesId& wallpaper_files_id,
     const base::FilePath& original_path,
     WallpaperLayout layout,
-    scoped_ptr<gfx::ImageSkia> image) {
+    std::unique_ptr<gfx::ImageSkia> image) {
   base::DeleteFile(GetCustomWallpaperDir(kOriginalWallpaperSubDir)
                        .Append(wallpaper_files_id.id()),
                    true /* recursive */);
   base::DeleteFile(GetCustomWallpaperDir(kSmallWallpaperSubDir)
                        .Append(wallpaper_files_id.id()),
                    true /* recursive */);
   base::DeleteFile(GetCustomWallpaperDir(kLargeWallpaperSubDir)
                        .Append(wallpaper_files_id.id()),
                    true /* recursive */);
   EnsureCustomWallpaperDirectories(wallpaper_files_id);
@@ skipping 396 matching lines @@
     if (interval > delay)
       delay = base::TimeDelta::FromMilliseconds(0);
     else if (interval > base::TimeDelta::FromMilliseconds(0))
       delay -= interval;
   }
   return delay;
 }
 
 void WallpaperManagerBase::OnCustomizedDefaultWallpaperDecoded(
     const GURL& wallpaper_url,
-    scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
-    scoped_ptr<user_manager::UserImage> wallpaper) {
+    std::unique_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
+    std::unique_ptr<user_manager::UserImage> wallpaper) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
   if (wallpaper->image().isNull()) {
     LOG(WARNING) << "Failed to decode customized wallpaper.";
     return;
   }
 
   wallpaper->image().EnsureRepsForSupportedScales();
   // TODO(crbug.com/593251): DeepCopy() may be unnecessary as this function
   // owns |wallpaper| as scoped_ptr whereas it used to be a const reference.
-  scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper->image().DeepCopy());
+  std::unique_ptr<gfx::ImageSkia> deep_copy(wallpaper->image().DeepCopy());
 
-  scoped_ptr<bool> success(new bool(false));
-  scoped_ptr<gfx::ImageSkia> small_wallpaper_image(new gfx::ImageSkia);
-  scoped_ptr<gfx::ImageSkia> large_wallpaper_image(new gfx::ImageSkia);
+  std::unique_ptr<bool> success(new bool(false));
+  std::unique_ptr<gfx::ImageSkia> small_wallpaper_image(new gfx::ImageSkia);
+  std::unique_ptr<gfx::ImageSkia> large_wallpaper_image(new gfx::ImageSkia);
 
   // TODO(bshe): This may break if Bytes becomes RefCountedMemory.
   base::Closure resize_closure = base::Bind(
       &WallpaperManagerBase::ResizeCustomizedDefaultWallpaper,
       base::Passed(&deep_copy),
       base::Unretained(rescaled_files.get()), base::Unretained(success.get()),
       base::Unretained(small_wallpaper_image.get()),
       base::Unretained(large_wallpaper_image.get()));
   base::Closure on_resized_closure = base::Bind(
       &WallpaperManagerBase::OnCustomizedDefaultWallpaperResized,
       weak_factory_.GetWeakPtr(), wallpaper_url,
       base::Passed(std::move(rescaled_files)), base::Passed(std::move(success)),
       base::Passed(std::move(small_wallpaper_image)),
       base::Passed(std::move(large_wallpaper_image)));
 
   if (!task_runner_->PostTaskAndReply(FROM_HERE, resize_closure,
                                       on_resized_closure)) {
     LOG(WARNING) << "Failed to start Customized Wallpaper resize.";
   }
 }
 
 void WallpaperManagerBase::ResizeCustomizedDefaultWallpaper(
-    scoped_ptr<gfx::ImageSkia> image,
+    std::unique_ptr<gfx::ImageSkia> image,
     const CustomizedWallpaperRescaledFiles* rescaled_files,
     bool* success,
     gfx::ImageSkia* small_wallpaper_image,
     gfx::ImageSkia* large_wallpaper_image) {
   *success = true;
 
   *success &= ResizeAndSaveWallpaper(
       *image, rescaled_files->path_rescaled_small(), WALLPAPER_LAYOUT_STRETCH,
       kSmallWallpaperMaxWidth, kSmallWallpaperMaxHeight, small_wallpaper_image);
 
   *success &= ResizeAndSaveWallpaper(
       *image, rescaled_files->path_rescaled_large(), WALLPAPER_LAYOUT_STRETCH,
       kLargeWallpaperMaxWidth, kLargeWallpaperMaxHeight, large_wallpaper_image);
 }
 
 void WallpaperManagerBase::SetCustomizedDefaultWallpaper(
     const GURL& wallpaper_url,
     const base::FilePath& downloaded_file,
     const base::FilePath& resized_directory) {
   // Should fail if this ever happens in tests.
   DCHECK(wallpaper_url.is_valid());
   if (!wallpaper_url.is_valid()) {
     if (!wallpaper_url.is_empty()) {
       LOG(WARNING) << "Invalid Customized Wallpaper URL '"
                    << wallpaper_url.spec() << "'";
     }
     return;
   }
   std::string downloaded_file_name = downloaded_file.BaseName().value();
-  scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files(
+  std::unique_ptr<CustomizedWallpaperRescaledFiles> rescaled_files(
       new CustomizedWallpaperRescaledFiles(
           downloaded_file, resized_directory.Append(downloaded_file_name +
                                                     kSmallWallpaperSuffix),
           resized_directory.Append(downloaded_file_name +
                                    kLargeWallpaperSuffix)));
 
   base::Closure check_file_exists = rescaled_files->CreateCheckerClosure();
   base::Closure on_checked_closure =
       base::Bind(&WallpaperManagerBase::SetCustomizedDefaultWallpaperAfterCheck,
                  weak_factory_.GetWeakPtr(), wallpaper_url, downloaded_file,
@@ skipping 14 matching lines @@
 void WallpaperManagerBase::CreateSolidDefaultWallpaper() {
   loaded_wallpapers_for_test_++;
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(kDefaultWallpaperColor);
   const gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
   default_wallpaper_image_.reset(new user_manager::UserImage(image));
 }
 
 }  // namespace wallpaper