Move UserImage to user_manager

chrome/browser/chromeos/login/users/avatar/user_image_manager_impl.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/avatar/user_image_manager_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_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/login/helper.h"
 #include "chrome/browser/chromeos/login/users/avatar/default_user_images.h"
-#include "chrome/browser/chromeos/login/users/avatar/user_image.h"
 #include "chrome/browser/chromeos/login/users/avatar/user_image_sync_observer.h"
 #include "chrome/browser/chromeos/login/users/user_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile_downloader.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/chrome_paths.h"
+#include "components/user_manager/user_image/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 "policy/policy_constants.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace chromeos {
 
 namespace {
 
@@ skipping 103 matching lines @@
     case User::kExternalImageIndex:
       // TODO(ivankr): Distinguish this from selected from file.
       return kHistogramImageFromCamera;
     case User::kProfileImageIndex:
       return kHistogramImageFromProfile;
     default:
       return image_index;
   }
 }
 
-bool SaveImage(const UserImage& user_image, const base::FilePath& image_path) {
-  UserImage safe_image;
-  const UserImage::RawImage* encoded_image = NULL;
+bool SaveImage(const user_manager::UserImage& user_image,
+               const base::FilePath& image_path) {
+  user_manager::UserImage safe_image;
+  const user_manager::UserImage::RawImage* encoded_image = NULL;
   if (!user_image.is_safe_format()) {
-    safe_image = UserImage::CreateAndEncode(user_image.image());
+    safe_image = user_manager::UserImage::CreateAndEncode(user_image.image());
     encoded_image = &safe_image.raw_image();
     UMA_HISTOGRAM_MEMORY_KB("UserImage.RecodedJpegSize", encoded_image->size());
   } else if (user_image.has_raw_image()) {
     encoded_image = &user_image.raw_image();
   } else {
     NOTREACHED() << "Raw image missing.";
     return false;
   }
 
   if (!encoded_image->size() ||
@@ skipping 36 matching lines @@
                  const int image_index,
                  const GURL& image_url);
 
   // Sets the user image in local state to the default image indicated
   // by |default_image_index|. Also updates the user object with the
   // new image.
   void SetToDefaultImage(int default_image_index);
 
   // Saves the |user_image| to disk and sets the user image in local
   // state to that image. Also updates the user with the new image.
-  void SetToImage(int image_index, const UserImage& user_image);
+  void SetToImage(int image_index, const user_manager::UserImage& user_image);
 
   // Decodes the JPEG image |data|, crops and resizes the image, saves
   // it to disk and sets the user image in local state to that image.
   // Also updates the user object with the new image.
   void SetToImageData(scoped_ptr<std::string> data);
 
   // Loads the image at |path|, transcodes it to JPEG format, saves
   // the image to disk and sets the user image in local state to that
   // image.  If |resize| is true, the image is cropped and resized
   // before transcoding.  Also updates the user object with the new
   // image.
   void SetToPath(const base::FilePath& path,
                  int image_index,
                  const GURL& image_url,
                  bool resize);
 
  private:
   // Called back after an image has been loaded from disk.
-  void OnLoadImageDone(bool save, const UserImage& user_image);
+  void OnLoadImageDone(bool save, const user_manager::UserImage& user_image);
 
   // Updates the user object with |user_image_|.
   void UpdateUser();
 
   // Saves |user_image_| to disk in JPEG format. Local state will be updated
   // when a callback indicates that the image has been saved.
   void SaveImageAndUpdateLocalState();
 
   // Called back after the |user_image_| has been saved to
   // disk. Updates the user image information in local state. The
@@ skipping 16 matching lines @@
 
   UserImageManagerImpl* parent_;
 
   // Whether one of the Load*() or Set*() methods has been run already.
   bool run_;
 
   int image_index_;
   GURL image_url_;
   base::FilePath image_path_;
 
-  UserImage user_image_;
+  user_manager::UserImage user_image_;
 
   base::WeakPtrFactory<Job> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Job);
 };
 
 UserImageManagerImpl::Job::Job(UserImageManagerImpl* parent)
     : parent_(parent),
       run_(false),
       weak_factory_(this) {
 }
 
 UserImageManagerImpl::Job::~Job() {
 }
 
 void UserImageManagerImpl::Job::LoadImage(base::FilePath image_path,
                                           const int image_index,
                                           const GURL& image_url) {
   DCHECK(!run_);
   run_ = true;
 
   image_index_ = image_index;
   image_url_ = image_url;
   image_path_ = image_path;
 
   if (image_index_ >= 0 && image_index_ < kDefaultImagesCount) {
     // Load one of the default images. This happens synchronously.
-    user_image_ = UserImage(GetDefaultImage(image_index_));
+    user_image_ = user_manager::UserImage(GetDefaultImage(image_index_));
     UpdateUser();
     NotifyJobDone();
   } else if (image_index_ == User::kExternalImageIndex ||
              image_index_ == User::kProfileImageIndex) {
     // Load the user image from a file referenced by |image_path|. This happens
     // asynchronously. The JPEG image loader can be used here because
     // LoadImage() is called only for users whose user image has previously
     // been set by one of the Set*() methods, which transcode to JPEG format.
     DCHECK(!image_path_.empty());
     parent_->image_loader_->Start(image_path_.value(),
                                   0,
                                   base::Bind(&Job::OnLoadImageDone,
                                              weak_factory_.GetWeakPtr(),
                                              false));
   } else {
     NOTREACHED();
     NotifyJobDone();
   }
 }
 
 void UserImageManagerImpl::Job::SetToDefaultImage(int default_image_index) {
   DCHECK(!run_);
   run_ = true;
 
   DCHECK_LE(0, default_image_index);
   DCHECK_GT(kDefaultImagesCount, default_image_index);
 
   image_index_ = default_image_index;
-  user_image_ = UserImage(GetDefaultImage(image_index_));
+  user_image_ = user_manager::UserImage(GetDefaultImage(image_index_));
 
   UpdateUser();
   UpdateLocalState();
   NotifyJobDone();
 }
 
