Move UserImage to user_manager

chrome/browser/chromeos/login/users/wallpaper/wallpaper_manager.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 CHROME_BROWSER_CHROMEOS_LOGIN_USERS_WALLPAPER_WALLPAPER_MANAGER_H_
 #define CHROME_BROWSER_CHROMEOS_LOGIN_USERS_WALLPAPER_WALLPAPER_MANAGER_H_
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "base/files/file_path.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/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
-#include "chrome/browser/chromeos/login/users/avatar/user_image.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_loader.h"
 #include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "components/user_manager/user_image/user_image.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
 #include "ui/gfx/image/image_skia.h"
 
 class PrefRegistrySimple;
 
 namespace base {
 class CommandLine;
 class SequencedTaskRunner;
 }
 
+namespace user_manager {
+class UserImage;
+}
+
 namespace chromeos {
 
 struct WallpaperInfo {
   // Online wallpaper URL or file name of migrated wallpaper.
   std::string file;
   ash::WallpaperLayout layout;
   User::WallpaperType type;
   base::Time date;
   bool operator==(const WallpaperInfo& other) {
     return (file == other.file) && (layout == other.layout) &&
         (type == other.type);
   }
 };
 
 class MovableOnDestroyCallback;
 typedef scoped_ptr<MovableOnDestroyCallback> MovableOnDestroyCallbackHolder;
 
 class WallpaperManagerBrowserTest;
-class UserImage;
 
 // Name of wallpaper sequence token.
 extern const char kWallpaperSequenceTokenName[];
 
 // File path suffices of resized small or large wallpaper.
 // TODO(bshe): Use the same sub folder system as custom wallpapers use.
 // crbug.com/174928
 extern const char kSmallWallpaperSuffix[];
 extern const char kLargeWallpaperSuffix[];
 
@@ skipping 310 matching lines @@
       const std::string& user_id,
       const WallpaperInfo& info,
       const base::FilePath& wallpaper_path,
       bool update_wallpaper,
       MovableOnDestroyCallbackHolder on_finish,
       base::WeakPtr<WallpaperManager> weak_ptr);
 
   // Resize and save customized default wallpaper.
   static void ResizeCustomizedDefaultWallpaper(
       scoped_ptr<gfx::ImageSkia> image,
-      const UserImage::RawImage& raw_image,
+      const user_manager::UserImage::RawImage& raw_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.
   void InitInitialUserWallpaper(const std::string& user_id, bool is_persistent);
 
   // Set wallpaper to |user_image| controlled by policy.  (Takes a UserImage
   // because that's the callback interface provided by UserImageLoader.)
   void SetPolicyControlledWallpaper(const std::string& user_id,
-                                    const UserImage& user_image);
+                                    const user_manager::UserImage& user_image);
 
   // Gets encoded wallpaper from cache. Returns true if success.
   bool GetWallpaperFromCache(const std::string& user_id, gfx::ImageSkia* image);
 
   // The number of wallpapers have loaded. For test only.
   int loaded_wallpapers() const { return loaded_wallpapers_; }
 
   // Cache some (or all) logged in users' wallpapers to memory at login
   // screen. It should not compete with first wallpaper loading when boot
   // up/initialize login WebUI page.
@@ skipping 50 matching lines @@
   bool GetUserWallpaperInfo(const std::string& user_id,
                             WallpaperInfo* info) const;
 
   // 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.)
   void OnWallpaperDecoded(const std::string& user_id,
                           ash::WallpaperLayout layout,
                           bool update_wallpaper,
                           MovableOnDestroyCallbackHolder on_finish,
-                          const UserImage& user_image);
+                          const user_manager::UserImage& user_image);
 
   // Creates new PendingWallpaper request (or updates currently pending).
   void ScheduleSetUserWallpaper(const std::string& user_id, bool delayed);
 
   // Sets wallpaper to default.
   void DoSetDefaultWallpaper(
       const std::string& user_id,
       MovableOnDestroyCallbackHolder on_finish);
 
   // Starts to load wallpaper at |wallpaper_path|. If |wallpaper_path| is the
@@ skipping 28 matching lines @@
   // This is called after we check that supplied default wallpaper files exist.
   void SetCustomizedDefaultWallpaperAfterCheck(
       const GURL& wallpaper_url,
       const base::FilePath& downloaded_file,
       scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files);
 
   // Starts rescaling of customized wallpaper.
   void OnCustomizedDefaultWallpaperDecoded(
       const GURL& wallpaper_url,
       scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
-      const UserImage& user_image);
+      const user_manager::UserImage& user_image);
 
   // Check the result of ResizeCustomizedDefaultWallpaper and finally
   // apply Customized Default Wallpaper.
   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);
 
   // Init |*default_*_wallpaper_file_| from given command line and
   // clear |default_wallpaper_image_|.
   void SetDefaultWallpaperPathsFromCommandLine(base::CommandLine* command_line);
 
   // Sets wallpaper to decoded default.
   void OnDefaultWallpaperDecoded(const base::FilePath& path,
                                  const ash::WallpaperLayout layout,
-                                 scoped_ptr<UserImage>* result,
+                                 scoped_ptr<user_manager::UserImage>* result,
                                  MovableOnDestroyCallbackHolder on_finish,
-                                 const UserImage& user_image);
+                                 const user_manager::UserImage& user_image);
 
   // Start decoding given default wallpaper.
-  void StartLoadAndSetDefaultWallpaper(const base::FilePath& path,
-                                       const ash::WallpaperLayout layout,
-                                       MovableOnDestroyCallbackHolder on_finish,
-                                       scoped_ptr<UserImage>* result_out);
+  void StartLoadAndSetDefaultWallpaper(
+      const base::FilePath& path,
+      const ash::WallpaperLayout layout,
+      MovableOnDestroyCallbackHolder on_finish,
+      scoped_ptr<user_manager::UserImage>* result_out);
 
   // Returns wallpaper subdirectory name for current resolution.
   const char* GetCustomWallpaperSubdirForCurrentResolution();
 
   // Init default_wallpaper_image_ with 1x1 image of default color.
   void CreateSolidDefaultWallpaper();
 
   // The number of loaded wallpapers.
   int loaded_wallpapers_;
 
@@ skipping 50 matching lines @@
   typedef std::vector<scoped_refptr<PendingWallpaper> > PendingList;
   PendingList loading_;
 
   base::FilePath default_small_wallpaper_file_;
   base::FilePath default_large_wallpaper_file_;
 
   base::FilePath guest_small_wallpaper_file_;
   base::FilePath guest_large_wallpaper_file_;
 
   // Current decoded default image is stored in cache.
-  scoped_ptr<UserImage> default_wallpaper_image_;
+  scoped_ptr<user_manager::UserImage> default_wallpaper_image_;
 
   DISALLOW_COPY_AND_ASSIGN(WallpaperManager);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_LOGIN_USERS_WALLPAPER_WALLPAPER_MANAGER_H_