Remove use of index in wallpaper picker code and some refactor

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"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
@@ skipping 28 matching lines @@
 
 // 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";
 
 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)
-const int kDefaultOOBEWallpaperIndex = 1; // IDR_AURA_WALLPAPERS_2_LANDSCAPE8
-#else
-const int kDefaultOOBEWallpaperIndex = 0;  // IDR_AURA_WALLPAPERS_5_GRADIENT5
-#endif
-
 // A dictionary pref that maps usernames to wallpaper properties.
 const char kUserWallpapersProperties[] = "UserWallpapersProperties";
 
 // Names of nodes with info about wallpaper in |kUserWallpapersProperties|
 // dictionary.
 const char kNewWallpaperDateNodeName[] = "date";
 const char kNewWallpaperLayoutNodeName[] = "layout";
 const char kNewWallpaperFileNodeName[] = "file";
 const char kNewWallpaperTypeNodeName[] = "type";
 
@@ skipping 28 matching lines @@
 
 // static
 WallpaperManager* WallpaperManager::Get() {
   if (!g_wallpaper_manager)
     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))),
       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,
@@ skipping 76 matching lines @@
     return (*it).second;
   else
     return gfx::ImageSkia();
 }
 
 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->layout = current_user_wallpaper_info_.layout =
+        ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type = User::DEFAULT;
     return true;
   }
 
   return GetUserWallpaperInfo(UserManager::Get()->GetLoggedInUser()->email(),
                               info);
 }
 
 void WallpaperManager::InitializeWallpaper() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 11 matching lines @@
   }
 
   bool disable_new_oobe = CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kDisableNewOobe);
   bool disable_boot_animation = CommandLine::ForCurrentProcess()->
       HasSwitch(switches::kDisableBootAnimation);
 
   if (!user_manager->IsUserLoggedIn()) {
     if (!disable_new_oobe) {
       if (!WizardController::IsDeviceRegistered()) {
-        SetDefaultWallpaper(kDefaultOOBEWallpaperIndex);
+        SetDefaultWallpaper();
       } else {
         bool show_users = true;
         bool result = CrosSettings::Get()->GetBoolean(
             kAccountsPrefShowUserNamesOnSignIn, &show_users);
         DCHECK(result) << "Unable to fetch setting "
                        << kAccountsPrefShowUserNamesOnSignIn;
         const chromeos::UserList& users = user_manager->GetUsers();
         if (!show_users || users.empty()) {
           // Boot into sign in form, preload default wallpaper.
-          SetDefaultWallpaper(kDefaultOOBEWallpaperIndex);
+          SetDefaultWallpaper();
           return;
         }
 
         if (!disable_boot_animation) {
           // Normal boot, load user wallpaper.
           // If normal boot animation is disabled wallpaper would be set
           // asynchronously once user pods are loaded.
           SetUserWallpaper(users[0]->email());
         }
       }
@@ skipping 54 matching lines @@
                                               const FilePath& path,
                                               ash::WallpaperLayout layout,
                                               int preferred_width,
                                               int preferred_height) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   int width = wallpaper.image().width();
   int height = wallpaper.image().height();
   int resized_width;
   int resized_height;
 
-  if (layout == ash::CENTER_CROPPED) {
+  if (layout == ash::WALLPAPER_LAYOUT_CENTER_CROPPED) {
     // Do not resize custom wallpaper if it is smaller than preferred size.
     if (!(width > preferred_width && height > preferred_height))
       return;
 
     double horizontal_ratio = static_cast<double>(preferred_width) / width;
     double vertical_ratio = static_cast<double>(preferred_height) / height;
     if (vertical_ratio > horizontal_ratio) {
       resized_width =
           RoundPositive(static_cast<double>(width) * vertical_ratio);
       resized_height = preferred_height;
     } else {
       resized_width = preferred_width;
       resized_height =
           RoundPositive(static_cast<double>(height) * horizontal_ratio);
     }
-  } else if (layout == ash::STRETCH) {
+  } else if (layout == ash::WALLPAPER_LAYOUT_STRETCH) {
     resized_width = preferred_width;
     resized_height = preferred_height;
   } else {
     // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
     if (file_util::PathExists(path))
       file_util::Delete(path, false);
     return;
   }
 
   gfx::ImageSkia resized_image = gfx::ImageSkiaOperations::CreateResizedImage(
@@ skipping 40 matching lines @@
     User::WallpaperType type,
     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());
+    SetDefaultWallpaper();
     return;
   }
 
   bool is_persistent = ShouldPersistDataForUser(username);
 
   wallpaper.image().EnsureRepsForSupportedScaleFactors();
   scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper.image().DeepCopy());
 
   WallpaperInfo wallpaper_info = {
       wallpaper_path,
@@ skipping 21 matching lines @@
   // DUMMY as file name here.
   WallpaperInfo info = {
       "DUMMY",
       layout,
       User::CUSTOMIZED,
       base::Time::Now().LocalMidnight()
   };
   SetUserWallpaperInfo(username, info, is_persistent);
 }
 
