Remove the old wallpaper picker code

chrome/browser/chromeos/login/wallpaper_manager.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/wallpaper_manager.h"
 
 #include <vector>
 
 #include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/desktop_background/desktop_background_resources.h"
@@ skipping 33 matching lines @@
 using content::BrowserThread;
 
 namespace {
 
 const int kWallpaperUpdateIntervalSec = 24 * 60 * 60;
 
 // A dictionary pref that maps usernames to file paths to their wallpapers.
 // Deprecated. Will remove this const char after done migration.
 const char kUserWallpapers[] = "UserWallpapers";
 
-// Names of nodes with info about wallpaper in |kUserWallpapers| dictionary.
-const char kWallpaperTypeNodeName[] = "type";
-const char kWallpaperIndexNodeName[] = "index";
-const char kWallpaperDateNodeName[] = "date";
-
 const int kThumbnailWidth = 128;
 const int kThumbnailHeight = 80;
 
 const int kCacheWallpaperDelayMs = 500;
 
 // Default wallpaper index used in OOBE (first boot).
 // Defined here because Chromium default index differs.
 // Also see ash::WallpaperInfo kDefaultWallpapers in
 // desktop_background_resources.cc
 #if defined(GOOGLE_CHROME_BUILD)
@@ skipping 47 matching lines @@
     g_wallpaper_manager = new WallpaperManager();
   return g_wallpaper_manager;
 }
 
 WallpaperManager::WallpaperManager()
     : loaded_wallpapers_(0),
       ALLOW_THIS_IN_INITIALIZER_LIST(current_default_wallpaper_index_(
           ash::GetInvalidWallpaperIndex())),
       ALLOW_THIS_IN_INITIALIZER_LIST(wallpaper_loader_(
           new UserImageLoader(ImageDecoder::ROBUST_JPEG_CODEC))),
-      current_user_wallpaper_type_(User::UNKNOWN),
-      ALLOW_THIS_IN_INITIALIZER_LIST(current_user_wallpaper_index_(
-          ash::GetInvalidWallpaperIndex())),
       should_cache_wallpaper_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   RestartTimer();
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_USER_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_WEBUI_VISIBLE,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
@@ skipping 69 matching lines @@
 gfx::ImageSkia WallpaperManager::GetCustomWallpaperThumbnail(
     const std::string& email) {
   CustomWallpaperMap::const_iterator it =
       custom_wallpaper_thumbnail_cache_.find(email);
   if (it != custom_wallpaper_thumbnail_cache_.end())
     return (*it).second;
   else
     return gfx::ImageSkia();
 }
 
-void WallpaperManager::GetLoggedInUserWallpaperProperties(
-    User::WallpaperType* type,
-    int* index,
-    base::Time* last_modification_date) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  if (UserManager::Get()->IsLoggedInAsStub()) {
-    *type = current_user_wallpaper_type_ = User::DEFAULT;
-    *index = current_user_wallpaper_index_ = ash::GetInvalidWallpaperIndex();
-    return;
-  }
-
-  GetUserWallpaperProperties(UserManager::Get()->GetLoggedInUser()->email(),
-                             type, index, last_modification_date);
-}
-
 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::CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type = User::DEFAULT;
     return true;
   }
 
