[cros] Move User class to user_manager component.

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 15 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.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/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_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 144 matching lines @@
 // Returns true on success.
 bool SaveWallpaperInternal(const base::FilePath& path,
                            const char* data,
                            int size) {
   int written_bytes = base::WriteFile(path, data, size);
   return written_bytes == size;
 }
 
 // Returns index of the first public session user found in |users|
 // or -1 otherwise.
-int FindPublicSession(const chromeos::UserList& users) {
+int FindPublicSession(const user_manager::UserList& users) {
   int index = -1;
   int i = 0;
-  for (UserList::const_iterator it = users.begin();
-       it != users.end(); ++it, ++i) {
+  for (user_manager::UserList::const_iterator it = users.begin();
+       it != users.end();
+       ++it, ++i) {
     if ((*it)->GetType() == user_manager::USER_TYPE_PUBLIC_ACCOUNT) {
       index = i;
       break;
     }
   }
 
   return index;
 }
 
 }  // namespace
@@ skipping 322 matching lines @@
       return;
   }
   SetUserWallpaperNow(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 UserList& logged_users = UserManager::Get()->GetLoggedInUsers();
-  for (UserList::const_iterator it = logged_users.begin();
+  const user_manager::UserList& logged_users =
+      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()) {
     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->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);
 }
 
 void WallpaperManager::InitializeWallpaper() {
@@ skipping 177 matching lines @@
     return SaveWallpaperInternal(
         path, reinterpret_cast<const char*>(data->front()), data->size());
   }
   return false;
 }
 
 bool WallpaperManager::IsPolicyControlled(const std::string& user_id) const {
   chromeos::WallpaperInfo info;
   if (!GetUserWallpaperInfo(user_id, &info))
     return false;
-  return info.type == chromeos::User::POLICY;
+  return info.type == user_manager::User::POLICY;
 }
 
 void WallpaperManager::OnPolicySet(const std::string& policy,
                                    const std::string& user_id) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
-  info.type = User::POLICY;
+  info.type = user_manager::User::POLICY;
   SetUserWallpaperInfo(user_id, info, true /* is_persistent */);
 }
 
 void WallpaperManager::OnPolicyCleared(const std::string& policy,
                                        const std::string& user_id) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
-  info.type = User::DEFAULT;
+  info.type = user_manager::User::DEFAULT;
   SetUserWallpaperInfo(user_id, info, true /* is_persistent */);
   SetDefaultWallpaperNow(user_id);
 }
 
 void WallpaperManager::OnPolicyFetched(const std::string& policy,
                                        const std::string& user_id,
                                        scoped_ptr<std::string> data) {
   if (!data)
     return;
 
@@ skipping 22 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 user_manager::UserImage& user_image) {
-  const User *user = chromeos::UserManager::Get()->FindUser(user_id);
+  const user_manager::User* user =
+      chromeos::UserManager::Get()->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_manager::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) {
+void WallpaperManager::SetCustomWallpaper(
+    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));
   DCHECK(UserManager::Get()->IsUserLoggedIn());
 
   // There is no visible background in kiosk mode.
   if (UserManager::Get()->IsLoggedInAsKioskApp())
     return;
 
   // Don't allow custom wallpapers while policy is in effect.
-  if (type != User::POLICY && IsPolicyControlled(user_id))
+  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;
@@ skipping 98 matching lines @@
   // 1x1 wallpaper is actually solid color, so it should be stretched.
   if (default_wallpaper_image_->image().width() == 1 &&
       default_wallpaper_image_->image().height() == 1)
     layout = ash::WALLPAPER_LAYOUT_STRETCH;
 
   ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
       default_wallpaper_image_->image(), layout);
 }
 
 // static