-void UserImageManagerImpl::Job::SetToImage(int image_index,
-                                           const UserImage& user_image) {
+void UserImageManagerImpl::Job::SetToImage(
+    int image_index,
+    const user_manager::UserImage& user_image) {
   DCHECK(!run_);
   run_ = true;
 
   DCHECK(image_index == User::kExternalImageIndex ||
          image_index == User::kProfileImageIndex);
 
   image_index_ = image_index;
   user_image_ = user_image;
 
   UpdateUser();
@@ skipping 34 matching lines @@
   image_url_ = image_url;
 
   DCHECK(!path.empty());
   parent_->unsafe_image_loader_->Start(path.value(),
                                        resize ? login::kMaxUserImageSize : 0,
                                        base::Bind(&Job::OnLoadImageDone,
                                                   weak_factory_.GetWeakPtr(),
                                                   true));
 }
 
-void UserImageManagerImpl::Job::OnLoadImageDone(bool save,
-                                                const UserImage& user_image) {
+void UserImageManagerImpl::Job::OnLoadImageDone(
+    bool save,
+    const user_manager::UserImage& user_image) {
   user_image_ = user_image;
   UpdateUser();
   if (save)
     SaveImageAndUpdateLocalState();
   else
     NotifyJobDone();
 }
 
 void UserImageManagerImpl::Job::UpdateUser() {
   User* user = parent_->user_manager_->FindUserAndModify(user_id());
@@ skipping 105 matching lines @@
     return;
 
   if (!image_properties) {
     SetInitialUserImage();
     return;
   }
 
   int image_index = User::kInvalidImageIndex;
   image_properties->GetInteger(kImageIndexNodeName, &image_index);
   if (image_index >= 0 && image_index < kDefaultImagesCount) {
-    user->SetImage(UserImage(GetDefaultImage(image_index)),
+    user->SetImage(user_manager::UserImage(GetDefaultImage(image_index)),
                    image_index);
     return;
   }
 
   if (image_index != User::kExternalImageIndex &&
       image_index != User::kProfileImageIndex) {
     NOTREACHED();
     return;
   }
 
@@ skipping 85 matching lines @@
   TryToCreateImageSyncObserver();
 }
 
 void UserImageManagerImpl::SaveUserDefaultImageIndex(int default_image_index) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
   job_->SetToDefaultImage(default_image_index);
 }
 
-void UserImageManagerImpl::SaveUserImage(const UserImage& user_image) {
+void UserImageManagerImpl::SaveUserImage(
+    const user_manager::UserImage& user_image) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
   job_->SetToImage(User::kExternalImageIndex, user_image);
 }
 
 void UserImageManagerImpl::SaveUserImageFromFile(const base::FilePath& path) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
   job_->SetToPath(path, User::kExternalImageIndex, GURL(), true);
 }
 
 void UserImageManagerImpl::SaveUserImageFromProfileImage() {
   if (IsUserImageManaged())
     return;
   // Use the profile image if it has been downloaded already. Otherwise, use a
   // stub image (gray avatar).
   job_.reset(new Job(this));
   job_->SetToImage(User::kProfileImageIndex,
-                   downloaded_profile_image_.isNull() ?
-                       UserImage() :
-                       UserImage::CreateAndEncode(downloaded_profile_image_));
+                   downloaded_profile_image_.isNull()
+                       ? user_manager::UserImage()
+                       : user_manager::UserImage::CreateAndEncode(
+                             downloaded_profile_image_));
   // If no profile image has been downloaded yet, ensure that a download is
   // started.
   if (downloaded_profile_image_.isNull())
     DownloadProfileData(kProfileDownloadReasonProfileImageChosen);
 }
 
 void UserImageManagerImpl::DeleteUserImage() {
   job_.reset();
   DeleteUserImageAndLocalStateEntry(kUserImages);
   DeleteUserImageAndLocalStateEntry(kUserImageProperties);
@@ skipping 335 matching lines @@
 
 bool UserImageManagerImpl::IsUserLoggedInAndRegular() const {
   const User* user = GetUser();
   if (!user)
     return false;
   return user->is_logged_in() &&
          user->GetType() == user_manager::USER_TYPE_REGULAR;
 }
 
 }  // namespace chromeos