Preload default wallpaper.

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 "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 29 matching lines @@
 
 const int kWallpaperUpdateIntervalSec = 24 * 60 * 60;
 
 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)
 const int kDefaultOOBEWallpaperIndex = 16; // IDR_AURA_WALLPAPERS_3_URBAN0
 #else
 const int kDefaultOOBEWallpaperIndex = 0;  // IDR_AURA_WALLPAPERS_ROMAINGUY_0
 #endif
 
@@ skipping 16 matching lines @@
   if (!g_wallpaper_manager)
     g_wallpaper_manager = new WallpaperManager();
   return g_wallpaper_manager;
 }
 
 WallpaperManager::WallpaperManager()
     : ALLOW_THIS_IN_INITIALIZER_LIST(wallpaper_loader_(new UserImageLoader)),
       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());
 }
 
 // static
 void WallpaperManager::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterDictionaryPref(prefs::kUsersWallpaperInfo,
                                       PrefService::UNSYNCABLE_PREF);
 }
 
 void WallpaperManager::AddObservers() {
   if (!DBusThreadManager::Get()->GetPowerManagerClient()->HasObserver(this))
     DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
   system::TimezoneSettings::GetInstance()->AddObserver(this);
 }
 
-void WallpaperManager::CacheIfCustomWallpaper(const std::string& email) {
-  User::WallpaperType type;
-  int index;
-  base::Time date;
-  GetUserWallpaperProperties(email, &type, &index, &date);
-  if (type == User::CUSTOMIZED) {
-    std::string wallpaper_path = GetWallpaperPathForUser(email, false).value();
-
-    // Uses WeakPtr here to make the request cancelable.
-    wallpaper_loader_->Start(wallpaper_path, 0,
-                             base::Bind(&WallpaperManager::CacheWallpaper,
-                                        weak_factory_.GetWeakPtr(), email));
-  }
-}
-
 void WallpaperManager::EnsureLoggedInUserWallpaperLoaded() {
   User::WallpaperType type;
   int index;
   base::Time last_modification_date;
   GetLoggedInUserWallpaperProperties(&type, &index, &last_modification_date);
 
   if (type != current_user_wallpaper_type_ ||
       index != current_user_wallpaper_index_) {
     SetUserWallpaper(UserManager::Get()->GetLoggedInUser().email());
   }
@@ skipping 91 matching lines @@
     }
     return;
   }
   SetUserWallpaper(user_manager->GetLoggedInUser().email());
 }
 
 void WallpaperManager::Observe(int type,
                                const content::NotificationSource& source,
                                const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (type == chrome::NOTIFICATION_LOGIN_USER_CHANGED) {
-    // Cancel callback for previous cache requests.
-    weak_factory_.InvalidateWeakPtrs();
-    custom_wallpaper_cache_.clear();
+  switch (type) {
+    case chrome::NOTIFICATION_LOGIN_USER_CHANGED: {
+      // Cancel callback for previous cache requests.
+      weak_factory_.InvalidateWeakPtrs();
+      custom_wallpaper_cache_.clear();
+      break;
+    }
+    case chrome::NOTIFICATION_LOGIN_WEBUI_VISIBLE: {
+      if (!CommandLine::ForCurrentProcess()->
+          HasSwitch(switches::kDisableBootAnimation)) {
+        BrowserThread::PostDelayedTask(
+            BrowserThread::UI, FROM_HERE,
+            base::Bind(&WallpaperManager::CacheAllUsersWallpapers,
+                       weak_factory_.GetWeakPtr()),
+            base::TimeDelta::FromMilliseconds(kCacheWallpaperDelayMs));
+      } else {
+        should_cache_wallpaper_ = true;
+      }
+      break;
+    }
+    default:
+      NOTREACHED() << "Unexpected notification " << type;
   }
 }
 
 void WallpaperManager::RestartTimer() {
   timer_.Stop();
   base::Time midnight = base::Time::Now().LocalMidnight();
   base::TimeDelta interval = base::Time::Now() - midnight;
   int64 remaining_seconds = kWallpaperUpdateIntervalSec - interval.InSeconds();
   if (remaining_seconds <= 0) {
     BatchUpdateWallpaper();
@@ skipping 135 matching lines @@
 void WallpaperManager::OnUserDeselected() {
   if (!UserManager::Get()->IsUserLoggedIn()) {
     // This will set default login wallpaper (#fefefe).
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetDefaultWallpaper(ash::GetSolidColorIndex());
   }
 }
 
 void WallpaperManager::OnUserSelected(const std::string& email) {
   SetUserWallpaper(email);
+  if (should_cache_wallpaper_) {
+    BrowserThread::PostDelayedTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&WallpaperManager::CacheAllUsersWallpapers,

[Nikita (slow), 2012/08/06 16:36:01]

We should no cache all users wallpapers when single user is selected.
Precaching should be single time operation.

[bshe, 2012/08/07 15:18:57]

It should be a single time operation. The only time |should_cache_wallpaper_| is
true is when we receive a NOTIFICATION_LOGIN_WEBUI_VISIBLE notification and
DisableBootAnimation is false. The LOGIN_WEBUI_VISIBLE should only fired once on
each login.

On 2012/08/06 16:36:01, Nikita Kostylev wrote:

+                   weak_factory_.GetWeakPtr()),
+        base::TimeDelta::FromMilliseconds(kCacheWallpaperDelayMs));
+    should_cache_wallpaper_ = false;
+  }
 }
 
 // WallpaperManager, private: --------------------------------------------------
 
 WallpaperManager::~WallpaperManager() {
   DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
   system::TimezoneSettings::GetInstance()->RemoveObserver(this);
 }
 
 void WallpaperManager::BatchUpdateWallpaper() {
@@ skipping 24 matching lines @@
         SetUserWallpaper(email);
       } else if (show_users &&
                  email == last_selected_user_) {
         SetUserWallpaper(email);
       }
     }
   }
   RestartTimer();
 }
 
