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

components/wallpaper/wallpaper_manager_base.h

 // 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.
 
 #ifndef COMPONENTS_WALLPAPER_WALLPAPER_MANAGER_BASE_H_
 #define COMPONENTS_WALLPAPER_WALLPAPER_MANAGER_BASE_H_
 
 #include <stddef.h>
 
 #include <deque>
 #include <map>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/signin/core/account_id/account_id.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_image/user_image.h"
@@ skipping 21 matching lines @@
 class WALLPAPER_EXPORT MovableOnDestroyCallback {
  public:
   explicit MovableOnDestroyCallback(const base::Closure& callback);
 
   ~MovableOnDestroyCallback();
 
  private:
   base::Closure callback_;
 };
 
-typedef scoped_ptr<MovableOnDestroyCallback> MovableOnDestroyCallbackHolder;
+using MovableOnDestroyCallbackHolder =
+    std::unique_ptr<MovableOnDestroyCallback>;
 
 struct WALLPAPER_EXPORT WallpaperInfo {
   WallpaperInfo();
   WallpaperInfo(const std::string& in_location,
                 WallpaperLayout in_layout,
                 user_manager::User::WallpaperType in_type,
                 const base::Time& in_date);
   ~WallpaperInfo();
 
   // Either file name of migrated wallpaper including first directory level
@@ skipping 200 matching lines @@
                                   const gfx::ImageSkia& image,
                                   bool update_wallpaper) = 0;
 
   // Use given files as new default wallpaper.
   // Reloads current wallpaper, if old default was loaded.
   // Current value of default_wallpaper_image_ is destroyed.
   // Sets default_wallpaper_image_ either to |small_wallpaper_image| or
   // |large_wallpaper_image| depending on GetAppropriateResolution().
   virtual void SetDefaultWallpaperPath(
       const base::FilePath& customized_default_wallpaper_file_small,
-      scoped_ptr<gfx::ImageSkia> small_wallpaper_image,
+      std::unique_ptr<gfx::ImageSkia> small_wallpaper_image,
       const base::FilePath& customized_default_wallpaper_file_large,
-      scoped_ptr<gfx::ImageSkia> large_wallpaper_image) = 0;
+      std::unique_ptr<gfx::ImageSkia> large_wallpaper_image) = 0;
 
   // Sets wallpaper to default wallpaper (asynchronously with zero delay).
   virtual void SetDefaultWallpaperNow(const AccountId& account_id) = 0;
 
   // Sets wallpaper to default wallpaper (asynchronously with default delay).
   virtual void SetDefaultWallpaperDelayed(const AccountId& account_id) = 0;
 
   // Sets selected wallpaper information for |account_id| and saves it to Local
   // State if |is_persistent| is true.
   virtual void SetUserWallpaperInfo(const AccountId& account_id,
@@ skipping 32 matching lines @@
                            const AccountId& account_id);
 
   // Called when the wallpaper policy has been cleared for |account_id|.
   virtual void OnPolicyCleared(const std::string& policy,
                                const AccountId& account_id);
 
   // Called when the policy-set wallpaper has been fetched.  Initiates decoding
   // of the JPEG |data| with a callback to SetPolicyControlledWallpaper().
   virtual void OnPolicyFetched(const std::string& policy,
                                const AccountId& account_id,
-                               scoped_ptr<std::string> data) = 0;
+                               std::unique_ptr<std::string> data) = 0;
 
   // This is called from CustomizationDocument.
   // |resized_directory| is the directory where resized versions are stored and
   // must be writable.
   virtual void SetCustomizedDefaultWallpaper(
       const GURL& wallpaper_url,
       const base::FilePath& downloaded_file,
       const base::FilePath& resized_directory);
 
   // Returns queue size.
@@ skipping 12 matching lines @@
   // is currently being loaded and or in progress of being loaded and |second|
   // the image itself.
   typedef std::pair<base::FilePath, gfx::ImageSkia> CustomWallpaperElement;
   typedef std::map<AccountId, CustomWallpaperElement> CustomWallpaperMap;
 
   // Saves original custom wallpaper to |path| (absolute path) on filesystem
   // and starts resizing operation of the custom wallpaper if necessary.
   static void SaveCustomWallpaper(const WallpaperFilesId& wallpaper_files_id,
                                   const base::FilePath& path,
                                   WallpaperLayout layout,
-                                  scoped_ptr<gfx::ImageSkia> image);
+                                  std::unique_ptr<gfx::ImageSkia> image);
 
   // Moves custom wallpapers from user email directory to
   // |wallpaper_files_id| directory.
   static void MoveCustomWallpapersOnWorker(
       const AccountId& account_id,
       const WallpaperFilesId& wallpaper_files_id,
       const scoped_refptr<base::SingleThreadTaskRunner>& reply_task_runner,
       base::WeakPtr<WallpaperManagerBase> weak_ptr);
 
   // Gets |account_id|'s custom wallpaper at |wallpaper_path|. Falls back on
   // original custom wallpaper. When |update_wallpaper| is true, sets wallpaper
   // to the loaded wallpaper. Must run on wallpaper sequenced worker thread.
   static void GetCustomWallpaperInternal(
       const AccountId& account_id,
       const WallpaperInfo& info,
       const base::FilePath& wallpaper_path,
       bool update_wallpaper,
       const scoped_refptr<base::SingleThreadTaskRunner>& reply_task_runner,
       MovableOnDestroyCallbackHolder on_finish,
       base::WeakPtr<WallpaperManagerBase> weak_ptr);
 
   // Resize and save customized default wallpaper.
   static void 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);
 
   // Initialize wallpaper for the specified user to default and saves this
   // settings in local state.
   virtual void InitInitialUserWallpaper(const AccountId& account_id,
                                         bool is_persistent);
 