@@ skipping 84 matching lines @@
       }
       break;
     }
     default:
       NOTREACHED() << "Unexpected notification " << type;
   }
 }
 
 void WallpaperManager::RemoveUserWallpaperInfo(const std::string& email) {
   PrefService* prefs = g_browser_process->local_state();
-  DictionaryPrefUpdate prefs_wallpapers_update(prefs,
-      kUserWallpapersProperties);
-  prefs_wallpapers_update->RemoveWithoutPathExpansion(email, NULL);
-
   DictionaryPrefUpdate prefs_wallpapers_info_update(prefs,
       prefs::kUsersWallpaperInfo);
   prefs_wallpapers_info_update->RemoveWithoutPathExpansion(email, NULL);
 
   DeleteUserWallpapers(email);
 }
 
 void WallpaperManager::ResizeAndSaveWallpaper(const UserImage& wallpaper,
                                               const FilePath& path,
                                               ash::WallpaperLayout layout,
@@ skipping 66 matching lines @@
   // Set up a one shot timer which will batch update wallpaper at midnight.
   timer_.Start(FROM_HERE,
                base::TimeDelta::FromSeconds(remaining_seconds),
                this,
                &WallpaperManager::BatchUpdateWallpaper);
 }
 
 void WallpaperManager::SetCustomWallpaper(const std::string& username,
     ash::WallpaperLayout layout,
     User::WallpaperType type,
-    base::WeakPtr<WallpaperDelegate> delegate,
     const UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   std::string wallpaper_path =
       GetOriginalWallpaperPathForUser(username).value();
 
   // If decoded wallpaper is empty, we are probably failed to decode the file.
   // Use default wallpaper in this case.
   if (wallpaper.image().isNull()) {
     SetDefaultWallpaper(ash::GetDefaultWallpaperIndex());
@@ skipping 14 matching lines @@
   };
   // TODO(bshe): This may break if RawImage becomes RefCountedMemory.
   BrowserThread::PostTask(
         BrowserThread::FILE,
         FROM_HERE,
         base::Bind(&WallpaperManager::ProcessCustomWallpaper,
                    base::Unretained(this),
                    username,
                    is_persistent,
                    wallpaper_info,
-                   delegate,
                    base::Passed(&deep_copy),
                    wallpaper.raw_image()));
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetCustomWallpaper(wallpaper.image(), layout);
 
   // User's custom wallpaper path is determined by username/email and the
   // appropriate wallpaper resolution in GetCustomWallpaperInternal. So use
   // DUMMY as file name here.
   WallpaperInfo info = {
       "DUMMY",
       layout,
       User::CUSTOMIZED,
       base::Time::Now().LocalMidnight()
   };
   SetUserWallpaperInfo(username, info, is_persistent);
-
-  SetUserWallpaperProperties(username, type, layout, is_persistent);
-}
-
-void WallpaperManager::SetUserWallpaperFromFile(
-    const std::string& username,
-    const FilePath& path,
-    ash::WallpaperLayout layout,
-    base::WeakPtr<WallpaperDelegate> delegate) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // For wallpapers, save the image without resizing.
-  wallpaper_loader_->Start(
-      path.value(), 0,
-      base::Bind(&WallpaperManager::SetCustomWallpaper,
-                 base::Unretained(this), username, layout, User::CUSTOMIZED,
-                 delegate));
-}
-
-void WallpaperManager::SetUserWallpaperProperties(const std::string& email,
-                                                  User::WallpaperType type,
-                                                  int index,
-                                                  bool is_persistent) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  current_user_wallpaper_type_ = type;
-  current_user_wallpaper_index_ = index;
-  if (!is_persistent)
-    return;
-
-  PrefService* local_state = g_browser_process->local_state();
-  DictionaryPrefUpdate wallpaper_update(local_state, 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_properties->SetString(kWallpaperDateNodeName,
-      base::Int64ToString(base::Time::Now().LocalMidnight().ToInternalValue()));
-  wallpaper_update->SetWithoutPathExpansion(email, wallpaper_properties);
 }
 
 void WallpaperManager::SetDefaultWallpaper(int index) {
   // Prevents loading of the same wallpaper as the currently loading/loaded one.
   if (current_default_wallpaper_index_ == index)
     return;
   current_default_wallpaper_index_ = index;
   current_wallpaper_path_ = FilePath("");
   loaded_wallpapers_++;
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetDefaultWallpaper(index);
 }
 
 void WallpaperManager::SetInitialUserWallpaper(const std::string& username,
                                                bool is_persistent) {
-  current_user_wallpaper_type_ = User::DEFAULT;
-  if (username == kGuestUser)
-    current_user_wallpaper_index_ = ash::GetGuestWallpaperIndex();
-  else
-    current_user_wallpaper_index_ = ash::GetDefaultWallpaperIndex();
-
   current_user_wallpaper_info_.file = "";
   current_user_wallpaper_info_.layout = ash::CENTER_CROPPED;
   current_user_wallpaper_info_.type = User::DEFAULT;
   current_user_wallpaper_info_.date = base::Time::Now().LocalMidnight();
 
   WallpaperInfo info = current_user_wallpaper_info_;
   SetUserWallpaperInfo(username, info, is_persistent);
 
   // 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())
-    SetDefaultWallpaper(current_user_wallpaper_index_);
+  if (ash::Shell::HasInstance()) {
+    if (username == kGuestUser)
+      SetDefaultWallpaper(ash::GetGuestWallpaperIndex());
+    else
+      SetDefaultWallpaper(ash::GetDefaultWallpaperIndex());
+  }
 }
 
 void WallpaperManager::SetUserWallpaperInfo(const std::string& username,
                                             const WallpaperInfo& info,
                                             bool is_persistent) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   current_user_wallpaper_info_ = info;
   if (!is_persistent)
     return;
 
