Move all wallpaper file loading and decoding from DesktopBackgroundController to 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"
+#include "ash/desktop_background/desktop_background_controller.h"
 #include "ash/shell.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 12 matching lines @@
 #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"
+#include "grit/ash_resources.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/image/image_skia_operations.h"
 #include "ui/gfx/skia_util.h"
 
 using content::BrowserThread;
 
+namespace chromeos {
+
 namespace {
 
 // The amount of delay before starts to move custom wallpapers to the new place.
 const int kMoveCustomWallpaperDelaySeconds = 30;
 
 // Default quality for encoding wallpaper.
 const int kDefaultEncodingQuality = 90;
 
 // A dictionary pref that maps usernames to file paths to their wallpapers.
 // Deprecated. Will remove this const char after done migration.
@@ skipping 48 matching lines @@
   base::FilePath base_path = GetCustomWallpaperDir(sub_dir);
   base::FilePath to_path = base_path.Append(user_id_hash);
   base::FilePath from_path = base_path.Append(user_id);
   if (base::PathExists(from_path))
     return base::Move(from_path, to_path);
   return false;
 }
 
 }  // namespace
 
-namespace chromeos {
-
 const char kWallpaperSequenceTokenName[] = "wallpaper-sequence";
 
 const char kSmallWallpaperSuffix[] = "_small";
 const char kLargeWallpaperSuffix[] = "_large";
 
 const char kSmallWallpaperSubDir[] = "small";
 const char kLargeWallpaperSubDir[] = "large";
 const char kOriginalWallpaperSubDir[] = "original";
 const char kThumbnailWallpaperSubDir[] = "thumb";
 
+const int kSmallWallpaperMaxWidth = 1366;
+const int kSmallWallpaperMaxHeight = 800;
+const int kLargeWallpaperMaxWidth = 2560;
+const int kLargeWallpaperMaxHeight = 1700;
+const int kWallpaperThumbnailWidth = 108;
+const int kWallpaperThumbnailHeight = 68;
+
 static WallpaperManager* g_wallpaper_manager = NULL;
 
 // This object is passed between several threads while wallpaper is being
 // loaded. It will notify callback when last reference to it is removed
 // (thus indicating that the last load action has finished).
 class MovableOnDestroyCallback {
  public:
   explicit MovableOnDestroyCallback(const base::Closure& callback)
       : callback_(callback) {
   }
@@ skipping 62 matching lines @@
 
   WallpaperManager* manager = WallpaperManager::Get();
   if (manager->pending_inactive_ == this)
     manager->pending_inactive_ = NULL;
 
   started_load_at_ = base::Time::Now();
 
   if (default_) {
     manager->DoSetDefaultWallpaper(user_id_, on_finish_.Pass());
   } else if (!user_wallpaper_.isNull()) {
-    ash::Shell::GetInstance()->
-        desktop_background_controller()->
-            SetCustomWallpaper(user_wallpaper_, info_.layout);
+    ash::Shell::GetInstance()
+        ->desktop_background_controller()
+        ->SetWallpaperImage(user_wallpaper_, info_.layout);
   } else if (!wallpaper_path_.empty()) {
     manager->task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                    base::Unretained(manager),
                    user_id_,
                    info_,
                    wallpaper_path_,
                    true /* update wallpaper */,
                    base::Passed(on_finish_.Pass())));
@@ skipping 75 matching lines @@
     g_wallpaper_manager = new WallpaperManager();
   return g_wallpaper_manager;
 }
 
 WallpaperManager::WallpaperManager()
     : loaded_wallpapers_(0),
       command_line_for_testing_(NULL),
       should_cache_wallpaper_(false),
       weak_factory_(this),
       pending_inactive_(NULL) {
+  SetDefaultWallpaperPathsFromCommandLine(
+      base::CommandLine::ForCurrentProcess());
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_USER_CHANGED,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE,
                  content::NotificationService::AllSources());
   registrar_.Add(this,
                  chrome::NOTIFICATION_WALLPAPER_ANIMATION_FINISHED,
                  content::NotificationService::AllSources());
   sequence_token_ = BrowserThread::GetBlockingPool()->
