[cros] Move User class to user_manager component.

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"
@@ skipping 17 matching lines @@
 #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/default_user_images.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 "grit/theme_resources.h"
 #include "policy/policy_constants.h"
+#include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace chromeos {
 
 namespace {
 
 // A dictionary that maps user_ids to old user image data with images stored in
 // PNG format. Deprecated.
 // TODO(ivankr): remove this const char after migration is gone.
 const char kUserImages[] = "UserImages";
@@ skipping 89 matching lines @@
       histogram_name, min_time, max_time, bucket_count,
       base::HistogramBase::kUmaTargetedHistogramFlag);
   counter->AddTime(time_delta);
 
   DVLOG(1) << "Profile image download time: " << time_delta.InSecondsF();
 }
 
 // Converts |image_index| to UMA histogram value.
 int ImageIndexToHistogramIndex(int image_index) {
   switch (image_index) {
-    case User::kExternalImageIndex:
+    case user_manager::User::USER_IMAGE_EXTERNAL:
       // TODO(ivankr): Distinguish this from selected from file.
       return user_manager::kHistogramImageFromCamera;
-    case User::kProfileImageIndex:
+    case user_manager::User::USER_IMAGE_PROFILE:
       return user_manager::kHistogramImageFromProfile;
     default:
       return image_index;
   }
 }
 
 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;
@@ skipping 136 matching lines @@
   image_index_ = image_index;
   image_url_ = image_url;
   image_path_ = image_path;
 
   if (image_index_ >= 0 && image_index_ < user_manager::kDefaultImagesCount) {
     // Load one of the default images. This happens synchronously.
     user_image_ =
         user_manager::UserImage(user_manager::GetDefaultImage(image_index_));
     UpdateUser();
     NotifyJobDone();
-  } else if (image_index_ == User::kExternalImageIndex ||
-             image_index_ == User::kProfileImageIndex) {
+  } else if (image_index_ == user_manager::User::USER_IMAGE_EXTERNAL ||
+             image_index_ == user_manager::User::USER_IMAGE_PROFILE) {
     // 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));
@@ skipping 18 matching lines @@
   UpdateLocalState();
   NotifyJobDone();
 }
 
 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);
+  DCHECK(image_index == user_manager::User::USER_IMAGE_EXTERNAL ||
+         image_index == user_manager::User::USER_IMAGE_PROFILE);
 
   image_index_ = image_index;
   user_image_ = user_image;
 
   UpdateUser();
   SaveImageAndUpdateLocalState();
 }
 
 void UserImageManagerImpl::Job::SetToImageData(scoped_ptr<std::string> data) {
   DCHECK(!run_);
   run_ = true;
 
-  image_index_ = User::kExternalImageIndex;
+  image_index_ = user_manager::User::USER_IMAGE_EXTERNAL;
 
   // This method uses the image_loader_, not the unsafe_image_loader_:
   // * This is necessary because the method is used to update the user image
   //   whenever the policy for a user is set. In the case of device-local
   //   accounts, policy may change at any time, even if the user is not
   //   currently logged in (and thus, the unsafe_image_loader_ may not be used).
   // * This is possible because only JPEG |data| is accepted. No support for
   //   other image file formats is needed.
   // * This is safe because the image_loader_ employs a hardened JPEG decoder
   //   that protects against malicious invalid image data being used to attack
@@ skipping 28 matching lines @@
     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());
+  user_manager::User* user =
+      parent_->user_manager_->FindUserAndModify(user_id());
   if (!user)
     return;
 