-void WallpaperManager::SetDefaultWallpaper(int index) {
+void WallpaperManager::SetDefaultWallpaper() {
+  ash::DesktopBackgroundController* controller =
+      ash::Shell::GetInstance()->desktop_background_controller();
+  ash::WallpaperResolution resolution = controller->GetAppropriateResolution();
+  ash::WallpaperInfo info;
+  if (UserManager::Get()->IsLoggedInAsGuest()) {
+    info = (resolution == ash::WALLPAPER_RESOLUTION_LARGE) ?
+        ash::kGuestLargeWallpaper : ash::kGuestSmallWallpaper;
+  } else {
+    info = (resolution == ash::WALLPAPER_RESOLUTION_LARGE) ?
+        ash::kDefaultLargeWallpaper : ash::kDefaultSmallWallpaper;
+  }
+
   // Prevents loading of the same wallpaper as the currently loading/loaded one.
-  if (current_default_wallpaper_index_ == index)
+  if (controller->GetWallpaperIDR() == info.idr)
     return;
-  current_default_wallpaper_index_ = index;
+
   current_wallpaper_path_ = FilePath("");
   loaded_wallpapers_++;
-  ash::Shell::GetInstance()->desktop_background_controller()->
-      SetDefaultWallpaper(index);
+  controller->SetDefaultWallpaper(info);
 }
 
 void WallpaperManager::SetInitialUserWallpaper(const std::string& username,
                                                bool is_persistent) {
   current_user_wallpaper_info_.file = "";
-  current_user_wallpaper_info_.layout = ash::CENTER_CROPPED;
+  current_user_wallpaper_info_.layout = ash::WALLPAPER_LAYOUT_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()) {
-    if (username == kGuestUser)
-      SetDefaultWallpaper(ash::GetGuestWallpaperIndex());
-    else
-      SetDefaultWallpaper(ash::GetDefaultWallpaperIndex());
-  }
+  if (ash::Shell::HasInstance())
+    SetDefaultWallpaper();
 }
 
 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 11 matching lines @@
 }
 
 void WallpaperManager::SetLastSelectedUser(
     const std::string& last_selected_user) {
   last_selected_user_ = last_selected_user;
 }
 
 void WallpaperManager::SetUserWallpaper(const std::string& email) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (email == kGuestUser) {
-    SetDefaultWallpaper(ash::GetGuestWallpaperIndex());
+    SetDefaultWallpaper();
     return;
   }
 
   if (!UserManager::Get()->IsKnownUser(email))
     return;
 
   SetLastSelectedUser(email);
 
   WallpaperInfo info;
 
   if (GetUserWallpaperInfo(email, &info)) {
     gfx::ImageSkia user_wallpaper;
     if (GetWallpaperFromCache(email, &user_wallpaper)) {
       ash::Shell::GetInstance()->desktop_background_controller()->
           SetCustomWallpaper(user_wallpaper, info.layout);
     } else {
       if (info.type == User::CUSTOMIZED) {
         ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
             desktop_background_controller()->GetAppropriateResolution();
-        bool is_small  = (resolution == ash::SMALL);
+        bool is_small  = (resolution == ash::WALLPAPER_RESOLUTION_SMALL);
         FilePath wallpaper_path = GetWallpaperPathForUser(email, is_small);
         if (current_wallpaper_path_ == wallpaper_path)
           return;
         current_wallpaper_path_ = wallpaper_path;
-        current_default_wallpaper_index_ = ash::GetInvalidWallpaperIndex();
         loaded_wallpapers_++;
 
         BrowserThread::PostTask(
             BrowserThread::FILE, FROM_HERE,
             base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                        base::Unretained(this), email, info, wallpaper_path,
                        true /* update wallpaper */));
         return;
       }
 
       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.
-        SetDefaultWallpaper(ash::GetDefaultWallpaperIndex());
+        SetDefaultWallpaper();
         return;
       }
 
       // Load downloaded ONLINE or converted DEFAULT wallpapers.
       LoadWallpaper(email, info, true /* update wallpaper */);
     }
   } else {
     SetInitialUserWallpaper(email, true);
   }
 }
 
