[cros] user_manager component - move UserManagerBase and UserManager

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 16 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/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/cryptohome/async_method_caller.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/user_names.h"
 #include "components/user_manager/user.h"
 #include "components/user_manager/user_image/user_image.h"
+#include "components/user_manager/user_manager.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 470 matching lines @@
   if (!ash::Shell::HasInstance())
     return;
 
   WallpaperInfo info;
   if (GetLoggedInUserWallpaperInfo(&info)) {
     UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Type", info.type,
                               user_manager::User::WALLPAPER_TYPE_COUNT);
     if (info == current_user_wallpaper_info_)
       return;
   }
-  SetUserWallpaperNow(UserManager::Get()->GetLoggedInUser()->email());
+  SetUserWallpaperNow(
+      user_manager::UserManager::Get()->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 user_manager::UserList& logged_users =
-      UserManager::Get()->GetLoggedInUsers();
+      user_manager::UserManager::Get()->GetLoggedInUsers();
   for (user_manager::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 (user_manager::UserManager::Get()->IsLoggedInAsStub()) {
     info->location = current_user_wallpaper_info_.location = "";
     info->layout = current_user_wallpaper_info_.layout =
         ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type =
         user_manager::User::DEFAULT;
     info->date = current_user_wallpaper_info_.date =
         base::Time::Now().LocalMidnight();
     return true;
   }
 
-  return GetUserWallpaperInfo(UserManager::Get()->GetLoggedInUser()->email(),
-                              info);
+  return GetUserWallpaperInfo(
+      user_manager::UserManager::Get()->GetLoggedInUser()->email(), info);
 }
 
 void WallpaperManager::InitializeWallpaper() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  UserManager* user_manager = UserManager::Get();
+  user_manager::UserManager* user_manager = user_manager::UserManager::Get();
 
   // Apply device customization.
   if (ShouldUseCustomizedDefaultWallpaper()) {
     SetDefaultWallpaperPath(
         GetCustomizedWallpaperDefaultRescaledFileName(kSmallWallpaperSuffix),
         scoped_ptr<gfx::ImageSkia>().Pass(),
         GetCustomizedWallpaperDefaultRescaledFileName(kLargeWallpaperSuffix),
         scoped_ptr<gfx::ImageSkia>().Pass());
   }
 
@@ skipping 224 matching lines @@
     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 user_manager::UserImage& user_image) {
   const user_manager::User* user =
-      chromeos::UserManager::Get()->FindUser(user_id);
+      user_manager::UserManager::Get()->FindUser(user_id);
   if (!user) {
     NOTREACHED() << "Unknown user.";
     return;
   }
 
   if (user->username_hash().empty()) {
     cryptohome::AsyncMethodCaller::GetInstance()->AsyncGetSanitizedUsername(
         user_id,
         base::Bind(&WallpaperManager::SetCustomWallpaperOnSanitizedUsername,
                    weak_factory_.GetWeakPtr(),
@@ skipping 32 matching lines @@
     const std::string& user_id,
     const std::string& user_id_hash,
     const std::string& file,
     ash::WallpaperLayout layout,
     user_manager::User::WallpaperType type,
     const gfx::ImageSkia& image,
     bool update_wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // There is no visible background in kiosk mode.
-  if (UserManager::Get()->IsLoggedInAsKioskApp())
+  if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
 
   // Don't allow custom wallpapers while policy is in effect.
   if (type != user_manager::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;
   }
 
-  const user_manager::User *user = UserManager::Get()->FindUser(user_id);
+  const user_manager::User* user =
+      user_manager::UserManager::Get()->FindUser(user_id);
   CHECK(user);
   bool is_persistent =
-      !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id) ||
+      !user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
+          user_id) ||
       (type == user_manager::User::POLICY &&
        user->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT);
 
   WallpaperInfo wallpaper_info = {
       wallpaper_path.value(),
       layout,
       type,
       // Date field is not used.
       base::Time::Now().LocalMidnight()
   };
@@ skipping 38 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 (user_manager::UserManager::Get()->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 (user_manager::UserManager::Get()->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 171 matching lines @@
 }
 
 void WallpaperManager::SetUserWallpaperNow(const std::string& user_id) {
   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())
+  if (!user_manager::UserManager::IsInitialized() ||
+      !g_browser_process->local_state()) {
     return;
+  }
+
   // There is no visible background in kiosk mode.
-  if (UserManager::Get()->IsLoggedInAsKioskApp())
+  if (user_manager::UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   // Guest user, regular user in ephemeral mode, or kiosk app.
-  const user_manager::User* user = UserManager::Get()->FindUser(user_id);
-  if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id) ||
+  const user_manager::User* user =
+      user_manager::UserManager::Get()->FindUser(user_id);
+  if (user_manager::UserManager::Get()->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 (!user_manager::UserManager::Get()->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 33 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(user_manager::UserManager::Get()->IsUserLoggedIn());
 
   // There is no visible background in kiosk mode.
-  if (UserManager::Get()->IsLoggedInAsKioskApp())
+  if (user_manager::UserManager::Get()->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));
-  user_manager::UserList users = UserManager::Get()->GetUsers();
+  user_manager::UserList users = user_manager::UserManager::Get()->GetUsers();
 
   if (!users.empty()) {
     user_manager::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 84 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 (user_manager::UserManager::Get()->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 user_manager::UserList& users = UserManager::Get()->GetUsers();
+  const user_manager::UserList& users =
+      user_manager::UserManager::Get()->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(chromeos::login::kSignInUser);
     return;
   }
 
   if (!disable_boot_animation) {
     int index = public_session_user_index != -1 ? public_session_user_index : 0;
     // Normal boot, load user wallpaper.
@@ skipping 64 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 (user_manager::UserManager::Get()->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 29 matching lines @@
 void WallpaperManager::MoveCustomWallpapersSuccess(
     const std::string& user_id,
     const std::string& user_id_hash) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   if (info.type == user_manager::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.
     info.location = base::FilePath(user_id_hash).Append(info.location).value();
     bool is_persistent =
-        !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id);
+        !user_manager::UserManager::Get()->IsUserNonCryptohomeDataEphemeral(
+            user_id);
     SetUserWallpaperInfo(user_id, info, is_persistent);
   }
 }
 
 void WallpaperManager::MoveLoggedInUserCustomWallpaper() {
   const user_manager::User* logged_in_user =
-      UserManager::Get()->GetLoggedInUser();
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&WallpaperManager::MoveCustomWallpapersOnWorker,
-                 logged_in_user->email(),
-                 logged_in_user->username_hash(),
-                 weak_factory_.GetWeakPtr()));
+      user_manager::UserManager::Get()->GetLoggedInUser();
+  if (logged_in_user) {
+    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,
     ash::WallpaperLayout layout,
     bool update_wallpaper,
     MovableOnDestroyCallbackHolder on_finish,
     const user_manager::UserImage& user_image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_ASYNC_END0("ui", "LoadAndDecodeWallpaper", this);
@@ skipping 358 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 user_manager::UserImage(image));
 }
 
 }  // namespace chromeos