Reland "Implement random wallpaper feature"

chrome/browser/chromeos/login/user_manager_impl.cc

 // Copyright (c) 2012 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/user_manager_impl.h"
 
 #include <vector>
 
 #include "ash/shell.h"
 #include "ash/desktop_background/desktop_background_controller.h"
-#include "ash/desktop_background/desktop_background_resources.h"
 #include "base/bind.h"
 #include "base/chromeos/chromeos_version.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
@@ skipping 48 matching lines @@
 // depends on that and it's hard to figure out what).
 const char kGuestUser[] = "";
 
 // Stub user email (for test paths).
 const char kStubUser[] = "stub-user@example.com";
 
 // Names of nodes with info about user image.
 const char kImagePathNodeName[] = "path";
 const char kImageIndexNodeName[] = "index";
 
+const char kWallpaperTypeNodeName[] = "type";
+const char kWallpaperIndexNodeName[] = "index";
+
 // Index of the default image used for the |kStubUser| user.
 const int kStubDefaultImageIndex = 0;
 
 // Delay betweeen user login and attempt to update user's profile image.
 const long kProfileImageDownloadDelayMs = 10000;
 
 // Enum for reporting histograms about profile picture download.
 enum ProfileDownloadResult {
   kDownloadSuccessChanged,
   kDownloadSuccess,
@@ skipping 208 matching lines @@
   // If we're not running on ChromeOS, and are not showing the login manager
   // or attempting a command line login? Then login the stub user.
   CommandLine* command_line = CommandLine::ForCurrentProcess();
   if (!base::chromeos::IsRunningOnChromeOS() &&
       !command_line->HasSwitch(switches::kLoginManager) &&
       !command_line->HasSwitch(switches::kLoginPassword) &&
       !command_line->HasSwitch(switches::kGuestSession)) {
     StubUserLoggedIn();
   }
 
+  MigrateWallpaperData();
+
   registrar_.Add(this, chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
       content::NotificationService::AllSources());
   registrar_.Add(this, chrome::NOTIFICATION_PROFILE_ADDED,
       content::NotificationService::AllSources());
   RetrieveTrustedDevicePolicies();
 }
 
 UserManagerImpl::~UserManagerImpl() {
   // Can't use STLDeleteElements because of the private destructor of User.
   for (size_t i = 0; i < users_.size();++i)
     delete users_[i];
   users_.clear();
   if (is_current_user_ephemeral_)
     delete logged_in_user_;
 }
 
 const UserList& UserManagerImpl::GetUsers() const {
   const_cast<UserManagerImpl*>(this)->EnsureUsersLoaded();
   return users_;
 }
 
 void UserManagerImpl::UserLoggedIn(const std::string& email) {
-  // Get a random wallpaper each time a user logged in.
-  current_user_wallpaper_index_ = ash::GetDefaultWallpaperIndex();
-
   // Remove the stub user if it is still around.
   if (logged_in_user_) {
     DCHECK(IsLoggedInAsStub());
     delete logged_in_user_;
     logged_in_user_ = NULL;
     is_current_user_ephemeral_ = false;
   }
 
   if (email == kGuestUser) {
     GuestUserLoggedIn();
@@ skipping 79 matching lines @@
   is_current_user_new_ = true;
   is_current_user_ephemeral_ = true;
   logged_in_user_ = new User(kDemoUser, false);
   SetInitialUserImage(kDemoUser);
   SetInitialUserWallpaper(kDemoUser);
   NotifyOnLogin();
 }
 
 void UserManagerImpl::GuestUserLoggedIn() {
   is_current_user_ephemeral_ = true;
-  // Guest user always uses the same wallpaper.
-  current_user_wallpaper_index_ = ash::GetGuestWallpaperIndex();
   logged_in_user_ = new User(kGuestUser, true);
   NotifyOnLogin();
 }
 
 void UserManagerImpl::EphemeralUserLoggedIn(const std::string& email) {
   is_current_user_new_ = true;
   is_current_user_ephemeral_ = true;
   logged_in_user_ = CreateUser(email);
   SetInitialUserImage(email);
   SetInitialUserWallpaper(email);
   NotifyOnLogin();
 }
 
 void UserManagerImpl::StubUserLoggedIn() {
   is_current_user_ephemeral_ = true;
-  current_user_wallpaper_index_ = ash::GetGuestWallpaperIndex();
   logged_in_user_ = new User(kStubUser, false);
   logged_in_user_->SetImage(GetDefaultImage(kStubDefaultImageIndex),
                             kStubDefaultImageIndex);
 }
 
 void UserManagerImpl::UserSelected(const std::string& email) {
   if (IsKnownUser(email)) {
+    int index;
+    User::WallpaperType type;
+    GetUserWallpaperProperties(email, type, index);
+    if (type == User::RANDOM) {
+      // Generate a new random wallpaper index if the selected user chose
+      // RANDOM wallpaper.
+      index = ash::GetRandomWallpaperIndex();
+      SaveUserWallpaperProperties(email, User::RANDOM, index);
+    }
     ash::Shell::GetInstance()->desktop_background_controller()->
-        SetDefaultWallpaper(FindUserWallpaperIndex(email));
+        SetDefaultWallpaper(index);
   }
 }
 
 void UserManagerImpl::SessionStarted() {
   session_started_ = true;
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_SESSION_STARTED,
       content::NotificationService::AllSources(),
       content::NotificationService::NoDetails());
 }
