Some cleanup of WallpaperManager.

chrome/browser/chromeos/login/wallpaper_manager.cc

 // Copyright (c) 2013 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 <numeric>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 13 matching lines @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/login/startup_utils.h"
 #include "chrome/browser/chromeos/login/user.h"
+#include "chrome/browser/chromeos/login/user_image.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/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
@@ skipping 24 matching lines @@
 // 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";
 
-// File path suffix of the original custom wallpaper.
-const char kOriginalCustomWallpaperSuffix[] = "_wallpaper";
-
 // Maximum number of wallpapers cached by CacheUsersWallpapers().
 const int kMaxWallpapersToCache = 3;
 
 // Maximum number of entries in WallpaperManager::last_load_times_ .
 const size_t kLastLoadsStatsMsMaxSize = 4;
 
 // Minimum delay between wallpaper loads, milliseconds.
 const unsigned kLoadMinDelayMs = 50;
 
 // Default wallpaper load delay, milliseconds.
@@ skipping 319 matching lines @@
 }
 
 base::FilePath WallpaperManager::GetCustomWallpaperPath(
     const char* sub_dir,
     const std::string& user_id_hash,
     const std::string& file) const {
   base::FilePath custom_wallpaper_path = GetCustomWallpaperDir(sub_dir);
   return custom_wallpaper_path.Append(user_id_hash).Append(file);
 }
 
-base::FilePath WallpaperManager::GetOriginalWallpaperPathForUser(
-    const std::string& user_id) {
-  std::string filename = user_id + kOriginalCustomWallpaperSuffix;
-  base::FilePath user_data_dir;
-  PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  return user_data_dir.AppendASCII(filename);
-}
-
 bool WallpaperManager::GetLoggedInUserWallpaperInfo(WallpaperInfo* info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (UserManager::Get()->IsLoggedInAsStub()) {
     info->file = current_user_wallpaper_info_.file = "";
     info->layout = current_user_wallpaper_info_.layout =
         ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
     info->type = current_user_wallpaper_info_.type = User::DEFAULT;
+    info->date = current_user_wallpaper_info_.date =
+        base::Time::Now().LocalMidnight();
     return true;
   }
 
   return GetUserWallpaperInfo(UserManager::Get()->GetLoggedInUser()->email(),
                               info);
 }
 
 void WallpaperManager::InitializeWallpaper() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UserManager* user_manager = UserManager::Get();
