Move UserImage to user_manager

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 <numeric>
 #include <vector>
 
 #include "ash/ash_constants.h"
@@ skipping 15 matching lines @@
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/customization_document.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
-#include "chrome/browser/chromeos/login/users/avatar/user_image.h"
 #include "chrome/browser/chromeos/login/users/user.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "components/user_manager/avatar/user_image.h"
 #include "components/user_manager/user_type.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skia_util.h"
 
 using content::BrowserThread;
 
@@ skipping 770 matching lines @@
 base::FilePath WallpaperManager::GetCustomWallpaperPath(
     const char* sub_dir,
     const std::string& user_id_hash,
     const std::string& file) {
   base::FilePath custom_wallpaper_path = GetCustomWallpaperDir(sub_dir);
   return custom_wallpaper_path.Append(user_id_hash).Append(file);
 }
 
 void WallpaperManager::SetPolicyControlledWallpaper(
     const std::string& user_id,
-    const UserImage& user_image) {
+    const user_manager::UserImage& user_image) {
   const User *user = chromeos::UserManager::Get()->FindUser(user_id);
   if (!user) {
     NOTREACHED() << "Unknown user.";
     return;
   }
   SetCustomWallpaper(user_id,
                      user->username_hash(),
                      "policy-controlled.jpeg",
                      ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
                      User::POLICY,
@@ skipping 684 matching lines @@
                  logged_in_user->email(),
                  logged_in_user->username_hash(),
                  weak_factory_.GetWeakPtr()));
 }
 
 void WallpaperManager::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) {
   DCHECK(BrowserThread::CurrentlyOn(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 = {
                            "",
                            ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
@@ skipping 97 matching lines @@
     SetDefaultWallpaperPath(rescaled_files->path_rescaled_small(),
                             scoped_ptr<gfx::ImageSkia>().Pass(),
                             rescaled_files->path_rescaled_large(),
                             scoped_ptr<gfx::ImageSkia>().Pass());
   }
 }
 
 void WallpaperManager::OnCustomizedDefaultWallpaperDecoded(
     const GURL& wallpaper_url,
     scoped_ptr<CustomizedWallpaperRescaledFiles> rescaled_files,
-    const UserImage& wallpaper) {
+    const user_manager::UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // 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();
   scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper.image().DeepCopy());
@@ skipping 21 matching lines @@
                  base::Passed(large_wallpaper_image.Pass()));
 
   if (!task_runner_->PostTaskAndReply(
           FROM_HERE, resize_closure, on_resized_closure)) {
     LOG(WARNING) << "Failed to start Customized Wallpaper resize.";
   }
 }
 
 void WallpaperManager::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) {
   *success = true;
 
   *success &= ResizeAndSaveWallpaper(*image,
                                      rescaled_files->path_rescaled_small(),
                                      ash::WALLPAPER_LAYOUT_STRETCH,
                                      kSmallWallpaperMaxWidth,
@@ skipping 108 matching lines @@
   guest_small_wallpaper_file_ =
       command_line->GetSwitchValuePath(ash::switches::kAshGuestWallpaperSmall);
   guest_large_wallpaper_file_ =
       command_line->GetSwitchValuePath(ash::switches::kAshGuestWallpaperLarge);
   default_wallpaper_image_.reset();
 }
 
 void WallpaperManager::OnDefaultWallpaperDecoded(
     const base::FilePath& path,
     const ash::WallpaperLayout layout,
-    scoped_ptr<chromeos::UserImage>* result_out,
+    scoped_ptr<user_manager::UserImage>* result_out,
     MovableOnDestroyCallbackHolder on_finish,
-    const UserImage& user_image) {
-  result_out->reset(new UserImage(user_image));
+    const user_manager::UserImage& user_image) {
+  result_out->reset(new user_manager::UserImage(user_image));
   ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
       user_image.image(), layout);
 }
 
 void WallpaperManager::StartLoadAndSetDefaultWallpaper(
     const base::FilePath& path,
     const ash::WallpaperLayout layout,
     MovableOnDestroyCallbackHolder on_finish,
-    scoped_ptr<chromeos::UserImage>* result_out) {
+    scoped_ptr<user_manager::UserImage>* result_out) {
   wallpaper_loader_->Start(
       path.value(),
       0,  // Do not crop.
       base::Bind(&WallpaperManager::OnDefaultWallpaperDecoded,
                  weak_factory_.GetWeakPtr(),
                  path,
                  layout,
                  base::Unretained(result_out),
                  base::Passed(on_finish.Pass())));
 }
@@ skipping 22 matching lines @@
   // as a placeholder only.
   const bool need_update_screen =
       default_wallpaper_image_.get() &&
       dbc->WallpaperIsAlreadyLoaded(default_wallpaper_image_->image(),
                                     false /* compare_layouts */,
                                     ash::WALLPAPER_LAYOUT_CENTER);
 
   default_wallpaper_image_.reset();
   if (GetAppropriateResolution() == WALLPAPER_RESOLUTION_SMALL) {
     if (small_wallpaper_image) {
-      default_wallpaper_image_.reset(new UserImage(*small_wallpaper_image));
+      default_wallpaper_image_.reset(
+          new user_manager::UserImage(*small_wallpaper_image));
       default_wallpaper_image_->set_file_path(
           default_small_wallpaper_file.value());
     }
   } else {
     if (large_wallpaper_image) {
-      default_wallpaper_image_.reset(new UserImage(*large_wallpaper_image));
+      default_wallpaper_image_.reset(
+          new user_manager::UserImage(*large_wallpaper_image));
       default_wallpaper_image_->set_file_path(
           default_large_wallpaper_file.value());
     }
   }
 
   if (need_update_screen) {
     DoSetDefaultWallpaper(std::string(),
                           MovableOnDestroyCallbackHolder().Pass());
   }
 }
 
 void WallpaperManager::CreateSolidDefaultWallpaper() {
   loaded_wallpapers_++;
   SkBitmap bitmap;
   bitmap.allocN32Pixels(1, 1);
   bitmap.eraseColor(kDefaultWallpaperColor);
   const gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(bitmap);
-  default_wallpaper_image_.reset(new UserImage(image));
+  default_wallpaper_image_.reset(new user_manager::UserImage(image));
 }
 
 }  // namespace chromeos