-void WallpaperManager::RecordUma(User::WallpaperType type, int index) {
+void WallpaperManager::RecordUma(user_manager::User::WallpaperType type,
+                                 int index) {
   UMA_HISTOGRAM_ENUMERATION(
-      "Ash.Wallpaper.Type", type, User::WALLPAPER_TYPE_COUNT);
+      "Ash.Wallpaper.Type", type, user_manager::User::WALLPAPER_TYPE_COUNT);
 }
 
 // static
 void WallpaperManager::SaveCustomWallpaper(const std::string& user_id_hash,
                                            const base::FilePath& original_path,
                                            ash::WallpaperLayout layout,
                                            scoped_ptr<gfx::ImageSkia> image) {
   EnsureCustomWallpaperDirectories(user_id_hash);
   std::string file_name = original_path.BaseName().value();
   base::FilePath small_wallpaper_path =
@@ skipping 97 matching lines @@
                                        update_wallpaper,
                                        valid_path,
                                        base::Passed(on_finish.Pass())));
   }
 }
 
 void WallpaperManager::InitInitialUserWallpaper(const std::string& user_id,
                                                 bool is_persistent) {
   current_user_wallpaper_info_.file = "";
   current_user_wallpaper_info_.layout = ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
-  current_user_wallpaper_info_.type = User::DEFAULT;
+  current_user_wallpaper_info_.type = user_manager::User::DEFAULT;
   current_user_wallpaper_info_.date = base::Time::Now().LocalMidnight();
 
   WallpaperInfo info = current_user_wallpaper_info_;
   SetUserWallpaperInfo(user_id, info, is_persistent);
 }
 
 void WallpaperManager::SetUserWallpaperInfo(const std::string& user_id,
                                             const WallpaperInfo& info,
                                             bool is_persistent) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 25 matching lines @@
 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())
     return;
   // Guest user, regular user in ephemeral mode, or kiosk app.
-  const User* user = UserManager::Get()->FindUser(user_id);
+  const user_manager::User* user = UserManager::Get()->FindUser(user_id);
   if (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))
     return;
 