@@ skipping 81 matching lines @@
 }
 
 void WallpaperManager::UpdateWallpaper() {
   ClearWallpaperCache();
   SetUserWallpaper(last_selected_user_);
 }
 
 // WallpaperManager, private: --------------------------------------------------
 
 WallpaperManager::~WallpaperManager() {
+  ClearObsoleteWallpaperPrefs();
   DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
   system::TimezoneSettings::GetInstance()->RemoveObserver(this);
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void WallpaperManager::BatchUpdateWallpaper() {
-  PrefService* local_state = g_browser_process->local_state();
-  UserManager* user_manager = UserManager::Get();
-  bool show_users = true;
-  CrosSettings::Get()->GetBoolean(
-      kAccountsPrefShowUserNamesOnSignIn, &show_users);
-  if (local_state) {
-    User::WallpaperType type;
-    int index = 0;
-    base::Time last_modification_date;
-    const UserList& users = user_manager->GetUsers();
-    for (UserList::const_iterator it = users.begin();
-         it != users.end(); ++it) {
-      std::string email = (*it)->email();
-      GetUserWallpaperProperties(email, &type, &index, &last_modification_date);
-      base::Time current_date = base::Time::Now().LocalMidnight();
-      if (type == User::DAILY && current_date != last_modification_date) {
-        SetUserWallpaperProperties(email, type, index, true);
-      }
-      // Force a wallpaper update for logged in / last selected user.
-      // TODO(bshe): Notify lock screen, wallpaper picker UI to update wallpaper
-      // as well.
-      if (user_manager->IsUserLoggedIn() &&
-          email == user_manager->GetLoggedInUser()->email()) {
-        SetUserWallpaper(email);
-      } else if (show_users &&
-                 email == last_selected_user_) {
-        SetUserWallpaper(email);
-      }
-    }
-  }
-  RestartTimer();
+  NOTIMPLEMENTED();
 }
 
 void WallpaperManager::CacheAllUsersWallpapers() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UserList users = UserManager::Get()->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++;
@@ skipping 27 matching lines @@
   }
 }
 
 void WallpaperManager::CacheThumbnail(const std::string& email,
                                       scoped_ptr<gfx::ImageSkia> wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   custom_wallpaper_thumbnail_cache_[email] =
       GetWallpaperThumbnail(*wallpaper.get());
 }
 
+void WallpaperManager::ClearObsoleteWallpaperPrefs() {
+  PrefService* prefs = g_browser_process->local_state();
+  DictionaryPrefUpdate wallpaper_properties_pref(prefs,
+      kUserWallpapersProperties);
+  wallpaper_properties_pref->Clear();
+  DictionaryPrefUpdate wallpapers_pref(prefs, kUserWallpapers);
+  wallpapers_pref->Clear();
+}
+
 void WallpaperManager::DeleteWallpaperInList(
     const std::vector<FilePath>& file_list) {
   for (std::vector<FilePath>::const_iterator it = file_list.begin();
        it != file_list.end(); ++it) {
     FilePath path = *it;
     if (!file_util::Delete(path, false)) {
       LOG(ERROR) << "Failed to remove user wallpaper.";
     }
 
     // Some users may still have wallpapers with a file extension. This will
@@ skipping 101 matching lines @@
                                          &date_string) &&
           base::StringToInt64(date_string, &val)))
       val = 0;
     info->date = base::Time::FromInternalValue(val);
     return true;
   }
 
   return false;
 }
 
