Speed up custom wallpaper switching time and wallpaper manager code 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 "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/path_service.h"
+#include "base/string_number_conversions.h"
+#include "base/string_util.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros_settings.h"
 #include "chrome/browser/chromeos/login/user.h"
 #include "chrome/browser/chromeos/login/user_manager.h"
 #include "chrome/browser/chromeos/login/user_manager_impl.h"
+#include "chrome/browser/chromeos/login/wizard_controller.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 "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_service.h"
+#include "skia/ext/image_operations.h"
+#include "third_party/zlib/zlib.h"
+#include "ui/gfx/codec/png_codec.h"
+#include "ui/gfx/skia_util.h"
+
+using content::BrowserThread;
 
 namespace {
+
 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;
+
+// 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
+
 }  // namespace
 
 namespace chromeos {
 
 static WallpaperManager* g_wallpaper_manager = NULL;
 
 // WallpaperManager, public: ---------------------------------------------------
 
 // static
 WallpaperManager* WallpaperManager::Get() {
   if (!g_wallpaper_manager)
     g_wallpaper_manager = new WallpaperManager();
   return g_wallpaper_manager;
 }
 
-WallpaperManager::WallpaperManager() : last_selected_user_("") {
+WallpaperManager::WallpaperManager()
+    : ALLOW_THIS_IN_INITIALIZER_LIST(wallpaper_loader_(new WallpaperLoader)),
+      current_user_wallpaper_type_(User::UNKNOWN),
+      ALLOW_THIS_IN_INITIALIZER_LIST(current_user_wallpaper_index_(
+          ash::GetInvalidWallpaperIndex())),
+      last_selected_user_(""),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   system::TimezoneSettings::GetInstance()->AddObserver(this);
   RestartTimer();
+  registrar_.Add(this,
+                 chrome::NOTIFICATION_LOGIN_USER_CHANGED,
+                 content::NotificationService::AllSources());
 }
 
 void WallpaperManager::AddPowerManagerClientObserver() {
   if (!DBusThreadManager::Get()->GetPowerManagerClient()->HasObserver(this))
     DBusThreadManager::Get()->GetPowerManagerClient()->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) {
+    // Uses WeakPtr here to make the request cancelable.
+    LoadCustomWallpaperFromFile(email,
+                                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());
+  }
+}
+
+void WallpaperManager::FetchCustomWallpaper(const std::string& email) {
+  User::WallpaperType type;
+  int index;
+  base::Time date;
+  GetUserWallpaperProperties(email, &type, &index, &date);
+  ash::WallpaperLayout layout = static_cast<ash::WallpaperLayout>(index);
+  LoadCustomWallpaperFromFile(email,
+                              base::Bind(&WallpaperManager::FetchWallpaper,
+                                         base::Unretained(this),
+                                         email, layout));
+}
+
+bool WallpaperManager::GetCustomWallpaperFromCache(const std::string& email,
+                                                   SkBitmap* wallpaper) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  CustomWallpaperMap::const_iterator it = custom_wallpaper_cache_.find(email);
+  if (it != custom_wallpaper_cache_.end()) {
+    *wallpaper = (*it).second;
+    return true;
+  }
+  return false;
+}
+
+FilePath WallpaperManager::GetWallpaperPathForUser(const std::string& username,
+                                                   bool is_thumbnail) {
+  std::string filename = username +
+      (is_thumbnail ? "_wallpaper_thumb.png" : "_wallpaper.png");
+  FilePath user_data_dir;
+  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
+  return user_data_dir.AppendASCII(filename);
+}
+
+SkBitmap WallpaperManager::GetCustomWallpaperThumbnail(
+    const std::string& email) {
+  CustomWallpaperMap::const_iterator it =
+      custom_wallpaper_thumbnail_cache_.find(email);
+  if (it != custom_wallpaper_cache_.end())
+    return (*it).second;
+  else
+    return SkBitmap();
+}
+
+void WallpaperManager::GetLoggedInUserWallpaperProperties(
+    User::WallpaperType* type,

[Ivan Korotkov, 2012/07/31 21:18:16]

It looks like there're many functions taking these 3 arguments --
type/index/date. Please consider combining them in a separate struct/class in
future CLs.

[bshe, 2012/08/01 15:07:35]

Will do.

On 2012/07/31 21:18:16, Ivan Korotkov wrote:

+    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);
+}
+
+void WallpaperManager::InitializeWallpaper() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  UserManager* user_manager = UserManager::Get();
+  if (!user_manager->IsUserLoggedIn()) {
+    if (!CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kDisableNewOobe)) {
+      if (!WizardController::IsDeviceRegistered() &&
+          !WizardController::IsZeroDelayEnabled()) {
+        // TODO(nkostylev): Add switch to disable wallpaper transition on OOBE.
+        // Should be used on test images so that they are not slowed down.
+        ash::Shell::GetInstance()->desktop_background_controller()->
+            SetDefaultWallpaper(kDefaultOOBEWallpaperIndex);
+      } else {
+        bool show_users = true;
+        bool result = CrosSettings::Get()->GetBoolean(
+            kAccountsPrefShowUserNamesOnSignIn, &show_users);
+        DCHECK(result) << "Unable to fetch setting "
+                       << kAccountsPrefShowUserNamesOnSignIn;
+        if (!show_users) {
+          ash::Shell::GetInstance()->desktop_background_controller()->
+              SetDefaultWallpaper(ash::GetSolidColorIndex());
+        }
+      }
+    }
+    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();
+  }
+}
+
 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();
   } else {
     // 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::SaveUserWallpaperProperties(const std::string& email,
+                                                   User::WallpaperType type,
+                                                   int index) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  current_user_wallpaper_type_ = type;
+  current_user_wallpaper_index_ = index;
+  // Ephemeral users can not save data to local state. We just cache the index
+  // in memory for them.
+  if (UserManager::Get()->IsCurrentUserEphemeral()) {
+    return;
+  }
+
+  PrefService* local_state = g_browser_process->local_state();
+  DictionaryPrefUpdate wallpaper_update(local_state,
+      UserManager::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::SetUserWallpaperFromFile(
+    const std::string& username,
+    const FilePath& path,
+    ash::WallpaperLayout layout,
+    base::WeakPtr<WallpaperDelegate> delegate) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // TODO(bshe): Refactor GetWallpaperPathForUser to this class.
+  std::string wallpaper_path =
+      GetWallpaperPathForUser(username, false).value();
+  // need to expose ephemeral user.
+  bool save_raw_file = true;
+
+  // For wallpapers, save the image without resizing.
+  wallpaper_loader_->Start(
+      path.value(), save_raw_file, wallpaper_path,
+      base::Bind(&WallpaperManager::SetCallback,
+                 base::Unretained(this), username, layout, User::CUSTOMIZED,
+                 delegate));
+}
+
+void WallpaperManager::SetInitialUserWallpaper(const std::string& username) {
+  current_user_wallpaper_type_ = User::DEFAULT;
+  // TODO(bshe): Ideally, wallpaper should start to load as soon as user click
+  // "Add user".
+  if (username == kGuestUser)
+    current_user_wallpaper_index_ = ash::GetGuestWallpaperIndex();
+  else
+    current_user_wallpaper_index_ = ash::GetDefaultWallpaperIndex();
+  SaveUserWallpaperProperties(username,
+                              current_user_wallpaper_type_,
+                              current_user_wallpaper_index_);
+
+  // 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()) {
+    ash::Shell::GetInstance()->desktop_background_controller()->
+        SetDefaultWallpaper(current_user_wallpaper_index_);
+  }
+}
+
 void WallpaperManager::SetLastSelectedUser(
     const std::string& last_selected_user) {
   last_selected_user_ = last_selected_user;
 }
 
