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"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
+#include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/wizard_controller.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
@@ skipping 10 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());
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_WALLPAPER_ANIMATION_FINISHED,
+                 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 108 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;
+    }
+    case chrome::NOTIFICATION_WALLPAPER_ANIMATION_FINISHED: {
+      if (should_cache_wallpaper_) {
+        BrowserThread::PostDelayedTask(
+            BrowserThread::UI, FROM_HERE,
+            base::Bind(&WallpaperManager::CacheAllUsersWallpapers,
+                       weak_factory_.GetWeakPtr()),
+            base::TimeDelta::FromMilliseconds(kCacheWallpaperDelayMs));
+        should_cache_wallpaper_ = false;
+      }
+      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 179 matching lines @@
         SetUserWallpaper(email);
       } else if (show_users &&
                  email == last_selected_user_) {
         SetUserWallpaper(email);
       }
     }
   }
   RestartTimer();
 }
 
+void WallpaperManager::CacheAllUsersWallpapers() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  UserList users = UserManager::Get()->GetUsers();
+
+  UserList::const_iterator it = users.begin();
+  // Skip the wallpaper of first user in the list. It should have been cached.
+  it++;
+  for (; it != users.end(); ++it) {
+    std::string user_email = (*it)->email();
+    CacheUserWallpaper(user_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()->
+        CacheDefaultWallpaper(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