@@ skipping 106 matching lines @@
   }
 
   return GetUserWallpaperInfo(UserManager::Get()->GetLoggedInUser()->email(),
                               info);
 }
 
 void WallpaperManager::InitializeWallpaper() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UserManager* user_manager = UserManager::Get();
 
-  CommandLine* command_line = GetComandLine();
+  CommandLine* command_line = GetCommandLine();
   if (command_line->HasSwitch(chromeos::switches::kGuestSession)) {
     // Guest wallpaper should be initialized when guest login.
     // Note: This maybe called before login. So IsLoggedInAsGuest can not be
     // used here to determine if current user is guest.
     return;
   }
 
   if (command_line->HasSwitch(::switches::kTestType))
     WizardController::SetZeroDelays();
 
@@ skipping 24 matching lines @@
       ClearDisposableWallpaperCache();
       BrowserThread::PostDelayedTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&WallpaperManager::MoveLoggedInUserCustomWallpaper,
                      weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromSeconds(kMoveCustomWallpaperDelaySeconds));
       break;
     }
     case chrome::NOTIFICATION_LOGIN_OR_LOCK_WEBUI_VISIBLE: {
-      if (!GetComandLine()->HasSwitch(switches::kDisableBootAnimation)) {
+      if (!GetCommandLine()->HasSwitch(switches::kDisableBootAnimation)) {
         BrowserThread::PostDelayedTask(
             BrowserThread::UI, FROM_HERE,
             base::Bind(&WallpaperManager::CacheUsersWallpapers,
                        weak_factory_.GetWeakPtr()),
             base::TimeDelta::FromMilliseconds(kCacheWallpaperDelayMs));
       } else {
         should_cache_wallpaper_ = true;
       }
       break;
     }
@@ skipping 22 matching lines @@
       prefs::kUsersWallpaperInfo);
   prefs_wallpapers_info_update->RemoveWithoutPathExpansion(user_id, NULL);
   DeleteUserWallpapers(user_id, info.file);
 }
 
 bool WallpaperManager::ResizeWallpaper(
     const UserImage& wallpaper,
     ash::WallpaperLayout layout,
     int preferred_width,
     int preferred_height,
-    scoped_refptr<base::RefCountedBytes>* output) const {
+    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 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.
@@ skipping 26 matching lines @@
 
   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;
 }
 