@@ skipping 12 matching lines @@
     GetPendingWallpaper(user_id, delayed)
         ->ResetSetWallpaperImage(user_wallpaper, info);
   } else {
     if (info.file.empty()) {
       // Uses default built-in wallpaper when file is empty. Eventually, we
       // will only ship one built-in wallpaper in ChromeOS image.
       GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
       return;
     }
 
-    if (info.type == User::CUSTOMIZED || info.type == User::POLICY) {
+    if (info.type == user_manager::User::CUSTOMIZED ||
+        info.type == user_manager::User::POLICY) {
       const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       // Wallpaper is not resized when layout is ash::WALLPAPER_LAYOUT_CENTER.
       // Original wallpaper should be used in this case.
       // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
       if (info.layout == ash::WALLPAPER_LAYOUT_CENTER)
         sub_dir = kOriginalWallpaperSubDir;
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
       wallpaper_path = wallpaper_path.Append(info.file);
       if (current_wallpaper_path_ == wallpaper_path)
         return;
@@ skipping 66 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();
+  user_manager::UserList users = UserManager::Get()->GetUsers();
 
   if (!users.empty()) {
-    UserList::const_iterator it = users.begin();
+    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);
     }
   }
 }
 
 void WallpaperManager::CacheUserWallpaper(const std::string& user_id) {
   if (wallpaper_cache_.find(user_id) != wallpaper_cache_.end())
     return;
   WallpaperInfo info;
   if (GetUserWallpaperInfo(user_id, &info)) {
     if (info.file.empty())
       return;
 
     base::FilePath wallpaper_dir;
     base::FilePath wallpaper_path;
-    if (info.type == User::CUSTOMIZED || info.type == User::POLICY) {
+    if (info.type == user_manager::User::CUSTOMIZED ||
+        info.type == user_manager::User::POLICY) {
       const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
       wallpaper_path = wallpaper_path.Append(info.file);
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                      user_id,
                      info,
                      wallpaper_path,
                      false /* do not update wallpaper */,
@@ skipping 68 matching lines @@
   if (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 chromeos::UserList& users = UserManager::Get()->GetUsers();
+  const user_manager::UserList& users = 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.
     // If normal boot animation is disabled wallpaper would be set
     // asynchronously once user pods are loaded.
     SetUserWallpaperDelayed(users[index]->email());
   }
 }
 
 void WallpaperManager::LoadWallpaper(const std::string& user_id,
                                      const WallpaperInfo& info,
                                      bool update_wallpaper,
                                      MovableOnDestroyCallbackHolder on_finish) {
   base::FilePath wallpaper_dir;
   base::FilePath wallpaper_path;
 
   // Do a sanity check that file path information is not empty.
-  if (info.type == User::ONLINE || info.type == User::DEFAULT) {
+  if (info.type == user_manager::User::ONLINE ||
+      info.type == user_manager::User::DEFAULT) {
     if (info.file.empty()) {
       if (base::SysInfo::IsRunningOnChromeOS()) {
         NOTREACHED() << "User wallpaper info appears to be broken: " << user_id;
       } else {
         // Filename might be empty on debug configurations when stub users
         // were created directly in Local State (for testing). Ignore such
         // errors i.e. allowsuch type of debug configurations on the desktop.
         LOG(WARNING) << "User wallpaper info is empty: " << user_id;
 
         // |on_finish| callback will get called on destruction.
         return;
       }
     }
   }
 
-  if (info.type == User::ONLINE) {
+  if (info.type == user_manager::User::ONLINE) {
     std::string file_name = GURL(info.file).ExtractFileName();
     WallpaperResolution resolution = GetAppropriateResolution();
     // Only solid color wallpapers have stretch layout and they have only one
     // resolution.
     if (info.layout != ash::WALLPAPER_LAYOUT_STRETCH &&
         resolution == WALLPAPER_RESOLUTION_SMALL) {
       file_name = base::FilePath(file_name).InsertBeforeExtension(
           kSmallWallpaperSuffix).value();
     }
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
     wallpaper_path = wallpaper_dir.Append(file_name);
     if (current_wallpaper_path_ == wallpaper_path)
       return;
 
     if (update_wallpaper)
       current_wallpaper_path_ = wallpaper_path;
 
     loaded_wallpapers_++;
     StartLoad(
         user_id, info, update_wallpaper, wallpaper_path, on_finish.Pass());
-  } else if (info.type == User::DEFAULT) {
+  } else if (info.type == user_manager::User::DEFAULT) {
     // Default wallpapers are migrated from M21 user profiles. A code refactor
     // overlooked that case and caused these wallpapers not being loaded at all.
     // On some slow devices, it caused login webui not visible after upgrade to
     // M26 from M21. See crosbug.com/38429 for details.
     base::FilePath user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
     wallpaper_path = user_data_dir.Append(info.file);
     StartLoad(
         user_id, info, update_wallpaper, wallpaper_path, on_finish.Pass());
   } else {
@@ skipping 36 matching lines @@
     return false;
   std::string date_string;
   if (!info_dict->GetString(kNewWallpaperDateNodeName, &date_string))
     return false;
   int64 date_val;
   if (!base::StringToInt64(date_string, &date_val))
     return false;
 
   info->file = file;
   info->layout = static_cast<ash::WallpaperLayout>(layout);
-  info->type = static_cast<User::WallpaperType>(type);
+  info->type = static_cast<user_manager::User::WallpaperType>(type);
   info->date = base::Time::FromInternalValue(date_val);
   return true;
 }
 
 void WallpaperManager::MoveCustomWallpapersSuccess(
     const std::string& user_id,
     const std::string& user_id_hash) {
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
-  if (info.type == User::CUSTOMIZED) {
+  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.
     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);
     SetUserWallpaperInfo(user_id, info, is_persistent);
   }
 }
 
 void WallpaperManager::MoveLoggedInUserCustomWallpaper() {
-  const User* logged_in_user = UserManager::Get()->GetLoggedInUser();
+  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()));
 }
 
 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);
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
   // Use default wallpaper in this case.
   if (user_image.image().isNull()) {
     // Updates user pref to default wallpaper.
-    WallpaperInfo info = {
-                           "",
-                           ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
-                           User::DEFAULT,
-                           base::Time::Now().LocalMidnight()
-                         };
+    WallpaperInfo info = {"", ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
+                          user_manager::User::DEFAULT,
+                          base::Time::Now().LocalMidnight()};
     SetUserWallpaperInfo(user_id, info, true);
 
     if (update_wallpaper)
       DoSetDefaultWallpaper(user_id, on_finish.Pass());
     return;
   }
 
   wallpaper_cache_[user_id] = user_image.image();
 
   if (update_wallpaper) {
@@ skipping 340 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