@@ skipping 75 matching lines @@
   WallpaperInfo info;
   GetUserWallpaperInfo(user_id, &info);
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate prefs_wallpapers_info_update(prefs,
       prefs::kUsersWallpaperInfo);
   prefs_wallpapers_info_update->RemoveWithoutPathExpansion(user_id, NULL);
   DeleteUserWallpapers(user_id, info.file);
 }
 
 bool WallpaperManager::ResizeWallpaper(
-    const UserImage& wallpaper,
+    const gfx::ImageSkia& wallpaper,
     ash::WallpaperLayout layout,
     int preferred_width,
     int preferred_height,
     scoped_refptr<base::RefCountedBytes>* output,
     gfx::ImageSkia* output_skia) const {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
-  int width = wallpaper.image().width();
-  int height = wallpaper.image().height();
+  int width = wallpaper.width();
+  int height = wallpaper.height();
   int resized_width;
   int resized_height;
   *output = new base::RefCountedBytes();
 
   if (layout == ash::WALLPAPER_LAYOUT_CENTER_CROPPED) {
     // Do not resize custom wallpaper if it is smaller than preferred size.
     if (!(width > preferred_width && height > preferred_height))
       return false;
 
     double horizontal_ratio = static_cast<double>(preferred_width) / width;
     double vertical_ratio = static_cast<double>(preferred_height) / height;
     if (vertical_ratio > horizontal_ratio) {
       resized_width =
           RoundPositive(static_cast<double>(width) * vertical_ratio);
       resized_height = preferred_height;
     } else {
       resized_width = preferred_width;
       resized_height =
           RoundPositive(static_cast<double>(height) * horizontal_ratio);
     }
   } else if (layout == ash::WALLPAPER_LAYOUT_STRETCH) {
     resized_width = preferred_width;
     resized_height = preferred_height;
   } else {
     resized_width = width;
     resized_height = height;
   }
 
   gfx::ImageSkia resized_image = gfx::ImageSkiaOperations::CreateResizedImage(
-      wallpaper.image(),
+      wallpaper,
       skia::ImageOperations::RESIZE_LANCZOS3,
       gfx::Size(resized_width, resized_height));
 
   SkBitmap image = *(resized_image.bitmap());
   SkAutoLockPixels lock_input(image);
   gfx::JPEGCodec::Encode(
       reinterpret_cast<unsigned char*>(image.getAddr32(0, 0)),
       gfx::JPEGCodec::FORMAT_SkBitmap,
       image.width(),
       image.height(),
       image.width() * image.bytesPerPixel(),
       kDefaultEncodingQuality, &(*output)->data());
 
   if (output_skia) {
     resized_image.MakeThreadSafe();
     *output_skia = resized_image;
   }
 
   return true;
 }
 
 bool WallpaperManager::ResizeAndSaveWallpaper(
-    const UserImage& wallpaper,
+    const gfx::ImageSkia& wallpaper,
     const base::FilePath& path,
     ash::WallpaperLayout layout,
     int preferred_width,
     int preferred_height,
     gfx::ImageSkia* result_out) const {
   if (layout == ash::WALLPAPER_LAYOUT_CENTER) {
     // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
     if (base::PathExists(path))
       base::DeleteFile(path, false);
     return false;
@@ skipping 67 matching lines @@
   const User *user = chromeos::UserManager::Get()->FindUser(user_id);
   if (!user) {
     NOTREACHED() << "Unknown user.";
     return;
   }
   SetCustomWallpaper(user_id,
                      user->username_hash(),
                      "policy-controlled.jpeg",
                      ash::WALLPAPER_LAYOUT_CENTER_CROPPED,
                      User::POLICY,
-                     wallpaper,
+                     wallpaper.image(),
                      true /* update wallpaper */);
 }
 
 void WallpaperManager::SetCustomWallpaper(const std::string& user_id,
                                           const std::string& user_id_hash,
                                           const std::string& file,
                                           ash::WallpaperLayout layout,
                                           User::WallpaperType type,
-                                          const UserImage& wallpaper,
+                                          const gfx::ImageSkia& wallpaper,
                                           bool update_wallpaper) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(UserManager::Get()->IsUserLoggedIn());
 
   // There is no visible background in kiosk mode.
   if (UserManager::Get()->IsLoggedInAsKioskApp())
     return;
 
   // Don't allow custom wallpapers while policy is in effect.
   if (type != User::POLICY && IsPolicyControlled(user_id))
     return;
 
   base::FilePath wallpaper_path =
       GetCustomWallpaperPath(kOriginalWallpaperSubDir, user_id_hash, file);
 
   // If decoded wallpaper is empty, we have probably failed to decode the file.
   // Use default wallpaper in this case.
-  if (wallpaper.image().isNull()) {
+  if (wallpaper.isNull()) {
     SetDefaultWallpaperDelayed(user_id);
     return;
   }
 
   bool is_persistent =
       !UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id);
 
-  wallpaper.image().EnsureRepsForSupportedScales();
-  scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper.image().DeepCopy());
-
   WallpaperInfo wallpaper_info = {
       wallpaper_path.value(),
       layout,
       type,
       // Date field is not used.
       base::Time::Now().LocalMidnight()
   };
