Replace chromeos::UserManager::Get() with chromeos::GetUserManager().

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 527 matching lines @@
   if (!ash::Shell::HasInstance())
     return;
 
   WallpaperInfo info;
   if (GetLoggedInUserWallpaperInfo(&info)) {
     // TODO(sschmitz): We need an index for default wallpapers for the new UI.
     RecordUma(info.type, -1);
     if (info == current_user_wallpaper_info_)
       return;
   }
-  SetUserWallpaperNow(UserManager::Get()->GetLoggedInUser()->email());
+  SetUserWallpaperNow(GetUserManager()->GetLoggedInUser()->email());
 }
 
 void WallpaperManager::ClearDisposableWallpaperCache() {
   // Cancel callback for previous cache requests.
   weak_factory_.InvalidateWeakPtrs();
   // Keep the wallpaper of logged in users in cache at multi-profile mode.
   std::set<std::string> logged_in_users_names;
-  const UserList& logged_users = UserManager::Get()->GetLoggedInUsers();
+  const UserList& logged_users = GetUserManager()->GetLoggedInUsers();
   for (UserList::const_iterator it = logged_users.begin();
        it != logged_users.end();
        ++it) {
     logged_in_users_names.insert((*it)->email());
   }
 
   CustomWallpaperMap logged_in_users_cache;
   for (CustomWallpaperMap::iterator it = wallpaper_cache_.begin();
        it != wallpaper_cache_.end(); ++it) {
     if (logged_in_users_names.find(it->first) !=
         logged_in_users_names.end()) {
       logged_in_users_cache.insert(*it);
     }
   }
   wallpaper_cache_ = logged_in_users_cache;
 }
 
 bool WallpaperManager::GetLoggedInUserWallpaperInfo(WallpaperInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (UserManager::Get()->IsLoggedInAsStub()) {
+  if (GetUserManager()->IsLoggedInAsStub()) {
     info->file = current_user_wallpaper_info_.file = "";
     info->layout = current_user_wallpaper_info_.layout =
         ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type = User::DEFAULT;
     info->date = current_user_wallpaper_info_.date =
         base::Time::Now().LocalMidnight();
     return true;
   }
 
-  return GetUserWallpaperInfo(UserManager::Get()->GetLoggedInUser()->email(),
+  return GetUserWallpaperInfo(GetUserManager()->GetLoggedInUser()->email(),
                               info);
 }
 
 void WallpaperManager::InitializeWallpaper() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  UserManager* user_manager = UserManager::Get();
+  UserManager* user_manager = GetUserManager();
 
   // Apply device customization.
   if (ShouldUseCustomizedDefaultWallpaper()) {
     SetDefaultWallpaperPath(
         GetCustomizedWallpaperDefaultRescaledFileName(kSmallWallpaperSuffix),
         scoped_ptr<gfx::ImageSkia>().Pass(),
         GetCustomizedWallpaperDefaultRescaledFileName(kLargeWallpaperSuffix),
         scoped_ptr<gfx::ImageSkia>().Pass());
   }
 
@@ skipping 223 matching lines @@
     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 *user = chromeos::UserManager::Get()->FindUser(user_id);
+  const User* user = chromeos::GetUserManager()->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,
                      user_image.image(),
                      true /* update wallpaper */);
 }
 
 void WallpaperManager::SetCustomWallpaper(const std::string& user_id,
                                           const std::string& user_id_hash,
                                           const std::string& file,
                                           ash::WallpaperLayout layout,
                                           User::WallpaperType type,
                                           const gfx::ImageSkia& image,
                                           bool update_wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  DCHECK(UserManager::Get()->IsUserLoggedIn());
+  DCHECK(GetUserManager()->IsUserLoggedIn());
 
   // There is no visible background in kiosk mode.
-  if (UserManager::Get()->IsLoggedInAsKioskApp())
+  if (GetUserManager()->IsLoggedInAsKioskApp())
     return;
 
   // Don't allow custom wallpapers while policy is in effect.
   if (type != User::POLICY && IsPolicyControlled(user_id))
     return;
 
   base::FilePath wallpaper_path =
       GetCustomWallpaperPath(kOriginalWallpaperSubDir, user_id_hash, file);
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
   // Use default wallpaper in this case.
   if (image.isNull()) {
     SetDefaultWallpaperDelayed(user_id);
     return;
   }
 
   bool is_persistent =
-      !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id);
+      !GetUserManager()->IsUserNonCryptohomeDataEphemeral(user_id);
 
   WallpaperInfo wallpaper_info = {
       wallpaper_path.value(),
       layout,
       type,
       // Date field is not used.
       base::Time::Now().LocalMidnight()
   };
   if (is_persistent) {
     image.EnsureRepsForSupportedScales();
@@ skipping 36 matching lines @@
 }
 
 void WallpaperManager::SetDefaultWallpaperDelayed(const std::string& user_id) {
   GetPendingWallpaper(user_id, true)->ResetSetDefaultWallpaper();
 }
 
 void WallpaperManager::DoSetDefaultWallpaper(
     const std::string& user_id,
     MovableOnDestroyCallbackHolder on_finish) {
   // There is no visible background in kiosk mode.
-  if (UserManager::Get()->IsLoggedInAsKioskApp())
+  if (GetUserManager()->IsLoggedInAsKioskApp())
     return;
   current_wallpaper_path_.clear();
   wallpaper_cache_.erase(user_id);
   // Some browser tests do not have a shell instance. As no wallpaper is needed
   // in these tests anyway, avoid loading one, preventing crashes and speeding
   // up the tests.
   if (!ash::Shell::HasInstance())
     return;
 
   WallpaperResolution resolution = GetAppropriateResolution();
   const bool use_small = (resolution == WALLPAPER_RESOLUTION_SMALL);
 
   const base::FilePath* file = NULL;
 
-  if (UserManager::Get()->IsLoggedInAsGuest()) {
+  if (GetUserManager()->IsLoggedInAsGuest()) {
     file =
         use_small ? &guest_small_wallpaper_file_ : &guest_large_wallpaper_file_;
   } else {
     file = use_small ? &default_small_wallpaper_file_
                      : &default_large_wallpaper_file_;
   }
   ash::WallpaperLayout layout = use_small
                                     ? ash::WALLPAPER_LAYOUT_CENTER
                                     : ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
   DCHECK(file);
@@ skipping 175 matching lines @@
   ScheduleSetUserWallpaper(user_id, false);
 }
 
 void WallpaperManager::ScheduleSetUserWallpaper(const std::string& user_id,
                                                 bool delayed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Some unit tests come here without a UserManager or without a pref system.
   if (!UserManager::IsInitialized() || !g_browser_process->local_state())
     return;
   // There is no visible background in kiosk mode.
-  if (UserManager::Get()->IsLoggedInAsKioskApp())
+  if (GetUserManager()->IsLoggedInAsKioskApp())
     return;
   // Guest user, regular user in ephemeral mode, or kiosk app.
-  const User* user = UserManager::Get()->FindUser(user_id);
-  if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id) ||
+  const User* user = GetUserManager()->FindUser(user_id);
+  if (GetUserManager()->IsUserNonCryptohomeDataEphemeral(user_id) ||
       (user != NULL && user->GetType() == user_manager::USER_TYPE_KIOSK_APP)) {
     InitInitialUserWallpaper(user_id, false);
     GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
     return;
   }
 
-  if (!UserManager::Get()->IsKnownUser(user_id))
+  if (!GetUserManager()->IsKnownUser(user_id))
     return;
 
   last_selected_user_ = user_id;
 
   WallpaperInfo info;
 
   if (!GetUserWallpaperInfo(user_id, &info)) {
     InitInitialUserWallpaper(user_id, true);
     GetUserWallpaperInfo(user_id, &info);
   }
@@ skipping 32 matching lines @@
 
     // Load downloaded ONLINE or converted DEFAULT wallpapers.
     GetPendingWallpaper(user_id, delayed)->ResetLoadWallpaper(info);
   }
 }
 
 void WallpaperManager::SetWallpaperFromImageSkia(const std::string& user_id,
                                                  const gfx::ImageSkia& image,
                                                  ash::WallpaperLayout layout,
                                                  bool update_wallpaper) {
-  DCHECK(UserManager::Get()->IsUserLoggedIn());
+  DCHECK(GetUserManager()->IsUserLoggedIn());
 
   // There is no visible background in kiosk mode.
-  if (UserManager::Get()->IsLoggedInAsKioskApp())
+  if (GetUserManager()->IsLoggedInAsKioskApp())
     return;
   WallpaperInfo info;
   info.layout = layout;
   wallpaper_cache_[user_id] = image;
 
   if (update_wallpaper) {
     GetPendingWallpaper(last_selected_user_, false /* Not delayed */)
         ->ResetSetWallpaperImage(image, info);
   }
 }