-void WallpaperManager::GetUserWallpaperProperties(const std::string& email,
-    User::WallpaperType* type,
-    int* index,
-    base::Time* last_modification_date) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // Default to the values cached in memory.
-  *type = current_user_wallpaper_type_;
-  *index = current_user_wallpaper_index_;
-
-  // Override with values found in local store, if any.
-  if (!email.empty()) {
-    const DictionaryValue* user_wallpapers = g_browser_process->local_state()->
-        GetDictionary(kUserWallpapersProperties);
-    const base::DictionaryValue* wallpaper_properties;
-    if (user_wallpapers->GetDictionaryWithoutPathExpansion(
-        email,
-        &wallpaper_properties)) {
-      *type = User::UNKNOWN;
-      *index = ash::GetInvalidWallpaperIndex();
-      wallpaper_properties->GetInteger(kWallpaperTypeNodeName,
-                                       reinterpret_cast<int*>(type));
-      wallpaper_properties->GetInteger(kWallpaperIndexNodeName, index);
-      std::string date_string;
-      int64 val;
-      if (!(wallpaper_properties->GetString(kWallpaperDateNodeName,
-                                            &date_string) &&
-            base::StringToInt64(date_string, &val)))
-        val = 0;
-      *last_modification_date = base::Time::FromInternalValue(val);
-    }
-  }
-
-  // Index maybe invalid when update from official build to unofficial build.
-  // Revert to default in that case.
-  if (*type == User::DEFAULT &&
-      (*index < 0 || *index >= ash::GetWallpaperCount())) {
-    *index = ash::GetDefaultWallpaperIndex();
-  }
-}
-
 void WallpaperManager::GenerateUserWallpaperThumbnail(
     const std::string& email,
     User::WallpaperType type,
-    base::WeakPtr<WallpaperDelegate> delegate,
     const gfx::ImageSkia& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   custom_wallpaper_thumbnail_cache_[email] = GetWallpaperThumbnail(wallpaper);
-
-  // Notify thumbnail is ready.
-  BrowserThread::PostTask(
-      BrowserThread::UI,
-      FROM_HERE,
-      base::Bind(&WallpaperManager::OnThumbnailUpdated,
-                 base::Unretained(this), delegate));
 }
 
 void WallpaperManager::GetCustomWallpaperInternal(
     const std::string& email,
     const WallpaperInfo& info,
     const FilePath& wallpaper_path,
     bool update_wallpaper) {
   std::string file_name = wallpaper_path.BaseName().value();
 
   if (!file_util::PathExists(wallpaper_path)) {
@@ skipping 14 matching lines @@
       info.type,
       info.date
   };
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&WallpaperManager::LoadWallpaper,
                  base::Unretained(this), email, new_info, update_wallpaper));
 }
 