-  // Block shutdown on this task. Otherwise, we may lose the custom wallpaper
-  // that the user selected.
-  scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
-      BrowserThread::GetBlockingPool()->
-          GetSequencedTaskRunnerWithShutdownBehavior(sequence_token_,
-              base::SequencedWorkerPool::BLOCK_SHUTDOWN);
-  // TODO(bshe): This may break if RawImage becomes RefCountedMemory.
-  blocking_task_runner->PostTask(FROM_HERE,
-      base::Bind(&WallpaperManager::ProcessCustomWallpaper,
-                 base::Unretained(this),
-                 user_id_hash,
-                 is_persistent,
-                 wallpaper_info,
-                 base::Passed(&deep_copy),
-                 wallpaper.raw_image()));
+  if (is_persistent) {
+    wallpaper.EnsureRepsForSupportedScales();
+    scoped_ptr<gfx::ImageSkia> deep_copy(wallpaper.DeepCopy());
+    // Block shutdown on this task. Otherwise, we may lose the custom wallpaper
+    // that the user selected.
+    scoped_refptr<base::SequencedTaskRunner> blocking_task_runner =
+        BrowserThread::GetBlockingPool()->
+            GetSequencedTaskRunnerWithShutdownBehavior(
+                sequence_token_, base::SequencedWorkerPool::BLOCK_SHUTDOWN);
+    // TODO(bshe): This may break if RawImage becomes RefCountedMemory.
+    blocking_task_runner->PostTask(
+        FROM_HERE,
+        base::Bind(&WallpaperManager::SaveCustomWallpaper,
+                   base::Unretained(this),
+                   user_id_hash,
+                   base::FilePath(wallpaper_info.file),
+                   wallpaper_info.layout,
+                   base::Passed(&deep_copy)));

[oshima, 2014/04/22 00:13:47]

I think deep_copy.Pass() is better now.

[Thiemo Nagel, 2014/04/23 17:14:06]

I have tried that before.  Using deep_copy.Pass() results in a screenful of
template errors, it seems that for some reason a const qualifier is added that
shouldn't be there.  I didn't get to the bottom of it, and followed the example
of the surrounding code by using base::Passed().

[oshima, 2014/04/23 17:34:23]

Didn't you pass &deep_copy.Pass() instead of deep_copy.Pass()?

[Thiemo Nagel, 2014/04/23 17:44:38]

Neither works.  In the case of deep_copy.Pass(), this is what I get:

In file included from ../../base/bind.h:13:0,
                 from ../../base/timer/timer.h:54,
                 from ../../ui/display/chromeos/display_configurator.h:17,
                 from ../../ash/display/display_manager.h:20,
                 from ../../ash/display/display_controller.h:12,
                 from
../../ash/desktop_background/desktop_background_controller.h:9,
                 from
../../chrome/browser/chromeos/login/wallpaper_manager.h:12,
                 from
../../chrome/browser/chromeos/login/wallpaper_manager.cc:5:
../../base/bind_internal.h: In constructor 'base::internal::BindState<Runnable,
RunType, void(P1, P2, P3, P4, P5)>::BindState(const Runnable&, const P1&, const
P2&, const P3&, const P4&, const P5&) [with Runnable =
base::internal::RunnableAdapter<void (chromeos::WallpaperManager::*)(const
std::basic_string<char>&, const base::FilePath&, ash::WallpaperLayout,
scoped_ptr<gfx::ImageSkia>)const>, RunType = void(const
chromeos::WallpaperManager*, const std::basic_string<char>&, const
base::FilePath&, ash::WallpaperLayout, scoped_ptr<gfx::ImageSkia>), P1 =
base::internal::UnretainedWrapper<chromeos::WallpaperManager>, P2 =
std::basic_string<char>, P3 = base::FilePath, P4 = ash::WallpaperLayout, P5 =
scoped_ptr<gfx::ImageSkia>]':
../../base/bind.h:354:73:   instantiated from 'base::Callback<typename
base::internal::BindState<typename
base::internal::FunctorTraits<Functor>::RunnableType, typename
base::internal::FunctorTraits<Functor>::RunType, void(typename
base::internal::CallbackParamTraits<A1>::StorageType, typename
base::internal::CallbackParamTraits<A2>::StorageType, typename
base::internal::CallbackParamTraits<A3>::StorageType, typename
base::internal::CallbackParamTraits<A4>::StorageType, typename
base::internal::CallbackParamTraits<A5>::StorageType)>::UnboundRunType>
base::Bind(Functor, const P1&, const P2&, const P3&, const P4&, const P5&) [with
Functor = void (chromeos::WallpaperManager::*)(const std::basic_string<char>&,
const base::FilePath&, ash::WallpaperLayout, scoped_ptr<gfx::ImageSkia>)const,
P1 = base::internal::UnretainedWrapper<chromeos::WallpaperManager>, P2 =
std::basic_string<char>, P3 = base::FilePath, P4 = ash::WallpaperLayout, P5 =
scoped_ptr<gfx::ImageSkia>, typename base::internal::BindState<typename
base::internal::FunctorTraits<Functor>::RunnableType, typename
base::internal::FunctorTraits<Functor>::RunType, void(typename
base::internal::CallbackParamTraits<A1>::StorageType, typename
base::internal::CallbackParamTraits<A2>::StorageType, typename
base::internal::CallbackParamTraits<A3>::StorageType, typename
base::internal::CallbackParamTraits<A4>::StorageType, typename
base::internal::CallbackParamTraits<A5>::StorageType)>::UnboundRunType =
void()]'
../../chrome/browser/chromeos/login/wallpaper_manager.cc:796:36:   instantiated
from here
../../base/bind_internal.h:2686:15: error: passing 'const
scoped_ptr<gfx::ImageSkia>' as 'this' argument of 'scoped_ptr<T, D>::operator
scoped_ptr<T, D>::RValue() [with T = gfx::ImageSkia, D =
base::DefaultDeleter<gfx::ImageSkia>]' discards qualifiers [-fpermissive]
../../base/bind_internal.h: In static member function 'static void
base::internal::InvokeHelper<false, void, Runnable, void(A1, A2, A3, A4,
A5)>::MakeItSo(Runnable, A1, A2, A3, A4, A5) [with Runnable =
base::internal::RunnableAdapter<void (chromeos::WallpaperManager::*)(const
std::basic_string<char>&, const base::FilePath&, ash::WallpaperLayout,
scoped_ptr<gfx::ImageSkia>)const>, A1 = chromeos::WallpaperManager*, A2 = const
std::basic_string<char>&, A3 = const base::FilePath&, A4 = const
ash::WallpaperLayout&, A5 = const scoped_ptr<gfx::ImageSkia>&]':
../../base/bind_internal.h:1811:60:   instantiated from 'static R
base::internal::Invoker<5, StorageType, R(X1, X2, X3, X4,
X5)>::Run(base::internal::BindStateBase*) [with StorageType =
base::internal::BindState<base::internal::RunnableAdapter<void
(chromeos::WallpaperManager::*)(const std::basic_string<char>&, const
base::FilePath&, ash::WallpaperLayout, scoped_ptr<gfx::ImageSkia>)const>,
void(const chromeos::WallpaperManager*, const std::basic_string<char>&, const
base::FilePath&, ash::WallpaperLayout, scoped_ptr<gfx::ImageSkia>),
void(base::internal::UnretainedWrapper<chromeos::WallpaperManager>,
std::basic_string<char>, base::FilePath, ash::WallpaperLayout,
scoped_ptr<gfx::ImageSkia>)>, R = void, X1 = const chromeos::WallpaperManager*,
X2 = const std::basic_string<char>&, X3 = const base::FilePath&, X4 =
ash::WallpaperLayout, X5 = scoped_ptr<gfx::ImageSkia>]'
../../base/callback.h:389:28:   instantiated from
'base::Callback<R()>::Callback(base::internal::BindState<Runnable, BindRunType,
BoundArgsType>*) [with Runnable = base::internal::RunnableAdapter<void
(chromeos::WallpaperManager::*)(const std::basic_string<char>&, const
base::FilePath&, ash::WallpaperLayout, scoped_ptr<gfx::ImageSkia>)const>,
BindRunType = void(const chromeos::WallpaperManager*, const
std::basic_string<char>&, const base::FilePath&, ash::WallpaperLayout,
scoped_ptr<gfx::ImageSkia>), BoundArgsType =
void(base::internal::UnretainedWrapper<chromeos::WallpaperManager>,
std::basic_string<char>, base::FilePath, ash::WallpaperLayout,
scoped_ptr<gfx::ImageSkia>), R = void]'
../../base/bind.h:354:73:   instantiated from 'base::Callback<typename
base::internal::BindState<typename
base::internal::FunctorTraits<Functor>::RunnableType, typename
base::internal::FunctorTraits<Functor>::RunType, void(typename
base::internal::CallbackParamTraits<A1>::StorageType, typename
base::internal::CallbackParamTraits<A2>::StorageType, typename
base::internal::CallbackParamTraits<A3>::StorageType, typename
base::internal::CallbackParamTraits<A4>::StorageType, typename
base::internal::CallbackParamTraits<A5>::StorageType)>::UnboundRunType>
base::Bind(Functor, const P1&, const P2&, const P3&, const P4&, const P5&) [with
Functor = void (chromeos::WallpaperManager::*)(const std::basic_string<char>&,
const base::FilePath&, ash::WallpaperLayout, scoped_ptr<gfx::ImageSkia>)const,
P1 = base::internal::UnretainedWrapper<chromeos::WallpaperManager>, P2 =
std::basic_string<char>, P3 = base::FilePath, P4 = ash::WallpaperLayout, P5 =
scoped_ptr<gfx::ImageSkia>, typename base::internal::BindState<typename
base::internal::FunctorTraits<Functor>::RunnableType, typename
base::internal::FunctorTraits<Functor>::RunType, void(typename
base::internal::CallbackParamTraits<A1>::StorageType, typename
base::internal::CallbackParamTraits<A2>::StorageType, typename
base::internal::CallbackParamTraits<A3>::StorageType, typename
base::internal::CallbackParamTraits<A4>::StorageType, typename
base::internal::CallbackParamTraits<A5>::StorageType)>::UnboundRunType =
void()]'
../../chrome/browser/chromeos/login/wallpaper_manager.cc:796:36:   instantiated
from here
../../base/bind_internal.h:991:5: error: passing 'base::enable_if<true, const
scoped_ptr<gfx::ImageSkia> >::type {aka const scoped_ptr<gfx::ImageSkia>}' as
'this' argument of 'scoped_ptr<T, D>::operator scoped_ptr<T, D>::RValue() [with
T = gfx::ImageSkia, D = base::DefaultDeleter<gfx::ImageSkia>]' discards
qualifiers [-fpermissive]
../../base/bind_internal.h:398:5: error:   initializing argument 5 of 'R
base::internal::RunnableAdapter<R (T::*)(A1, A2, A3, A4)const>::Run(const T*,
typename base::internal::CallbackParamTraits<A2>::ForwardType, typename
base::internal::CallbackParamTraits<A3>::ForwardType, typename
base::internal::CallbackParamTraits<A4>::ForwardType, typename
base::internal::CallbackParamTraits<A5>::ForwardType) [with R = void, T =
chromeos::WallpaperManager, A1 = const std::basic_string<char>&, A2 = const
base::FilePath&, A3 = ash::WallpaperLayout, A4 = scoped_ptr<gfx::ImageSkia>,
typename base::internal::CallbackParamTraits<A2>::ForwardType = const
std::basic_string<char>&, typename
base::internal::CallbackParamTraits<A3>::ForwardType = const base::FilePath&,
typename base::internal::CallbackParamTraits<A4>::ForwardType = const
ash::WallpaperLayout&, typename
base::internal::CallbackParamTraits<A5>::ForwardType =
scoped_ptr<gfx::ImageSkia>]'