+void CacheAllUsersWallpapers() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (!users_.empty())
+    return;
+  if (!g_browser_process)
+    return;
+
+  PrefService* local_state = g_browser_process->local_state();

[Nikita (slow), 2012/08/06 16:36:01]

Use user_manager->GetUsers() instead.

[bshe, 2012/08/07 15:18:57]

Done.

+
+  const ListValue* prefs_users =
+      local_state->GetList(UserManager::kLoggedInUsers);
+
+  if (prefs_users) {
+    ListValue::const_iterator it = prefs_users->begin();
+    it++;
+    for (; it != prefs_users->end(); ++it) {
+      CacheUserWallpaper(email);
+    }
+  }
+}
+
+void WallpaperManager::CacheUserWallpaper(const std::string& email) {
+  User::WallpaperType type;
+  int index;
+  base::Time date;
+  GetUserWallpaperProperties(email, &type, &index, &date);
+  if (type == User::CUSTOMIZED) {
+    std::string wallpaper_path = GetWallpaperPathForUser(email, false).value();
+
+    // Uses WeakPtr here to make the request cancelable.
+    wallpaper_loader_->Start(wallpaper_path, 0,
+                             base::Bind(&WallpaperManager::CacheWallpaper,
+                                        weak_factory_.GetWeakPtr(), email));
+  } else {
+    ash::Shell::GetInstance()->desktop_background_controller()->
+        TriggerCacheDefaultWallpaper(index);
+  }
+}
+
 void WallpaperManager::CacheWallpaper(const std::string& email,
                                       const UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(custom_wallpaper_cache_.find(email) == custom_wallpaper_cache_.end());
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&WallpaperManager::CacheThumbnail,
                  base::Unretained(this), email, wallpaper.image()));
@@ skipping 15 matching lines @@
                                       ash::WallpaperLayout layout,
                                       const UserImage& wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
       base::Bind(&WallpaperManager::CacheThumbnail,
                  base::Unretained(this), email, wallpaper.image()));
 
+  custom_wallpaper_cache_.insert(std::make_pair(email, wallpaper.image()));
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetCustomWallpaper(wallpaper.image(), layout);
 }
 
 void WallpaperManager::GetUserWallpaperProperties(const std::string& email,
     User::WallpaperType* type,
     int* index,
     base::Time* last_modification_date) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
@@ skipping 99 matching lines @@
 
 void WallpaperManager::SystemResumed() {
   BatchUpdateWallpaper();
 }
 
 void WallpaperManager::TimezoneChanged(const icu::TimeZone& timezone) {
   RestartTimer();
 }
 
 }  // chromeos