@@ skipping 64 matching lines @@
                                     WallpaperInfo* info) const = 0;
 
   // Sets wallpaper to the decoded wallpaper if |update_wallpaper| is true.
   // Otherwise, cache wallpaper to memory if not logged in.  (Takes a UserImage
   // because that's the callback interface provided by UserImageLoader.)
   virtual void OnWallpaperDecoded(
       const AccountId& account_id,
       WallpaperLayout layout,
       bool update_wallpaper,
       MovableOnDestroyCallbackHolder on_finish,
-      scoped_ptr<user_manager::UserImage> user_image) = 0;
+      std::unique_ptr<user_manager::UserImage> user_image) = 0;
 
   // Creates new PendingWallpaper request (or updates currently pending).
   virtual void ScheduleSetUserWallpaper(const AccountId& account_id,
                                         bool delayed) = 0;
 
   // Sets wallpaper to default.
   virtual void DoSetDefaultWallpaper(
       const AccountId& account_id,
       MovableOnDestroyCallbackHolder on_finish) = 0;
 
@@ skipping 15 matching lines @@
   // It is usually average wallpaper load time.
   // If last wallpaper load happened long ago, timeout should be reduced by
   // the time passed after last wallpaper load. So usual user experience results
   // in zero delay.
   virtual base::TimeDelta GetWallpaperLoadDelay() const;
 
   // This is called after we check that supplied default wallpaper files exist.
   virtual void SetCustomizedDefaultWallpaperAfterCheck(
       const GURL& wallpaper_url,
       const base::FilePath& downloaded_file,
-      scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files) = 0;
+      std::unique_ptr<CustomizedWallpaperRescaledFiles> rescaled_files) = 0;
 
   // Starts rescaling of customized wallpaper.
   virtual void OnCustomizedDefaultWallpaperDecoded(
       const GURL& wallpaper_url,
-      scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
-      scoped_ptr<user_manager::UserImage> user_image);
+      std::unique_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
+      std::unique_ptr<user_manager::UserImage> user_image);
 
   // Check the result of ResizeCustomizedDefaultWallpaper and finally
   // apply Customized Default Wallpaper.
   virtual void 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) = 0;
+      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) = 0;
 
   // Init |*default_*_wallpaper_file_| from given command line and
   // clear |default_wallpaper_image_|.
   virtual void SetDefaultWallpaperPathsFromCommandLine(
       base::CommandLine* command_line) = 0;
 
   // Sets wallpaper to decoded default.
   virtual void OnDefaultWallpaperDecoded(
       const base::FilePath& path,
       const WallpaperLayout layout,
-      scoped_ptr<user_manager::UserImage>* result,
+      std::unique_ptr<user_manager::UserImage>* result,
       MovableOnDestroyCallbackHolder on_finish,
-      scoped_ptr<user_manager::UserImage> user_image) = 0;
+      std::unique_ptr<user_manager::UserImage> user_image) = 0;
 
   // Start decoding given default wallpaper.
   virtual void StartLoadAndSetDefaultWallpaper(
       const base::FilePath& path,
       const WallpaperLayout layout,
       MovableOnDestroyCallbackHolder on_finish,
-      scoped_ptr<user_manager::UserImage>* result_out) = 0;
+      std::unique_ptr<user_manager::UserImage>* result_out) = 0;
 
   // Returns wallpaper subdirectory name for current resolution.
   virtual const char* GetCustomWallpaperSubdirForCurrentResolution();
 
   // Init default_wallpaper_image_ with 1x1 image of default color.
   virtual void CreateSolidDefaultWallpaper();
 
   // The number of loaded wallpapers.
   int loaded_wallpapers_for_test_;
 
@@ skipping 32 matching lines @@
   base::FilePath default_small_wallpaper_file_;
   base::FilePath default_large_wallpaper_file_;
 
   base::FilePath guest_small_wallpaper_file_;
   base::FilePath guest_large_wallpaper_file_;
 
   base::FilePath child_small_wallpaper_file_;
   base::FilePath child_large_wallpaper_file_;
 
   // Current decoded default image is stored in cache.
-  scoped_ptr<user_manager::UserImage> default_wallpaper_image_;
+  std::unique_ptr<user_manager::UserImage> default_wallpaper_image_;
 
   base::WeakPtrFactory<WallpaperManagerBase> weak_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WallpaperManagerBase);
 };
 
 }  // namespace wallpaper
 
 #endif  // COMPONENTS_WALLPAPER_WALLPAPER_MANAGER_BASE_H_