-void WallpaperManager::SetWallpaperFromFile(std::string email,
-                                            const std::string& path,
-                                            ash::WallpaperLayout layout) {
-  image_loader_->Start(
-      path, 0, false,
-      base::Bind(&WallpaperManager::OnCustomWallpaperLoaded,
-                 base::Unretained(this), email, layout));
+void WallpaperManager::SetUserWallpaper(const std::string& email) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  if (UserManager::Get()->IsKnownUser(email)) {
+    User::WallpaperType type;
+    int index;
+    base::Time date;
+    GetUserWallpaperProperties(email, &type, &index, &date);
+    if (type == User::DAILY && date != base::Time::Now().LocalMidnight()) {
+      index = ash::GetNextWallpaperIndex(index);
+      SaveUserWallpaperProperties(email, User::DAILY, index);
+    } else if (type == User::CUSTOMIZED) {
+      SkBitmap custom_wallpaper;
+      if (GetCustomWallpaperFromCache(email, &custom_wallpaper)) {
+        // In customized mode, we use index pref to save the user selected
+        // wallpaper layout. See function SaveWallpaperToLocalState().
+        ash::WallpaperLayout layout = static_cast<ash::WallpaperLayout>(index);
+        ash::Shell::GetInstance()->desktop_background_controller()->
+            SetCustomWallpaper(custom_wallpaper, layout);
+      } else {
+        FetchCustomWallpaper(email);
+      }
+      return;
+    }
+    ash::Shell::GetInstance()->desktop_background_controller()->
+        SetDefaultWallpaper(index);
+    SetLastSelectedUser(email);
+  }
 }
 
-void WallpaperManager::UserDeselected() {
+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);
+}
+
 // WallpaperManager, private: --------------------------------------------------
 
 WallpaperManager::~WallpaperManager() {
   DBusThreadManager::Get()->GetPowerManagerClient()->RemoveObserver(this);
   system::TimezoneSettings::GetInstance()->RemoveObserver(this);
 }
 
 void WallpaperManager::OnCustomWallpaperLoaded(const std::string& email,
                                                ash::WallpaperLayout layout,
                                                const UserImage& user_image) {
   const SkBitmap& wallpaper = user_image.image();
   ash::Shell::GetInstance()->desktop_background_controller()->
       SetCustomWallpaper(wallpaper, layout);
 }
 
 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();
