Save user selected wallpaper information to local state.

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/logging.h"
+#include "base/string_number_conversions.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/prefs/pref_service.h"
+#include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/power_manager_client.h"
+#include "content/public/browser/browser_thread.h"
+
+using content::BrowserThread;
 
 namespace {
+
 const int kWallpaperUpdateIntervalSec = 24 * 60 * 60;
+
+// A dictionary that maps usernames to wallpaper properties.
+const char kUsersWallpaperInfo[] = "UsersWallpaperInfo";

[battre, 2012/07/30 15:00:56]

this one should go to pref_names.h and follow the linux_hacker_style_notation
found there. Please check whether this needs to be a top-level element or
whether this can be grouped with something already listed there.

[bshe, 2012/07/30 18:05:05]

Done. It is wallpaper specific and I can't find any other prefs that is related
to wallpaper in pref_name.h file. So I make it a top-level element.

+
+// Names of nodes with info about wallpaper.
+const char kWallpaperDateNodeName[] = "date";
+const char kWallpaperLayoutNodeName[] = "layout";
+const char kWallpaperFileNodeName[] = "file";
+const char kWallpaperTypeNodeName[] = "type";
+
 }  // 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;
 }
 
+// static
+void WallpaperManager::RegisterPrefs(PrefService* local_state) {
+  local_state->RegisterDictionaryPref(kUsersWallpaperInfo,
+                                      PrefService::UNSYNCABLE_PREF);

[battre, 2012/07/30 15:00:56]

- will there be only one user wallpaper?
- does it make sense to register a default here so you don't have to deal with
empty dictionaries? Maybe containing just a white image?

[bshe, 2012/07/30 18:05:05]

Each user will have a record in the kUsersWallpaperInfo dictionary and there is
only one such dictionary in Local State.
The structure of the dictionary is something like this:
"UserWallpapersProperties": {
      "username@gmail.com": {
         "date": "12987748800000000",
         "layout": 1,
         "file": "wallpaper.jpg",
         "type": 1
      }
}
Every item in the dictionary is associated with an email(username). When a user
first boot up a chrome book, since there is no valid user yet, I am not sure if
I should create a default username/email to register this pref. Once a user
login, a default wallpaper record associated with that user will be saved in the
dictionary.

+}
+
 WallpaperManager::WallpaperManager() : last_selected_user_("") {
   system::TimezoneSettings::GetInstance()->AddObserver(this);
   RestartTimer();
 }
 
 void WallpaperManager::AddPowerManagerClientObserver() {
   if (!DBusThreadManager::Get()->GetPowerManagerClient()->HasObserver(this))
     DBusThreadManager::Get()->GetPowerManagerClient()->AddObserver(this);
 }
 
 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::SaveUserWallpaperInfo(const std::string& username,
+                                             const std::string& file_name,
+                                             ash::WallpaperLayout layout,
+                                             User::WallpaperType type) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // 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,
+                                        kUsersWallpaperInfo);
+
+  base::DictionaryValue* wallpaper_properties = new base::DictionaryValue();
+  wallpaper_properties->SetString(kWallpaperDateNodeName,
+      base::Int64ToString(base::Time::Now().LocalMidnight().ToInternalValue()));
+  wallpaper_properties->SetString(kWallpaperFileNodeName,
+                            file_name);

[battre, 2012/07/30 15:00:56]

nit: indentation

[bshe, 2012/07/30 18:05:05]

Done.

+  wallpaper_properties->Set(kWallpaperLayoutNodeName,
+                            new base::FundamentalValue(layout));

[battre, 2012/07/30 15:00:56]

The more idiomatic way would be
wallpaper_properties->SetInteger(kWallpaperLayoutNodeName,
                                 layout);
(same below)

[bshe, 2012/07/30 18:05:05]

Done.

+  wallpaper_properties->Set(kWallpaperTypeNodeName,
+                            new base::FundamentalValue(type));
+  wallpaper_update->SetWithoutPathExpansion(username, wallpaper_properties);
+}
+
 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) {
+void WallpaperManager::SetWallpaperFromFilePath(const std::string& path,
+                                                ash::WallpaperLayout layout) {
   image_loader_->Start(
       path, 0, false,
-      base::Bind(&WallpaperManager::OnCustomWallpaperLoaded,
-                 base::Unretained(this), email, layout));
+      base::Bind(&WallpaperManager::OnWallpaperLoaded,
+                 base::Unretained(this), layout));
+}
+
+void WallpaperManager::SetWallpaperFromImageSkia(
+    const gfx::ImageSkia& wallpaper,
+    ash::WallpaperLayout layout) {
+  ash::Shell::GetInstance()->desktop_background_controller()->
+      SetCustomWallpaper(wallpaper, layout);
 }
 
 void WallpaperManager::UserDeselected() {
   if (!UserManager::Get()->IsUserLoggedIn()) {
     // This will set default login wallpaper (#fefefe).
     ash::Shell::GetInstance()->desktop_background_controller()->
         SetDefaultWallpaper(ash::GetSolidColorIndex());
   }
 }
 
@@ skipping 45 matching lines @@
         user_manager->UserSelected(email);
       } else if (show_users &&
                  email == last_selected_user_) {
         user_manager->UserSelected(email);
       }
     }
   }
   RestartTimer();
 }
 
+void WallpaperManager::OnWallpaperLoaded(ash::WallpaperLayout layout,
+                                         const UserImage& user_image) {
+  const SkBitmap& wallpaper = user_image.image();
+  SetWallpaperFromImageSkia(wallpaper, layout);
+}
+
 void WallpaperManager::SystemResumed() {
   BatchUpdateWallpaper();
 }
 
 void WallpaperManager::TimezoneChanged(const icu::TimeZone& timezone) {
   RestartTimer();
 }
 
 }  // chromeos