@@ skipping 429 matching lines @@
 
 const User* UserManagerImpl::FindUserInList(const std::string& email) const {
   const UserList& users = GetUsers();
   for (UserList::const_iterator it = users.begin(); it != users.end(); ++it) {
     if ((*it)->email() == email)
       return *it;
   }
   return NULL;
 }
 
-int UserManagerImpl::FindUserWallpaperIndex(const std::string& email) {
-  PrefService* local_state = g_browser_process->local_state();
-  const DictionaryValue* user_wallpapers =
-      local_state->GetDictionary(UserManager::kUserWallpapers);
-  int index;
-  if (!user_wallpapers->GetIntegerWithoutPathExpansion(email, &index))
-    index = current_user_wallpaper_index_;
-  if (index < 0 || index >= ash::GetWallpaperCount()) {
-      index = ash::GetDefaultWallpaperIndex();
-      SaveUserWallpaperIndex(index);
-  }
-  return index;
-}
-
 void UserManagerImpl::NotifyOnLogin() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_LOGIN_USER_CHANGED,
       content::Source<UserManagerImpl>(this),
       content::Details<const User>(logged_in_user_));
 
   LoadKeyStore();
 
   // Schedules current user ownership check on file thread.
@@ skipping 29 matching lines @@
   key_store_loaded_ = true;
 }
 
 void UserManagerImpl::SetInitialUserImage(const std::string& username) {
   // Choose a random default image.
   int image_id = base::RandInt(0, kDefaultImagesCount - 1);
   SaveUserDefaultImageIndex(username, image_id);
 }
 
 void UserManagerImpl::SetInitialUserWallpaper(const std::string& username) {
+  current_user_wallpaper_type_ = User::DEFAULT;
   // TODO(bshe): Ideally, wallpaper should start to load as soon as user click
   // "Add user".
   if (username == kGuestUser)
     current_user_wallpaper_index_ = ash::GetGuestWallpaperIndex();
   else
     current_user_wallpaper_index_ = ash::GetDefaultWallpaperIndex();
-  SaveUserWallpaperIndex(current_user_wallpaper_index_);
+
+  SaveUserWallpaperProperties(username,
+                              current_user_wallpaper_type_,
+                              current_user_wallpaper_index_);
+
   // Some browser tests do not have shell instance. And it is not necessary to
   // create a wallpaper for these tests. Add HasInstance check to prevent tests
   // crash and speed up the tests by avoid loading wallpaper.
   if (ash::Shell::HasInstance()) {
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetDefaultWallpaper(current_user_wallpaper_index_);
   }
 }
 