-  if (!user_image_.image().isNull())
+  if (!user_image_.image().isNull()) {
     user->SetImage(user_image_, image_index_);
-  else
-    user->SetStubImage(image_index_, false);
+  } else {
+    user->SetStubImage(
+        user_manager::UserImage(
+            *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+                IDR_PROFILE_PICTURE_LOADING)),
+        image_index_,
+        false);
+  }
   user->SetImageURL(image_url_);
 
   parent_->OnJobChangedUserImage();
 }
 
 void UserImageManagerImpl::Job::SaveImageAndUpdateLocalState() {
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
   image_path_ = user_data_dir.Append(user_id() + kSafeImagePathExtension);
 
   base::PostTaskAndReplyWithResult(
       parent_->background_task_runner_,
       FROM_HERE,
       base::Bind(&SaveImage, user_image_, image_path_),
       base::Bind(&Job::OnSaveImageDone, weak_factory_.GetWeakPtr()));
 }
 
 void UserImageManagerImpl::Job::OnSaveImageDone(bool success) {
-  if (success || image_index_ == User::kProfileImageIndex)
+  if (success || image_index_ == user_manager::User::USER_IMAGE_PROFILE)
     UpdateLocalState();
   NotifyJobDone();
 }
 
 void UserImageManagerImpl::Job::UpdateLocalState() {
   // Ignore if data stored or cached outside the user's cryptohome is to be
   // treated as ephemeral.
   if (parent_->user_manager_->IsUserNonCryptohomeDataEphemeral(user_id()))
     return;
 
@@ skipping 37 matching lines @@
 UserImageManagerImpl::~UserImageManagerImpl() {}
 
 void UserImageManagerImpl::LoadUserImage() {
   PrefService* local_state = g_browser_process->local_state();
   const base::DictionaryValue* prefs_images_unsafe =
       local_state->GetDictionary(kUserImages);
   const base::DictionaryValue* prefs_images =
       local_state->GetDictionary(kUserImageProperties);
   if (!prefs_images && !prefs_images_unsafe)
     return;
-  User* user = GetUserAndModify();
+  user_manager::User* user = GetUserAndModify();
   bool needs_migration = false;
 
   // If entries are found in both |prefs_images_unsafe| and |prefs_images|,
   // |prefs_images| is honored for now but |prefs_images_unsafe| will be
   // migrated, overwriting the |prefs_images| entry, when the user logs in.
   const base::DictionaryValue* image_properties = NULL;
   if (prefs_images_unsafe) {
     needs_migration = prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
         user_id(), &image_properties);
     if (needs_migration)
       user_needs_migration_ = true;
   }
   if (prefs_images) {
     prefs_images->GetDictionaryWithoutPathExpansion(user_id(),
                                                     &image_properties);
   }
 
   // If the user image for |user_id| is managed by policy and the policy-set
   // image is being loaded and persisted right now, let that job continue. It
   // will update the user image when done.
   if (IsUserImageManaged() && job_.get())
     return;
 
   if (!image_properties) {
     SetInitialUserImage();
     return;
   }
 
-  int image_index = User::kInvalidImageIndex;
+  int image_index = user_manager::User::USER_IMAGE_INVALID;
   image_properties->GetInteger(kImageIndexNodeName, &image_index);
   if (image_index >= 0 && image_index < user_manager::kDefaultImagesCount) {
     user->SetImage(
         user_manager::UserImage(user_manager::GetDefaultImage(image_index)),
         image_index);
     return;
   }
 
-  if (image_index != User::kExternalImageIndex &&
-      image_index != User::kProfileImageIndex) {
+  if (image_index != user_manager::User::USER_IMAGE_EXTERNAL &&
+      image_index != user_manager::User::USER_IMAGE_PROFILE) {
     NOTREACHED();
     return;
   }
 
   std::string image_url_string;
   image_properties->GetString(kImageURLNodeName, &image_url_string);
   GURL image_url(image_url_string);
   std::string image_path;
   image_properties->GetString(kImagePathNodeName, &image_path);
 
   user->SetImageURL(image_url);
-  user->SetStubImage(image_index, true);
-  DCHECK(!image_path.empty() || image_index == User::kProfileImageIndex);
+  user->SetStubImage(user_manager::UserImage(
+                         *ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
+                             IDR_PROFILE_PICTURE_LOADING)),
+                     image_index,
+                     true);
+  DCHECK(!image_path.empty() ||
+         image_index == user_manager::User::USER_IMAGE_PROFILE);
   if (image_path.empty() || needs_migration) {
     // Return if either of the following is true:
     // * The profile image is to be used but has not been downloaded yet. The
     //   profile image will be downloaded after login.
     // * The image needs migration. Migration will be performed after login.
     return;
   }
 
   job_.reset(new Job(this));
   job_->LoadImage(base::FilePath(image_path), image_index, image_url);
 }
 
 void UserImageManagerImpl::UserLoggedIn(bool user_is_new,
                                         bool user_is_local) {
-  const User* user = GetUser();
+  const user_manager::User* user = GetUser();
   if (user_is_new) {
     if (!user_is_local)
       SetInitialUserImage();
   } else {
     UMA_HISTOGRAM_ENUMERATION("UserImage.LoggedIn",
                               ImageIndexToHistogramIndex(user->image_index()),
                               user_manager::kHistogramImagesCount);
 
     if (!IsUserImageManaged() && user_needs_migration_) {
       const base::DictionaryValue* prefs_images_unsafe =
@@ skipping 56 matching lines @@
     return;
   job_.reset(new Job(this));
   job_->SetToDefaultImage(default_image_index);
 }
 
 void UserImageManagerImpl::SaveUserImage(
     const user_manager::UserImage& user_image) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
-  job_->SetToImage(User::kExternalImageIndex, user_image);
+  job_->SetToImage(user_manager::User::USER_IMAGE_EXTERNAL, user_image);
 }
 
 void UserImageManagerImpl::SaveUserImageFromFile(const base::FilePath& path) {
   if (IsUserImageManaged())
     return;
   job_.reset(new Job(this));
-  job_->SetToPath(path, User::kExternalImageIndex, GURL(), true);
+  job_->SetToPath(path, user_manager::User::USER_IMAGE_EXTERNAL, 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,
+  job_->SetToImage(user_manager::User::USER_IMAGE_PROFILE,
                    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);
 }
 
@@ skipping 22 matching lines @@
 }
 
 void UserImageManagerImpl::OnExternalDataSet(const std::string& policy) {
   DCHECK_EQ(policy::key::kUserAvatarImage, policy);
   if (IsUserImageManaged())
     return;
 
   has_managed_image_ = true;
   job_.reset();
 
-  const User* user = GetUser();
+  const user_manager::User* user = GetUser();
   // If the user image for the currently logged-in user became managed, stop the
   // sync observer so that the policy-set image does not get synced out.
   if (user && user->is_logged_in())
     user_image_sync_observer_.reset();
 }
 
 void UserImageManagerImpl::OnExternalDataCleared(const std::string& policy) {
   DCHECK_EQ(policy::key::kUserAvatarImage, policy);
   has_managed_image_ = false;
   SetInitialUserImage();
@@ skipping 84 matching lines @@
   }
 
   // Nothing to do if the picture is cached or is the default avatar.
   if (result != kDownloadSuccess)
     return;
 
   downloaded_profile_image_ = gfx::ImageSkia::CreateFrom1xBitmap(
       downloader->GetProfilePicture());
   profile_image_url_ = GURL(downloader->GetProfilePictureURL());
 
-  const User* user = GetUser();
-  if (user->image_index() == User::kProfileImageIndex) {
+  const user_manager::User* user = GetUser();
+  if (user->image_index() == user_manager::User::USER_IMAGE_PROFILE) {
     VLOG(1) << "Updating profile image for logged-in user.";
     UMA_HISTOGRAM_ENUMERATION("UserImage.ProfileDownloadResult",
                               kDownloadSuccessChanged,
                               kDownloadResultsCount);
     // This will persist |downloaded_profile_image_| to disk.
     SaveUserImageFromProfileImage();
   }
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PROFILE_IMAGE_UPDATED,
@@ skipping 39 matching lines @@
 }
 
 void UserImageManagerImpl::SetInitialUserImage() {
   // Choose a random default image.
   SaveUserDefaultImageIndex(
       base::RandInt(user_manager::kFirstDefaultImageIndex,
                     user_manager::kDefaultImagesCount - 1));
 }
 
 void UserImageManagerImpl::TryToInitDownloadedProfileImage() {
-  const User* user = GetUser();
-  if (user->image_index() == User::kProfileImageIndex &&
-      downloaded_profile_image_.isNull() &&
-      !user->image_is_stub()) {
+  const user_manager::User* user = GetUser();
+  if (user->image_index() == user_manager::User::USER_IMAGE_PROFILE &&
+      downloaded_profile_image_.isNull() && !user->image_is_stub()) {
     // Initialize the |downloaded_profile_image_| for the currently logged-in
     // user if it has not been initialized already, the user image is the
     // profile image and the user image has been loaded successfully.
     VLOG(1) << "Profile image initialized from disk.";
     downloaded_profile_image_ = user->GetImage();
     profile_image_url_ = user->image_url();
   }
 }
 
 bool UserImageManagerImpl::NeedProfileImage() const {
-  const User* user = GetUser();
+  const user_manager::User* user = GetUser();
   return IsUserLoggedInAndRegular() &&
-      (user->image_index() == User::kProfileImageIndex ||
-       profile_image_requested_);
+         (user->image_index() == user_manager::User::USER_IMAGE_PROFILE ||
+          profile_image_requested_);
 }
 
 void UserImageManagerImpl::DownloadProfileData(const std::string& reason) {
   // GAIA profiles exist for regular users only.
   if (!IsUserLoggedInAndRegular())
     return;
 
   // If a download is already in progress, allow it to continue, with one
   // exception: If the current download does not include the profile image but
   // the image has since become necessary, start a new download that includes
@@ skipping 30 matching lines @@
   update->RemoveWithoutPathExpansion(user_id(), NULL);
 }
 
 void UserImageManagerImpl::OnJobChangedUserImage() {
   if (GetUser()->is_logged_in())
     TryToInitDownloadedProfileImage();
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
       content::Source<UserImageManagerImpl>(this),
-      content::Details<const User>(GetUser()));
+      content::Details<const user_manager::User>(GetUser()));
 }
 
 void UserImageManagerImpl::OnJobDone() {
   if (job_.get())
     base::MessageLoopProxy::current()->DeleteSoon(FROM_HERE, job_.release());
   else
     NOTREACHED();
 
   if (!user_needs_migration_)
     return;
   // Migration completed for |user_id|.
   user_needs_migration_ = false;
 
   const base::DictionaryValue* prefs_images_unsafe =
       g_browser_process->local_state()->GetDictionary(kUserImages);
   const base::DictionaryValue* image_properties = NULL;
   if (!prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
           user_id(), &image_properties)) {
     NOTREACHED();
     return;
   }
 