-void WallpaperManager::SetSigninWallpaper() {
-  SetDefaultWallpaper(kDefaultOOBEWallpaperIndex);
-}
-
 void WallpaperManager::SetWallpaperFromImageSkia(
     const gfx::ImageSkia& wallpaper,
     ash::WallpaperLayout layout) {
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetCustomWallpaper(wallpaper, layout);
 }
 
 void WallpaperManager::UpdateWallpaper() {
   ClearWallpaperCache();
   SetUserWallpaper(last_selected_user_);
@@ skipping 30 matching lines @@
 void WallpaperManager::CacheUserWallpaper(const std::string& email) {
   if (wallpaper_cache_.find(email) == wallpaper_cache_.end())
     return;
   WallpaperInfo info;
   if (GetUserWallpaperInfo(email, &info)) {
     FilePath wallpaper_dir;
     FilePath wallpaper_path;
     if (info.type == User::CUSTOMIZED) {
       ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
           desktop_background_controller()->GetAppropriateResolution();
-      bool is_small  = (resolution == ash::SMALL);
+      bool is_small  = (resolution == ash::WALLPAPER_RESOLUTION_SMALL);
       FilePath wallpaper_path = GetWallpaperPathForUser(email, is_small);
       BrowserThread::PostTask(
           BrowserThread::FILE, FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                      base::Unretained(this), email, info, wallpaper_path,
                      false /* do not update wallpaper */));
       return;
     }
     LoadWallpaper(email, info, false /* do not update wallpaper */);
   }
@@ skipping 56 matching lines @@
                                      const WallpaperInfo& info,
                                      bool update_wallpaper) {
   FilePath wallpaper_dir;
   FilePath wallpaper_path;
   if (info.type == User::ONLINE) {
     std::string file_name = GURL(info.file).ExtractFileName();
     ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
         desktop_background_controller()->GetAppropriateResolution();
     // Only solid color wallpapers have stretch layout and they have only one
     // resolution.
-    if (info.layout != ash::STRETCH && resolution == ash::SMALL) {
+    if (info.layout != ash::WALLPAPER_LAYOUT_STRETCH &&
+        resolution == ash::WALLPAPER_RESOLUTION_SMALL) {
       file_name = 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) {
+    if (update_wallpaper)
       current_wallpaper_path_ = wallpaper_path;
-      current_default_wallpaper_index_ = ash::GetInvalidWallpaperIndex();
-    }
     loaded_wallpapers_++;
     StartLoad(email, info, update_wallpaper, wallpaper_path);
   } else {
     // For custom wallpapers, we have increment |loaded_wallpapers_| in
     // SetUserWallpaper(). We should not increment it again here.
     FilePath user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
     wallpaper_path = user_data_dir.Append(info.file);
     base::WorkerPool::PostTask(
         FROM_HERE,
@@ skipping 19 matching lines @@
     // wallpaper info from memory. Returns true.
     return true;
   }
 
   const DictionaryValue* user_wallpapers = g_browser_process->local_state()->
       GetDictionary(prefs::kUsersWallpaperInfo);
   const base::DictionaryValue* wallpaper_info_dict;
   if (user_wallpapers->GetDictionaryWithoutPathExpansion(
           email, &wallpaper_info_dict)) {
     info->file = "";
-    info->layout = ash::CENTER_CROPPED;
+    info->layout = ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = User::UNKNOWN;
     info->date = base::Time::Now().LocalMidnight();
     wallpaper_info_dict->GetString(kNewWallpaperFileNodeName, &(info->file));
     int temp;
     wallpaper_info_dict->GetInteger(kNewWallpaperLayoutNodeName, &temp);
     info->layout = static_cast<ash::WallpaperLayout>(temp);
     wallpaper_info_dict->GetInteger(kNewWallpaperTypeNodeName, &temp);
     info->type = static_cast<User::WallpaperType>(temp);
     std::string date_string;
     int64 val;
@@ skipping 53 matching lines @@
                                           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.
     WallpaperInfo info = {
                            "",
-                           ash::CENTER_CROPPED,
+                           ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
                            User::DEFAULT,
                            base::Time::Now().LocalMidnight()
                          };
     SetUserWallpaperInfo(email, info, true);
 
-    if (update_wallpaper) {
-      SetDefaultWallpaper(ash::GetDefaultWallpaperIndex());
-    } else {
-      ash::Shell::GetInstance()->desktop_background_controller()->
-          CacheDefaultWallpaper(ash::GetDefaultWallpaperIndex());
-    }
+    if (update_wallpaper)
+      SetDefaultWallpaper();
     return;
   }
   // Generate all reps before passing to another thread.
   wallpaper.image().EnsureRepsForSupportedScaleFactors();
   scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper.image().DeepCopy());
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&WallpaperManager::CacheThumbnail,
@@ skipping 50 matching lines @@
                          ash::kSmallWallpaperMaxWidth,
                          ash::kSmallWallpaperMaxHeight);
   ResizeAndSaveWallpaper(wallpaper, large_wallpaper_path, layout,
                          ash::kLargeWallpaperMaxWidth,
                          ash::kLargeWallpaperMaxHeight);
 }
 
 void WallpaperManager::RecordUma(User::WallpaperType type, int index) {
   UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Type", type,
                             User::WALLPAPER_TYPE_COUNT);
-  if (type == User::DEFAULT) {
-    if (index >= 0) {
-      // TODO(sschmitz): Remove "if" when the index for new UI is available.
-      UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.DefaultIndex", index,
-                                ash::GetWallpaperCount());
-    }
-  }
 }
 
 void WallpaperManager::SaveWallpaperInternal(const FilePath& path,
                                              const char* data,
                                              int size) {
   int written_bytes = file_util::WriteFile(path, data, size);
   DCHECK(written_bytes == size);
 }
 
 bool WallpaperManager::ShouldPersistDataForUser(const std::string& email) {
@@ skipping 40 matching lines @@
                           FROM_HERE,
                           base::Bind(&WallpaperManager::StartLoad,
                                      base::Unretained(this),
                                      email,
                                      info,
                                      update_wallpaper,
                                      valid_path));
 }
 
 }  // chromeos