@@ skipping 35 matching lines @@
   CustomWallpaperMap::const_iterator it = wallpaper_cache_.find(user_id);
   if (it != wallpaper_cache_.end()) {
     *image = (*it).second;
     return true;
   }
   return false;
 }
 
 void WallpaperManager::CacheUsersWallpapers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  UserList users = UserManager::Get()->GetUsers();
+  UserList users = GetUserManager()->GetUsers();
 
   if (!users.empty()) {
     UserList::const_iterator it = users.begin();
     // Skip the wallpaper of first user in the list. It should have been cached.
     it++;
     for (int cached = 0;
          it != users.end() && cached < kMaxWallpapersToCache;
          ++it, ++cached) {
       std::string user_id = (*it)->email();
       CacheUserWallpaper(user_id);
@@ skipping 83 matching lines @@
   SetDefaultWallpaperPathsFromCommandLine(command_line);
 }
 
 CommandLine* WallpaperManager::GetCommandLine() {
   CommandLine* command_line = command_line_for_testing_ ?
       command_line_for_testing_ : CommandLine::ForCurrentProcess();
   return command_line;
 }
 
 void WallpaperManager::InitializeRegisteredDeviceWallpaper() {
-  if (UserManager::Get()->IsUserLoggedIn())
+  if (GetUserManager()->IsUserLoggedIn())
     return;
 
   bool disable_boot_animation =
       GetCommandLine()->HasSwitch(switches::kDisableBootAnimation);
   bool show_users = true;
   bool result = CrosSettings::Get()->GetBoolean(
       kAccountsPrefShowUserNamesOnSignIn, &show_users);
   DCHECK(result) << "Unable to fetch setting "
                  << kAccountsPrefShowUserNamesOnSignIn;
-  const chromeos::UserList& users = UserManager::Get()->GetUsers();
+  const chromeos::UserList& users = GetUserManager()->GetUsers();
   int public_session_user_index = FindPublicSession(users);
   if ((!show_users && public_session_user_index == -1) || users.empty()) {
     // Boot into sign in form, preload default wallpaper.
     SetDefaultWallpaperDelayed(UserManager::kSignInUser);
     return;
   }
 
   if (!disable_boot_animation) {
     int index = public_session_user_index != -1 ? public_session_user_index : 0;
     // Normal boot, load user wallpaper.
@@ skipping 63 matching lines @@
     // crosbug.com/38429.
     LOG(ERROR) << "Wallpaper reverts to default unexpected.";
     DoSetDefaultWallpaper(user_id, on_finish.Pass());
   }
 }
 
 bool WallpaperManager::GetUserWallpaperInfo(const std::string& user_id,
                                             WallpaperInfo* info) const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id)) {
+  if (GetUserManager()->IsUserNonCryptohomeDataEphemeral(user_id)) {
     // Default to the values cached in memory.
     *info = current_user_wallpaper_info_;
 
     // Ephemeral users do not save anything to local state. But we have got
     // wallpaper info from memory. Returns true.
     return true;
   }
 
   const base::DictionaryValue* info_dict;
   if (!g_browser_process->local_state()->
@@ skipping 31 matching lines @@
     const std::string& user_id_hash) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   if (info.type == User::CUSTOMIZED) {
     // New file field should include user id hash in addition to file name.
     // This is needed because at login screen, user id hash is not available.
     std::string relative_path =
         base::FilePath(user_id_hash).Append(info.file).value();
     info.file = relative_path;
     bool is_persistent =
-        !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id);
+        !GetUserManager()->IsUserNonCryptohomeDataEphemeral(user_id);
     SetUserWallpaperInfo(user_id, info, is_persistent);
   }
 }
 
 void WallpaperManager::MoveLoggedInUserCustomWallpaper() {
-  const User* logged_in_user = UserManager::Get()->GetLoggedInUser();
+  const User* logged_in_user = GetUserManager()->GetLoggedInUser();
   task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WallpaperManager::MoveCustomWallpapersOnWorker,
                  logged_in_user->email(),
                  logged_in_user->username_hash(),
                  weak_factory_.GetWeakPtr()));
 }
 
 void WallpaperManager::OnWallpaperDecoded(
     const std::string& user_id,
@@ skipping 365 matching lines @@
 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));
 }
 
 }  // namespace chromeos