-void WallpaperManager::ResizeAndSaveWallpaper(const UserImage& wallpaper,
-                                              const base::FilePath& path,
-                                              ash::WallpaperLayout layout,
-                                              int preferred_width,
-                                              int preferred_height) const {
+bool WallpaperManager::ResizeAndSaveWallpaper(
+    const UserImage& 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;
+    return false;
   }
   scoped_refptr<base::RefCountedBytes> data;
-  if (ResizeWallpaper(wallpaper, layout, preferred_width, preferred_height,
-                      &data)) {
-    SaveWallpaperInternal(path,
-                          reinterpret_cast<const char*>(data->front()),
-                          data->size());
+  if (ResizeWallpaper(wallpaper,
+                      layout,
+                      preferred_width,
+                      preferred_height,
+                      &data,
+                      result_out)) {
+    return SaveWallpaperInternal(
+        path, reinterpret_cast<const char*>(data->front()), data->size());
   }
+  return false;
 }
 
 bool WallpaperManager::IsPolicyControlled(const std::string& user_id) const {
   chromeos::WallpaperInfo info;
   if (!GetUserWallpaperInfo(user_id, &info))
     return false;
   return info.type == chromeos::User::POLICY;
 }
 
 void WallpaperManager::OnPolicySet(const std::string& policy,
@@ skipping 20 matching lines @@
     return;
 
   wallpaper_loader_->Start(
       data.Pass(),
       0,  // Do not crop.
       base::Bind(&WallpaperManager::SetPolicyControlledWallpaper,
                  weak_factory_.GetWeakPtr(),
                  user_id));
 }
 
+// static
+WallpaperManager::WallpaperResolution
+WallpaperManager::GetAppropriateResolution() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  gfx::Size size =
+      ash::DesktopBackgroundController::GetMaxDisplaySizeInNative();
+  return (size.width() > kSmallWallpaperMaxWidth ||
+          size.height() > kSmallWallpaperMaxHeight)
+             ? WALLPAPER_RESOLUTION_LARGE
+             : WALLPAPER_RESOLUTION_SMALL;
+}
+
 void WallpaperManager::SetPolicyControlledWallpaper(
     const std::string& user_id,
     const UserImage& wallpaper) {
   const User *user = chromeos::UserManager::Get()->FindUser(user_id);
   if (!user) {
     NOTREACHED() << "Unknown user.";
     return;
   }
   SetCustomWallpaper(user_id,
                      user->username_hash(),
@@ skipping 94 matching lines @@
   // There is no visible background in kiosk mode.
   if (UserManager::Get()->IsLoggedInAsKioskApp())
     return;
   current_wallpaper_path_.clear();
   wallpaper_cache_.erase(user_id);
   // Some browser tests do not have a shell instance. As no wallpaper is needed
   // in these tests anyway, avoid loading one, preventing crashes and speeding
   // up the tests.
   if (!ash::Shell::HasInstance())
     return;
-  if (ash::Shell::GetInstance()->desktop_background_controller()->
-          SetDefaultWallpaper(UserManager::Get()->IsLoggedInAsGuest()))
-    loaded_wallpapers_++;
+
+  WallpaperResolution resolution = GetAppropriateResolution();
+  const bool use_small = (resolution == WALLPAPER_RESOLUTION_SMALL);
+
+  const base::FilePath* file = NULL;
+
+  if (UserManager::Get()->IsLoggedInAsGuest()) {
+    file =
+        use_small ? &guest_small_wallpaper_file_ : &guest_large_wallpaper_file_;
+  } else {
+    file = use_small ? &default_small_wallpaper_file_
+                     : &default_large_wallpaper_file_;
+  }
+  const ash::WallpaperLayout layout =
+      use_small ? ash::WALLPAPER_LAYOUT_CENTER
+                : ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
+  DCHECK(file);
+  if (!default_wallpaper_image_.get() ||
+      default_wallpaper_image_->url().spec() != file->value()) {
+    default_wallpaper_image_.reset();
+    if (!file->empty()) {
+      loaded_wallpapers_++;
+      StartLoadAndSetDefaultWallpaper(
+          *file, layout, on_finish.Pass(), &default_wallpaper_image_);
+      return;
+    }
+
+    const int resource_id = use_small ? IDR_AURA_WALLPAPER_DEFAULT_SMALL
+                                      : IDR_AURA_WALLPAPER_DEFAULT_LARGE;
+
+    loaded_wallpapers_ += ash::Shell::GetInstance()
+                              ->desktop_background_controller()
+                              ->SetWallpaperResource(resource_id, layout);
+    return;
+  }
+  ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
+      default_wallpaper_image_->image(), layout);
 }
 
 void WallpaperManager::InitInitialUserWallpaper(const std::string& user_id,
                                                 bool is_persistent) {
   current_user_wallpaper_info_.file = "";
   current_user_wallpaper_info_.layout = ash::WALLPAPER_LAYOUT_CENTER_CROPPED;
   current_user_wallpaper_info_.type = User::DEFAULT;
   current_user_wallpaper_info_.date = base::Time::Now().LocalMidnight();
 
   WallpaperInfo info = current_user_wallpaper_info_;
@@ skipping 64 matching lines @@
     GetUserWallpaperInfo(user_id, &info);
   }
 
   gfx::ImageSkia user_wallpaper;
   current_user_wallpaper_info_ = info;
   if (GetWallpaperFromCache(user_id, &user_wallpaper)) {
     GetPendingWallpaper(user_id, delayed)
         ->ResetSetWallpaperImage(user_wallpaper, info);
   } else {
     if (info.type == User::CUSTOMIZED || info.type == User::POLICY) {
-      ash::WallpaperResolution resolution =
-          ash::Shell::GetInstance()->
-              desktop_background_controller()->
-                  GetAppropriateResolution();
-      const char* sub_dir = (resolution == ash::WALLPAPER_RESOLUTION_SMALL)
-                                ? kSmallWallpaperSubDir
-                                : kLargeWallpaperSubDir;
-
+      const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       // Wallpaper is not resized when layout is ash::WALLPAPER_LAYOUT_CENTER.
       // Original wallpaper should be used in this case.
       // TODO(bshe): Generates cropped custom wallpaper for CENTER layout.
       if (info.layout == ash::WALLPAPER_LAYOUT_CENTER)
         sub_dir = kOriginalWallpaperSubDir;
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
       wallpaper_path = wallpaper_path.Append(info.file);
       if (current_wallpaper_path_ == wallpaper_path)
         return;
       current_wallpaper_path_ = wallpaper_path;
@@ skipping 31 matching lines @@
   if (UserManager::IsMultipleProfilesAllowed())
     wallpaper_cache_[user_id] = wallpaper;
 
   if (update_wallpaper) {
     GetPendingWallpaper(last_selected_user_, false /* Not delayed */)
         ->ResetSetWallpaperImage(wallpaper, info);
   }
 }
 
 void WallpaperManager::UpdateWallpaper(bool clear_cache) {
+  FOR_EACH_OBSERVER(Observer, observers_, OnUpdateWallpaperForTesting());
   if (clear_cache)
     wallpaper_cache_.clear();
   current_wallpaper_path_.clear();
   // For GAIA login flow, the last_selected_user_ may not be set before user
   // login. If UpdateWallpaper is called at GAIA login screen, no wallpaper will
   // be set. It could result a black screen on external monitors.
   // See http://crbug.com/265689 for detail.
   if (last_selected_user_.empty()) {
     SetDefaultWallpaperNow(UserManager::kSignInUser);
     return;
@@ skipping 45 matching lines @@
 }
 
 void WallpaperManager::CacheUserWallpaper(const std::string& user_id) {
   if (wallpaper_cache_.find(user_id) != wallpaper_cache_.end())
     return;
   WallpaperInfo info;
   if (GetUserWallpaperInfo(user_id, &info)) {
     base::FilePath wallpaper_dir;
     base::FilePath wallpaper_path;
     if (info.type == User::CUSTOMIZED || info.type == User::POLICY) {
-      ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
-          desktop_background_controller()->GetAppropriateResolution();
-      const char* sub_dir  = (resolution == ash::WALLPAPER_RESOLUTION_SMALL) ?
-            kSmallWallpaperSubDir : kLargeWallpaperSubDir;
+      const char* sub_dir = GetCustomWallpaperSubdirForCurrentResolution();
       base::FilePath wallpaper_path = GetCustomWallpaperDir(sub_dir);
       wallpaper_path = wallpaper_path.Append(info.file);
       task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WallpaperManager::GetCustomWallpaperInternal,
                      base::Unretained(this),
                      user_id,
                      info,
                      wallpaper_path,
                      false /* do not update wallpaper */,
@@ skipping 93 matching lines @@
   dir = GetCustomWallpaperDir(kOriginalWallpaperSubDir);
   dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     base::CreateDirectory(dir);
   dir = GetCustomWallpaperDir(kThumbnailWallpaperSubDir);
   dir = dir.Append(user_id_hash);
   if (!base::PathExists(dir))
     base::CreateDirectory(dir);
 }
 
-CommandLine* WallpaperManager::GetComandLine() {
+void WallpaperManager::SetCommandLineForTesting(
+    base::CommandLine* command_line) {
+  command_line_for_testing_ = command_line;
+  SetDefaultWallpaperPathsFromCommandLine(command_line);
+}
+
+CommandLine* WallpaperManager::GetCommandLine() {
   CommandLine* command_line = command_line_for_testing_ ?
       command_line_for_testing_ : CommandLine::ForCurrentProcess();
   return command_line;
 }
 
 void WallpaperManager::InitializeRegisteredDeviceWallpaper() {
   if (UserManager::Get()->IsUserLoggedIn())
     return;
 
-  bool disable_boot_animation = GetComandLine()->
-      HasSwitch(switches::kDisableBootAnimation);
+  bool disable_boot_animation =
+      GetCommandLine()->HasSwitch(switches::kDisableBootAnimation);
   bool show_users = true;
   bool result = CrosSettings::Get()->GetBoolean(
       kAccountsPrefShowUserNamesOnSignIn, &show_users);
   DCHECK(result) << "Unable to fetch setting "
                  << kAccountsPrefShowUserNamesOnSignIn;
   const chromeos::UserList& users = UserManager::Get()->GetUsers();
   if (!show_users || users.empty()) {
     // Boot into sign in form, preload default wallpaper.
     SetDefaultWallpaperDelayed(UserManager::kSignInUser);
     return;
   }
 
   if (!disable_boot_animation) {
     // Normal boot, load user wallpaper.
     // If normal boot animation is disabled wallpaper would be set
     // asynchronously once user pods are loaded.
     SetUserWallpaperDelayed(users[0]->email());
   }
 }
 
 void WallpaperManager::LoadWallpaper(const std::string& user_id,
                                      const WallpaperInfo& info,
                                      bool update_wallpaper,
                                      MovableOnDestroyCallbackHolder on_finish) {
   base::FilePath wallpaper_dir;
   base::FilePath wallpaper_path;
   if (info.type == User::ONLINE) {
     std::string file_name = GURL(info.file).ExtractFileName();
-    ash::WallpaperResolution resolution = ash::Shell::GetInstance()->
-        desktop_background_controller()->GetAppropriateResolution();
+    WallpaperResolution resolution = GetAppropriateResolution();
     // Only solid color wallpapers have stretch layout and they have only one
     // resolution.
     if (info.layout != ash::WALLPAPER_LAYOUT_STRETCH &&
-        resolution == ash::WALLPAPER_RESOLUTION_SMALL) {
+        resolution == WALLPAPER_RESOLUTION_SMALL) {
       file_name = base::FilePath(file_name).InsertBeforeExtension(
           kSmallWallpaperSuffix).value();
     }
     CHECK(PathService::Get(chrome::DIR_CHROMEOS_WALLPAPERS, &wallpaper_dir));
     wallpaper_path = wallpaper_dir.Append(file_name);
     if (current_wallpaper_path_ == wallpaper_path)
       return;
 
     if (update_wallpaper)
       current_wallpaper_path_ = wallpaper_path;
@@ skipping 185 matching lines @@
     return;
   }
 
   // Only cache the user wallpaper at login screen and for multi profile users.
   if (!UserManager::Get()->IsUserLoggedIn() ||
       UserManager::IsMultipleProfilesAllowed()) {
     wallpaper_cache_[user_id] = wallpaper.image();
   }
 
   if (update_wallpaper) {
-    ash::Shell::GetInstance()->desktop_background_controller()->
-        SetCustomWallpaper(wallpaper.image(), layout);
+    ash::Shell::GetInstance()
+        ->desktop_background_controller()
+        ->SetWallpaperImage(wallpaper.image(), layout);
   }
 }
 
 void WallpaperManager::ProcessCustomWallpaper(
     const std::string& user_id_hash,
     bool persistent,
     const WallpaperInfo& info,
     scoped_ptr<gfx::ImageSkia> image,
     const UserImage::RawImage& raw_image) {
   DCHECK(BrowserThread::GetBlockingPool()->
@@ skipping 14 matching lines @@
   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, original_path,
+  ResizeAndSaveWallpaper(wallpaper,
+                         original_path,
                          ash::WALLPAPER_LAYOUT_STRETCH,
                          wallpaper.image().width(),
-                         wallpaper.image().height());
+                         wallpaper.image().height(),
+                         NULL);
   DeleteAllExcept(original_path);
 
-  ResizeAndSaveWallpaper(wallpaper, small_wallpaper_path, layout,
-                         ash::kSmallWallpaperMaxWidth,
-                         ash::kSmallWallpaperMaxHeight);
+  ResizeAndSaveWallpaper(wallpaper,
+                         small_wallpaper_path,
+                         layout,
+                         kSmallWallpaperMaxWidth,
+                         kSmallWallpaperMaxHeight,
+                         NULL);
   DeleteAllExcept(small_wallpaper_path);
-  ResizeAndSaveWallpaper(wallpaper, large_wallpaper_path, layout,
-                         ash::kLargeWallpaperMaxWidth,
-                         ash::kLargeWallpaperMaxHeight);
+  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,
                             User::WALLPAPER_TYPE_COUNT);
 }
 
-void WallpaperManager::SaveWallpaperInternal(const base::FilePath& path,
+bool WallpaperManager::SaveWallpaperInternal(const base::FilePath& path,
                                              const char* data,
                                              int size) const {
   int written_bytes = base::WriteFile(path, data, size);
-  DCHECK(written_bytes == size);
+  return written_bytes == size;
 }
 
 void WallpaperManager::StartLoad(const std::string& user_id,
                                  const WallpaperInfo& info,
                                  bool update_wallpaper,
                                  const base::FilePath& wallpaper_path,
                                  MovableOnDestroyCallbackHolder on_finish) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   TRACE_EVENT_ASYNC_BEGIN0("ui", "LoadAndDecodeWallpaper", this);
 
@@ skipping 52 matching lines @@
   if (!pending_inactive_) {
     loading_.push_back(new WallpaperManager::PendingWallpaper(
         (delayed ? GetWallpaperLoadDelay()
                  : base::TimeDelta::FromMilliseconds(0)),
         user_id));
     pending_inactive_ = loading_.back();
   }
   return pending_inactive_;
 }
 
+void WallpaperManager::SetDefaultWallpaperPathsFromCommandLine(
+    base::CommandLine* command_line) {
+  default_small_wallpaper_file_ = command_line->GetSwitchValuePath(
+      ash::switches::kAshDefaultWallpaperSmall);
+  default_large_wallpaper_file_ = command_line->GetSwitchValuePath(
+      ash::switches::kAshDefaultWallpaperLarge);
+  guest_small_wallpaper_file_ =
+      command_line->GetSwitchValuePath(ash::switches::kAshGuestWallpaperSmall);
+  guest_large_wallpaper_file_ =
+      command_line->GetSwitchValuePath(ash::switches::kAshGuestWallpaperLarge);
+  default_wallpaper_image_.reset();
+}
+
+void WallpaperManager::OnDefaultWallpaperDecoded(
+    const base::FilePath& path,
+    const ash::WallpaperLayout layout,
+    scoped_ptr<chromeos::UserImage>* result_out,
+    MovableOnDestroyCallbackHolder on_finish,
+    const UserImage& wallpaper) {
+  result_out->reset(new UserImage(wallpaper.image()));
+  (*result_out)->set_url(GURL(path.value()));
+  ash::Shell::GetInstance()->desktop_background_controller()->SetWallpaperImage(
+      wallpaper.image(), layout);
+}
+
+void WallpaperManager::StartLoadAndSetDefaultWallpaper(
+    const base::FilePath& path,
+    const ash::WallpaperLayout layout,
+    MovableOnDestroyCallbackHolder on_finish,
+    scoped_ptr<chromeos::UserImage>* result_out) {
+  wallpaper_loader_->Start(
+      path.value(),
+      0,  // Do not crop.
+      base::Bind(&WallpaperManager::OnDefaultWallpaperDecoded,
+                 weak_factory_.GetWeakPtr(),
+                 path,
+                 layout,
+                 base::Unretained(result_out),
+                 base::Passed(on_finish.Pass())));
+}
+
+const char* WallpaperManager::GetCustomWallpaperSubdirForCurrentResolution() {
+  WallpaperResolution resolution = GetAppropriateResolution();
+  return resolution == WALLPAPER_RESOLUTION_SMALL ? kSmallWallpaperSubDir
+                                                  : kLargeWallpaperSubDir;
+}
+
 }  // namespace chromeos