+  }
 
   std::string relative_path = base::FilePath(user_id_hash).Append(file).value();
   // User's custom wallpaper path is determined by relative path and the
   // appropriate wallpaper resolution in GetCustomWallpaperInternal.
   WallpaperInfo info = {
       relative_path,
       layout,
       type,
       base::Time::Now().LocalMidnight()
   };
   SetUserWallpaperInfo(user_id, info, is_persistent);
   if (update_wallpaper) {
     GetPendingWallpaper(user_id, false)
-        ->ResetSetWallpaperImage(wallpaper.image(), info);
+        ->ResetSetWallpaperImage(wallpaper, info);
   }
 
   if (UserManager::IsMultipleProfilesAllowed())
-    wallpaper_cache_[user_id] = wallpaper.image();
+    wallpaper_cache_[user_id] = wallpaper;
 }
 
 void WallpaperManager::SetDefaultWallpaperNow(const std::string& user_id) {
   GetPendingWallpaper(user_id, false)->ResetSetDefaultWallpaper();
 }
 
 void WallpaperManager::SetDefaultWallpaperDelayed(const std::string& user_id) {
   GetPendingWallpaper(user_id, true)->ResetSetDefaultWallpaper();
 }
 
@@ skipping 74 matching lines @@
 
   base::DictionaryValue* wallpaper_info_dict = new base::DictionaryValue();
   wallpaper_info_dict->SetString(kNewWallpaperDateNodeName,
       base::Int64ToString(info.date.ToInternalValue()));
   wallpaper_info_dict->SetString(kNewWallpaperFileNodeName, info.file);
   wallpaper_info_dict->SetInteger(kNewWallpaperLayoutNodeName, info.layout);
   wallpaper_info_dict->SetInteger(kNewWallpaperTypeNodeName, info.type);
   wallpaper_update->SetWithoutPathExpansion(user_id, wallpaper_info_dict);
 }
 