-int UserManagerImpl::GetUserWallpaperIndex() {
+void UserManagerImpl::MigrateWallpaperData() {
+  PrefService* local_state = g_browser_process->local_state();
+  if (local_state) {
+    const DictionaryValue* user_wallpapers =
+          local_state->GetDictionary(kUserWallpapers);
+    int index;
+    if (user_wallpapers) {
+      const UserList& users = GetUsers();
+      for (UserList::const_iterator it = users.begin();
+           it != users.end();
+           ++it) {
+        std::string username = (*it)->email();
+        if (user_wallpapers->GetIntegerWithoutPathExpansion((username),
+            &index)) {
+          DictionaryPrefUpdate prefs_wallpapers_update(local_state,
+                                                       kUserWallpapers);
+          prefs_wallpapers_update->RemoveWithoutPathExpansion(username, NULL);
+          SaveUserWallpaperProperties(username, User::DEFAULT, index);
+        }
+      }
+    }
+  }
+}
+
+int UserManagerImpl::GetLoggedInUserWallpaperIndex() {
+  int index;
+  User::WallpaperType type;
+  GetLoggedInUserWallpaperProperties(type, index);
+  return index;
+}
+
+void UserManagerImpl::GetLoggedInUserWallpaperProperties(
+    User::WallpaperType& type, int& index) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // If at login screen, use an invalid index to prevent any wallpaper
-  // operation.
-  if (!IsUserLoggedIn() || IsLoggedInAsStub())
-    return ash::GetInvalidWallpaperIndex();
+  if (!IsUserLoggedIn() || IsLoggedInAsStub()) {
+    index = ash::GetInvalidWallpaperIndex();
+    current_user_wallpaper_index_ = index;
+    current_user_wallpaper_type_ = User::DEFAULT;
+    return;
+  }
+
   // If logged in as other ephemeral users (Demo/Stub/Normal user with
   // ephemeral policy enabled/Guest), use the index in memory.
-  if (IsCurrentUserEphemeral())
-    return current_user_wallpaper_index_;
+  if (IsCurrentUserEphemeral()) {
+    type = current_user_wallpaper_type_;
+    index = current_user_wallpaper_index_;
+    return;
+  }
 
   const chromeos::User& user = GetLoggedInUser();
   std::string username = user.email();
   DCHECK(!username.empty());
-  return FindUserWallpaperIndex(username);
+
+  GetUserWallpaperProperties(username, type, index);
 }
 
-void UserManagerImpl::SaveUserWallpaperIndex(int wallpaper_index) {
+void UserManagerImpl::SaveLoggedInUserWallpaperProperties(
+    User::WallpaperType type, int index) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  current_user_wallpaper_index_ = wallpaper_index;
+  current_user_wallpaper_type_ = type;
+  current_user_wallpaper_index_ = index;
   // Ephemeral users can not save data to local state. We just cache the index
   // in memory for them.
   if (IsCurrentUserEphemeral() || !IsUserLoggedIn()) {
     return;
   }
 
   const chromeos::User& user = GetLoggedInUser();
   std::string username = user.email();
   DCHECK(!username.empty());
 
-  PrefService* local_state = g_browser_process->local_state();
-  DictionaryPrefUpdate wallpapers_update(local_state,
-                                         UserManager::kUserWallpapers);
-  wallpapers_update->SetWithoutPathExpansion(username,
-      new base::FundamentalValue(wallpaper_index));
+  SaveUserWallpaperProperties(username, type, index);
 }
 
 void UserManagerImpl::SetUserImage(const std::string& username,
                                    int image_index,
                                    const SkBitmap& image) {
   User* user = const_cast<User*>(FindUser(username));
   // User may have been removed by now.
   if (user) {
     // For existing users, a valid image index should have been set upon loading
     // them from Local State.
@@ skipping 12 matching lines @@
       // Unless this is first-time setting with |SetInitialUserImage|,
       // send a notification about image change.
       content::NotificationService::current()->Notify(
           chrome::NOTIFICATION_LOGIN_USER_IMAGE_CHANGED,
           content::Source<UserManagerImpl>(this),
           content::Details<const User>(user));
     }
   }
 }
 
