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 108 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 131 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::LARGE) ? ash::kGuestLargeWallpaper :
+        ash::kGuestSmallWallpaper;
+  } else {
+    info = (resolution == ash::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_.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);
         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 115 matching lines @@
     // Only solid color wallpapers have stretch layout and they have only one
     // resolution.
     if (info.layout != ash::STRETCH && resolution == ash::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 99 matching lines @@
   if (wallpaper.image().isNull()) {
     // Updates user pref to default wallpaper.
     WallpaperInfo info = {
                            "",
                            ash::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