-void WallpaperManager::SetLastSelectedUser(

[Nikita (slow), 2014/04/18 09:28:19]

I guess this was previously used for tests, maybe not.
Not anymore.

-    const std::string& last_selected_user) {
-  last_selected_user_ = last_selected_user;
-}
-
 void WallpaperManager::SetUserWallpaperDelayed(const std::string& user_id) {
   ScheduleSetUserWallpaper(user_id, true);
 }
 
 void WallpaperManager::SetUserWallpaperNow(const std::string& user_id) {
   ScheduleSetUserWallpaper(user_id, false);
 }
 
 void WallpaperManager::ScheduleSetUserWallpaper(const std::string& user_id,
                                                 bool delayed) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Some unit tests come here without a UserManager or without a pref system.
   if (!UserManager::IsInitialized() || !g_browser_process->local_state())
     return;
   // There is no visible background in kiosk mode.
   if (UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   // Guest user, regular user in ephemeral mode, or kiosk app.
   const User* user = UserManager::Get()->FindUser(user_id);
   if (UserManager::Get()->IsUserNonCryptohomeDataEphemeral(user_id) ||
       (user != NULL && user->GetType() == User::USER_TYPE_KIOSK_APP)) {
     InitInitialUserWallpaper(user_id, false);
     GetPendingWallpaper(user_id, delayed)->ResetSetDefaultWallpaper();
     return;
   }
 
   if (!UserManager::Get()->IsKnownUser(user_id))
     return;
 
-  SetLastSelectedUser(user_id);
+  last_selected_user_ = user_id;
 
   WallpaperInfo info;
 
   if (!GetUserWallpaperInfo(user_id, &info)) {
     InitInitialUserWallpaper(user_id, true);
     GetUserWallpaperInfo(user_id, &info);
   }
 
   gfx::ImageSkia user_wallpaper;
   current_user_wallpaper_info_ = info;
@@ skipping 143 matching lines @@
 
 void WallpaperManager::ClearObsoleteWallpaperPrefs() {
   PrefService* prefs = g_browser_process->local_state();
   DictionaryPrefUpdate wallpaper_properties_pref(prefs,
       kUserWallpapersProperties);
   wallpaper_properties_pref->Clear();
   DictionaryPrefUpdate wallpapers_pref(prefs, kUserWallpapers);
   wallpapers_pref->Clear();
 }
 
+// static
 void WallpaperManager::DeleteAllExcept(const base::FilePath& path) {

[Nikita (slow), 2014/04/18 09:28:19]

nit: This function seems to be used only in this file.
How about moving it to unnamed namespace instead?

[Thiemo Nagel, 2014/04/23 17:14:06]

Done.

   base::FilePath dir = path.DirName();
   if (base::DirectoryExists(dir)) {
     base::FileEnumerator files(dir, false, base::FileEnumerator::FILES);
     for (base::FilePath current = files.Next(); !current.empty();
          current = files.Next()) {
       if (current != path)
         base::DeleteFile(current, false);
     }
   }
 }
 
+// static
 void WallpaperManager::DeleteWallpaperInList(

[Nikita (slow), 2014/04/18 09:28:19]

nit: This function seems to be used only in this file.
How about moving it to unnamed namespace instead?

[Thiemo Nagel, 2014/04/23 17:14:06]

Done.

     const std::vector<base::FilePath>& file_list) {
   for (std::vector<base::FilePath>::const_iterator it = file_list.begin();
        it != file_list.end(); ++it) {
     base::FilePath path = *it;
     // Some users may still have legacy wallpapers with png extension. We need
     // to delete these wallpapers too.
     if (!base::DeleteFile(path, true) &&
         !base::DeleteFile(path.AddExtension(".png"), false)) {
       LOG(ERROR) << "Failed to remove user wallpaper at " << path.value();
     }
@@ skipping 25 matching lines @@
 
   // Remove original user wallpaper.
   wallpaper_path = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
   file_to_remove.push_back(wallpaper_path.Append(user_id));
   wallpaper_path = wallpaper_path.Append(path_to_file);
   file_to_remove.push_back(wallpaper_path);
 
   base::WorkerPool::PostTask(
       FROM_HERE,
       base::Bind(&WallpaperManager::DeleteWallpaperInList,
-                 base::Unretained(this),
                  file_to_remove),
       false);
 }
 
+// static
 void WallpaperManager::EnsureCustomWallpaperDirectories(

[Nikita (slow), 2014/04/18 09:28:19]

nit: This function seems to be used only in this file.
How about moving it to unnamed namespace instead?

[Thiemo Nagel, 2014/04/23 17:14:06]

Done.

     const std::string& user_id_hash) {
   base::FilePath dir;
   dir = GetCustomWallpaperDir(kSmallWallpaperSubDir);
   dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     base::CreateDirectory(dir);
   dir = GetCustomWallpaperDir(kLargeWallpaperSubDir);
   dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     base::CreateDirectory(dir);
@@ skipping 264 matching lines @@
     wallpaper_cache_[user_id] = wallpaper.image();
   }
 
   if (update_wallpaper) {
     ash::Shell::GetInstance()
         ->desktop_background_controller()
         ->SetWallpaperImage(wallpaper.image(), layout);
   }
 }
 
-void WallpaperManager::ProcessCustomWallpaper(
+void WallpaperManager::SaveCustomWallpaper(
     const std::string& user_id_hash,
-    bool persistent,
-    const WallpaperInfo& info,
-    scoped_ptr<gfx::ImageSkia> image,
-    const UserImage::RawImage& raw_image) {
-  DCHECK(BrowserThread::GetBlockingPool()->
-      IsRunningSequenceOnCurrentThread(sequence_token_));
-  UserImage wallpaper(*image.get(), raw_image);
-  if (persistent) {
-    SaveCustomWallpaper(user_id_hash, base::FilePath(info.file), info.layout,
-                        wallpaper);
-  }
-}
-
-void WallpaperManager::SaveCustomWallpaper(const std::string& user_id_hash,
-                                           const base::FilePath& original_path,
-                                           ash::WallpaperLayout layout,
-                                           const UserImage& wallpaper) {
+    const base::FilePath& original_path,
+    ash::WallpaperLayout layout,
+    scoped_ptr<gfx::ImageSkia> wallpaper) const {
   DCHECK(BrowserThread::GetBlockingPool()->
       IsRunningSequenceOnCurrentThread(sequence_token_));
   EnsureCustomWallpaperDirectories(user_id_hash);
   std::string file_name = original_path.BaseName().value();
   base::FilePath small_wallpaper_path =
       GetCustomWallpaperPath(kSmallWallpaperSubDir, user_id_hash, file_name);
   base::FilePath large_wallpaper_path =
       GetCustomWallpaperPath(kLargeWallpaperSubDir, user_id_hash, file_name);
 
   // Re-encode orginal file to jpeg format and saves the result in case that
   // resized wallpaper is not generated (i.e. chrome shutdown before resized
   // wallpaper is saved).
-  ResizeAndSaveWallpaper(wallpaper,
+  ResizeAndSaveWallpaper(*wallpaper,
                          original_path,
                          ash::WALLPAPER_LAYOUT_STRETCH,
-                         wallpaper.image().width(),
-                         wallpaper.image().height(),
+                         wallpaper->width(),
+                         wallpaper->height(),
                          NULL);
   DeleteAllExcept(original_path);
 
-  ResizeAndSaveWallpaper(wallpaper,
+  ResizeAndSaveWallpaper(*wallpaper,
                          small_wallpaper_path,
                          layout,
                          kSmallWallpaperMaxWidth,
                          kSmallWallpaperMaxHeight,
                          NULL);
   DeleteAllExcept(small_wallpaper_path);
-  ResizeAndSaveWallpaper(wallpaper,
+  ResizeAndSaveWallpaper(*wallpaper,
                          large_wallpaper_path,
                          layout,
                          kLargeWallpaperMaxWidth,
                          kLargeWallpaperMaxHeight,
                          NULL);
   DeleteAllExcept(large_wallpaper_path);
 }
 
 void WallpaperManager::RecordUma(User::WallpaperType type, int index) const {
   UMA_HISTOGRAM_ENUMERATION("Ash.Wallpaper.Type", type,
@@ skipping 118 matching lines @@
                  base::Passed(on_finish.Pass())));
 }
 
 const char* WallpaperManager::GetCustomWallpaperSubdirForCurrentResolution() {
   WallpaperResolution resolution = GetAppropriateResolution();
   return resolution == WALLPAPER_RESOLUTION_SMALL ? kSmallWallpaperSubDir
                                                   : kLargeWallpaperSubDir;
 }
 
 }  // namespace chromeos