-  int image_index = User::kInvalidImageIndex;
+  int image_index = user_manager::User::USER_IMAGE_INVALID;
   image_properties->GetInteger(kImageIndexNodeName, &image_index);
   UMA_HISTOGRAM_ENUMERATION("UserImage.Migration",
                             ImageIndexToHistogramIndex(image_index),
                             user_manager::kHistogramImagesCount);
 
   std::string image_path;
   image_properties->GetString(kImagePathNodeName, &image_path);
   if (!image_path.empty()) {
     // If an old image exists, delete it and remove |user_id| from the old prefs
     // dictionary only after the deletion has completed. This ensures that no
@@ skipping 13 matching lines @@
   }
 }
 
 void UserImageManagerImpl::UpdateLocalStateAfterMigration() {
   DictionaryPrefUpdate update(g_browser_process->local_state(),
                               kUserImages);
   update->RemoveWithoutPathExpansion(user_id(), NULL);
 }
 
 void UserImageManagerImpl::TryToCreateImageSyncObserver() {
-  const User* user = GetUser();
+  const user_manager::User* user = GetUser();
   // If the currently logged-in user's user image is managed, the sync observer
   // must not be started so that the policy-set image does not get synced out.
   if (!user_image_sync_observer_ &&
       user && user->CanSyncImage() &&
       !IsUserImageManaged()) {
     user_image_sync_observer_.reset(new UserImageSyncObserver(user));
   }
 }
 
-const User* UserImageManagerImpl::GetUser() const {
+const user_manager::User* UserImageManagerImpl::GetUser() const {
   return user_manager_->FindUser(user_id());
 }
 
-User* UserImageManagerImpl::GetUserAndModify() const {
+user_manager::User* UserImageManagerImpl::GetUserAndModify() const {
   return user_manager_->FindUserAndModify(user_id());
 }
 
 bool UserImageManagerImpl::IsUserLoggedInAndRegular() const {
-  const User* user = GetUser();
+  const user_manager::User* user = GetUser();
   if (!user)
     return false;
   return user->is_logged_in() &&
          user->GetType() == user_manager::USER_TYPE_REGULAR;
 }
 
 }  // namespace chromeos