-void WallpaperManager::MigrateWallpaperData(const UserList& users) {
-  PrefService* local_state = g_browser_process->local_state();
-  if (local_state) {
-    const DictionaryValue* user_wallpapers =
-          local_state->GetDictionary(kUserWallpapers);
-    int index;
-    const DictionaryValue* new_user_wallpapers =
-        local_state->GetDictionary(kUserWallpapersProperties);
-    if (new_user_wallpapers->empty()) {
-      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);
-          SetUserWallpaperProperties(username, User::DEFAULT, index, true);
-        } else {
-          // Before M20, wallpaper index is not saved into LocalState unless
-          // user specifically sets a wallpaper. After M20, the default
-          // wallpaper index is saved to LocalState as soon as a new user login.
-          // When migrating wallpaper index from M20 to M21, we only migrate
-          // data that is in LocalState. This cause a problem when users login
-          // on a M20 device and then update the device to M21. The default
-          // wallpaper index failed to migrate because it was not saved into
-          // LocalState. Then we assume that all users have index saved in
-          // LocalState in M21. This is not true and it results an empty
-          // wallpaper for those users as described in cr/130685. So here we use
-          // default wallpaper for users that exist in user list but does not
-          // have an index saved in LocalState.
-          SetUserWallpaperProperties(
-              username, User::DEFAULT, ash::GetDefaultWallpaperIndex(), true);
-        }
-      }
-    }
-  }
-}
-
-void WallpaperManager::MigrateBuiltInWallpaper(const std::string& email) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!email.empty() && UserManager::Get()->IsKnownUser(email)) {
-    PrefService* prefs = g_browser_process->local_state();
-    const DictionaryValue* user_wallpapers = prefs->
-        GetDictionary(kUserWallpapersProperties);
-    const base::DictionaryValue* wallpaper_properties;
-    User::WallpaperType type;
-    int index;
-    ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
-        desktop_background_controller()->GetAppropriateResolution();
-    if (user_wallpapers->GetDictionaryWithoutPathExpansion(email,
-            &wallpaper_properties)) {
-      base::Time date;
-      GetUserWallpaperProperties(email, &type, &index, &date);
-
-      FilePath wallpaper_dir;
-      CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
-      DCHECK(type != User::UNKNOWN);
-
-      FilePath wallpaper_path;
-      if (type != User::CUSTOMIZED) {
-        base::RefCountedStaticMemory* wallpaper =
-            ui::ResourceBundle::GetSharedInstance().LoadDataResourceBytes(
-                GetWallpaperViewInfo(index, ash::LARGE).id);
-
-        // Saves large wallpaper to user custom wallpaper path.
-        wallpaper_path = GetWallpaperPathForUser(email, false);
-        BrowserThread::PostTask(
-            BrowserThread::FILE,
-            FROM_HERE,
-            base::Bind(&WallpaperManager::SaveWallpaperInternal,
-                   base::Unretained(this), wallpaper_path,
-                   reinterpret_cast<const char*>(wallpaper->front()),
-                   wallpaper->size()));
-
-        wallpaper =
-            ui::ResourceBundle::GetSharedInstance().LoadDataResourceBytes(
-                GetWallpaperViewInfo(index, ash::SMALL).id);
-
-        // Saves small wallpaper to user custom wallpaper thumbnail path.
-        wallpaper_path = GetWallpaperPathForUser(email, true);
-        BrowserThread::PostTask(
-            BrowserThread::FILE,
-            FROM_HERE,
-            base::Bind(&WallpaperManager::SaveWallpaperInternal,
-                   base::Unretained(this), wallpaper_path,
-                   reinterpret_cast<const char*>(wallpaper->front()),
-                   wallpaper->size()));
-      }
-
-      bool small_resolution = (resolution == ash::SMALL);
-      std::string file_name =
-          GetWallpaperPathForUser(email, small_resolution).BaseName().value();
-      WallpaperInfo info = {
-                               file_name,
-                               GetWallpaperViewInfo(index, resolution).layout,
-                               type,
-                               base::Time::Now().LocalMidnight()
-                           };
-      SetUserWallpaperInfo(email, info, true);
-    }
-  }
-}
-
-void WallpaperManager::OnThumbnailUpdated(
-    base::WeakPtr<WallpaperDelegate> delegate) {
-  if (delegate)
-    delegate->SetCustomWallpaperThumbnail();
-}
-
 void WallpaperManager::OnWallpaperDecoded(const std::string& email,
                                           ash::WallpaperLayout layout,
                                           bool update_wallpaper,
                                           const UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If decoded wallpaper is empty, we are probably failed to decode the file.
   // Use default wallpaper in this case.
   if (wallpaper.image().isNull()) {
     // Updates user pref to default wallpaper.
@@ skipping 30 matching lines @@
   if (update_wallpaper) {
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetCustomWallpaper(wallpaper.image(), layout);
   }
 }
 
 void WallpaperManager::ProcessCustomWallpaper(
     const std::string& email,
     bool persistent,
     const WallpaperInfo& info,
-    base::WeakPtr<WallpaperDelegate> delegate,
     scoped_ptr<gfx::ImageSkia> image,
     const UserImage::RawImage& raw_image) {
   UserImage wallpaper(*image.get(), raw_image);
-  GenerateUserWallpaperThumbnail(email, info.type, delegate, wallpaper.image());
+  GenerateUserWallpaperThumbnail(email, info.type, wallpaper.image());
   if (persistent)
     SaveCustomWallpaper(email, FilePath(info.file), info.layout, wallpaper);
 }
 
 void WallpaperManager::OnWallpaperEncoded(const FilePath& path,
     scoped_refptr<base::RefCountedBytes> data) {
   SaveWallpaperInternal(path,
                         reinterpret_cast<const char*>(data->front()),
                         data->size());
 }
@@ skipping 87 matching lines @@
                           FROM_HERE,
                           base::Bind(&WallpaperManager::StartLoad,
                                      base::Unretained(this),
                                      email,
                                      info,
                                      update_wallpaper,
                                      valid_path));
 }
 
 }  // chromeos