[cros, user_manager] Move default user images constants and helper functions out of src/chrome.

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_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/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 "policy/policy_constants.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace chromeos {
 
 namespace {
@@ skipping 96 matching lines @@
   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:
       // TODO(ivankr): Distinguish this from selected from file.
-      return kHistogramImageFromCamera;
+      return user_manager::kHistogramImageFromCamera;
     case User::kProfileImageIndex:
-      return kHistogramImageFromProfile;
+      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;
   if (!user_image.is_safe_format()) {
@@ skipping 129 matching lines @@
 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) {
+  if (image_index_ >= 0 && image_index_ < user_manager::kDefaultImagesCount) {
     // Load one of the default images. This happens synchronously.
-    user_image_ = user_manager::UserImage(GetDefaultImage(image_index_));
+    user_image_ =
+        user_manager::UserImage(user_manager::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);
+  DCHECK_GT(user_manager::kDefaultImagesCount, default_image_index);
 
   image_index_ = default_image_index;
-  user_image_ = user_manager::UserImage(GetDefaultImage(image_index_));
+  user_image_ =
+      user_manager::UserImage(user_manager::GetDefaultImage(image_index_));
 
   UpdateUser();
   UpdateLocalState();
   NotifyJobDone();
 }
 
 void UserImageManagerImpl::Job::SetToImage(
     int image_index,
     const user_manager::UserImage& user_image) {
   DCHECK(!run_);
@@ skipping 170 matching lines @@
   if (IsUserImageManaged() && job_.get())
     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(user_manager::UserImage(GetDefaultImage(image_index)),
-                   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) {
     NOTREACHED();
     return;
   }
 
   std::string image_url_string;
@@ skipping 19 matching lines @@
 
 void UserImageManagerImpl::UserLoggedIn(bool user_is_new,
                                         bool user_is_local) {
   const User* user = GetUser();
   if (user_is_new) {
     if (!user_is_local)
       SetInitialUserImage();
   } else {
     UMA_HISTOGRAM_ENUMERATION("UserImage.LoggedIn",
                               ImageIndexToHistogramIndex(user->image_index()),
-                              kHistogramImagesCount);
+                              user_manager::kHistogramImagesCount);
 
     if (!IsUserImageManaged() && user_needs_migration_) {
       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)) {
         std::string image_path;
         image_properties->GetString(kImagePathNodeName, &image_path);
         job_.reset(new Job(this));
@@ skipping 268 matching lines @@
       content::Source<UserImageManager>(this),
       content::NotificationService::NoDetails());
 }
 
 bool UserImageManagerImpl::IsUserImageManaged() const {
   return has_managed_image_;
 }
 
 void UserImageManagerImpl::SetInitialUserImage() {
   // Choose a random default image.
-  SaveUserDefaultImageIndex(base::RandInt(kFirstDefaultImageIndex,
-                                          kDefaultImagesCount - 1));
+  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()) {
     // 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.
@@ skipping 78 matching lines @@
   if (!prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
           user_id(), &image_properties)) {
     NOTREACHED();
     return;
   }
 
   int image_index = User::kInvalidImageIndex;
   image_properties->GetInteger(kImageIndexNodeName, &image_index);
   UMA_HISTOGRAM_ENUMERATION("UserImage.Migration",
                             ImageIndexToHistogramIndex(image_index),
-                            kHistogramImagesCount);
+                            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
     // orphaned image is left behind if the browser crashes before the deletion
     // has been performed: In that case, local state will be unchanged and the
     // migration will be run again on the user's next login.
     background_task_runner_->PostTaskAndReply(
@@ skipping 36 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