+void UserManagerImpl::GetUserWallpaperProperties(const std::string& username,
+                                                 User::WallpaperType& type,
+                                                 int& index) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  PrefService* local_state = g_browser_process->local_state();
+
+  const DictionaryValue* user_wallpapers =
+      local_state->GetDictionary(UserManager::kUserWallpapersProperties);
+
+  type = User::DEFAULT;
+  index = ash::GetDefaultWallpaperIndex();
+
+  if (user_wallpapers) {
+    base::DictionaryValue* wallpaper_properties;
+    user_wallpapers->GetDictionaryWithoutPathExpansion(username,
+                                                       &wallpaper_properties);
+    if (wallpaper_properties) {
+      int saved_type = User::UNKNOWN;
+      wallpaper_properties->GetInteger(kWallpaperTypeNodeName, &saved_type);
+      type = static_cast<User::WallpaperType>(saved_type);
+      wallpaper_properties->GetInteger(kWallpaperIndexNodeName, &index);
+    }
+  }
+}
+
+void UserManagerImpl::SaveUserWallpaperProperties(const std::string& username,
+                                                  User::WallpaperType type,
+                                                  int index) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  current_user_wallpaper_type_ = type;
+  current_user_wallpaper_index_ = index;
+  // Ephemeral users can not save data to local state. We just cache the index
+  // in memory for them.
+  if (IsCurrentUserEphemeral()) {
+    return;
+  }
+
+  PrefService* local_state = g_browser_process->local_state();
+  DictionaryPrefUpdate wallpaper_update(local_state,
+      UserManager::kUserWallpapersProperties);
+
+  base::DictionaryValue* wallpaper_properties = new base::DictionaryValue();
+  wallpaper_properties->Set(kWallpaperTypeNodeName,
+                            new base::FundamentalValue(type));
+  wallpaper_properties->Set(kWallpaperIndexNodeName,
+                            new base::FundamentalValue(index));
+  wallpaper_update->SetWithoutPathExpansion(username, wallpaper_properties);
+}
+
 void UserManagerImpl::SaveUserImageInternal(const std::string& username,
                                             int image_index,
                                             const SkBitmap& image) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   SetUserImage(username, image_index, image);
 
   // Ignore for ephemeral users.
   if (IsEphemeralUser(username))
     return;
@@ skipping 207 matching lines @@
   for (UserList::iterator it = users_.begin(); it != users_.end(); ++it) {
     std::string user_email = (*it)->email();
     // Skip user that we would like to delete.
     if (email != user_email)
       prefs_users_update->Append(Value::CreateStringValue(user_email));
     else
       user_to_remove = it;
   }
 
   DictionaryPrefUpdate prefs_wallpapers_update(prefs,
-                                               kUserWallpapers);
+                                               kUserWallpapersProperties);
   prefs_wallpapers_update->RemoveWithoutPathExpansion(email, NULL);
 
   DictionaryPrefUpdate prefs_images_update(prefs, kUserImages);
   std::string image_path_string;
   prefs_images_update->GetStringWithoutPathExpansion(email, &image_path_string);
   prefs_images_update->RemoveWithoutPathExpansion(email, NULL);
 
   DictionaryPrefUpdate prefs_oauth_update(prefs, kUserOAuthTokenStatus);
   int oauth_status;
   prefs_oauth_update->GetIntegerWithoutPathExpansion(email, &oauth_status);
@@ skipping 15 matching lines @@
     BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&UserManagerImpl::DeleteUserImage,
                    base::Unretained(this),
                    image_path));
   }
 }
 
 }  // namespace chromeos