-      // TODO(bshe): Move GetUserWallpaperProperties() to this class.
-      static_cast<UserManagerImpl*>(user_manager)->
-          GetUserWallpaperProperties(email, &type, &index,
-                                     &last_modification_date);
+      GetUserWallpaperProperties(email, &type, &index, &last_modification_date);
       base::Time current_date = base::Time::Now().LocalMidnight();
       if (type == User::DAILY && current_date != last_modification_date) {
         index = ash::GetNextWallpaperIndex(index);
-        // TODO(bshe): Move SaveUserWallpaperProperties() to this class.
-        static_cast<UserManagerImpl*>(user_manager)->
-            SaveUserWallpaperProperties(email, type, index);
+        SaveUserWallpaperProperties(email, type, index);
       }
       // 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()) {
-        user_manager->UserSelected(email);
+        SetUserWallpaper(email);
       } else if (show_users &&
                  email == last_selected_user_) {
-        user_manager->UserSelected(email);
+        SetUserWallpaper(email);
       }
     }
   }
   RestartTimer();
 }
 
+void WallpaperManager::CacheWallpaper(const std::string& email,
+                                      const SkBitmap& 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));
+
+  custom_wallpaper_cache_.insert(std::make_pair(email, wallpaper));
+}
+
+void WallpaperManager::CacheThumbnail(const std::string& email,
+                                      const SkBitmap& wallpaper) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  SkBitmap thumbnail =
+      skia::ImageOperations::Resize(wallpaper,
+                                    skia::ImageOperations::RESIZE_LANCZOS3,
+                                    kThumbnailWidth, kThumbnailHeight);
+  custom_wallpaper_thumbnail_cache_[email] = thumbnail;
+}
+
+void WallpaperManager::FetchWallpaper(const std::string& email,
+                                      ash::WallpaperLayout layout,
+                                      const SkBitmap& wallpaper) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&WallpaperManager::CacheThumbnail,
+                 base::Unretained(this), email, wallpaper));
+
+  ash::Shell::GetInstance()->desktop_background_controller()->
+      SetCustomWallpaper(wallpaper, layout);
+}
+
+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(UserManager::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);
+    }
+  }
+}
+
+void WallpaperManager::GenerateUserWallpaperThumbnail(
+    const std::string& email,
+    User::WallpaperType type,
+    base::WeakPtr<WallpaperDelegate> delegate,
+    const SkBitmap& wallpaper) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  SkBitmap thumbnail =
+      skia::ImageOperations::Resize(wallpaper,
+                                    skia::ImageOperations::RESIZE_LANCZOS3,
+                                    kThumbnailWidth, kThumbnailHeight);
+
+  custom_wallpaper_thumbnail_cache_[email] = thumbnail;
+
+  // Notify thumbnail is ready.
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&WallpaperManager::OnThumbnailUpdated,
+                 base::Unretained(this), delegate));
+}
+
+void WallpaperManager::LoadCustomWallpaperFromFile(const std::string& email,
+    const LoadedCallback& loaded_cb) {
+  // TODO(bshe): Refactor GetWallpaperPathForUser to this class.
+  std::string wallpaper_path =
+      GetWallpaperPathForUser(email, false).value();
+  // Load user wallpaper asynchronously.
+  wallpaper_loader_->Start(wallpaper_path, false, std::string(), loaded_cb);
+}
+
+void WallpaperManager::OnThumbnailUpdated(
+    base::WeakPtr<WallpaperDelegate> delegate) {
+  if (delegate)
+    delegate->SetCustomWallpaperThumbnail();
+}
+
+void WallpaperManager::SetCallback(const std::string& username,
+                                   ash::WallpaperLayout layout,
+                                   User::WallpaperType type,
+                                   base::WeakPtr<WallpaperDelegate> delegate,
+                                   const SkBitmap& wallpaper) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  BrowserThread::PostTask(
+      BrowserThread::FILE,
+      FROM_HERE,
+      base::Bind(&WallpaperManager::GenerateUserWallpaperThumbnail,
+                 base::Unretained(this), username, type, delegate, wallpaper));
+
+  ash::Shell::GetInstance()->desktop_background_controller()->
+      SetCustomWallpaper(wallpaper, layout);
+
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&WallpaperManager::SaveUserWallpaperProperties,
+                 base::Unretained(this),
+                 username, type, layout));
+}
+
 void WallpaperManager::SystemResumed() {
   BatchUpdateWallpaper();
 }
 
 void WallpaperManager::TimezoneChanged(const icu::TimeZone& timezone) {
   RestartTimer();
 }
 
 }  // chromeos