If customization includes default wallpaper, download and apply it.

ash/desktop_background/desktop_background_controller.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 "ash/desktop_background/desktop_background_controller.h"
 
 #include "ash/ash_switches.h"
 #include "ash/desktop_background/desktop_background_controller_observer.h"
 #include "ash/desktop_background/desktop_background_view.h"
 #include "ash/desktop_background/desktop_background_widget_controller.h"
@@ skipping 32 matching lines @@
 // changed?
 const int kWallpaperReloadDelayMs = 2000;
 
 }  // namespace
 
 const int kSmallWallpaperMaxWidth = 1366;
 const int kSmallWallpaperMaxHeight = 800;
 const int kLargeWallpaperMaxWidth = 2560;
 const int kLargeWallpaperMaxHeight = 1700;
 const int kWallpaperThumbnailWidth = 108;
 const int kWallpaperThumbnailHeight = 68;

[Daniel Erat, 2014/03/27 01:45:50]

delete these if you don't use them

[Alexander Alekseev, 2014/03/31 14:15:40]

They are used in extensions/wallpaper_api.cc

 
 // DesktopBackgroundController::WallpaperLoader wraps background wallpaper
 // loading.
 class DesktopBackgroundController::WallpaperLoader

[Daniel Erat, 2014/03/27 01:45:50]

delete WallpaperLoader if you don't use it anymore

[Alexander Alekseev, 2014/03/31 14:15:40]

Done.

     : public base::RefCountedThreadSafe<
           DesktopBackgroundController::WallpaperLoader> {
  public:
   // If set, |file_path| must be a trusted (i.e. read-only,
   // non-user-controlled) file containing a JPEG image.
   WallpaperLoader(const base::FilePath& file_path,
                   WallpaperLayout file_layout,
                   int resource_id,
                   WallpaperLayout resource_layout)
       : file_path_(file_path),
@@ skipping 80 matching lines @@
   // ID of an image resource to use if |file_path_| is empty or unloadable.
   int resource_id_;
 
   // Layout to be used when displaying |resource_id_|.
   WallpaperLayout resource_layout_;
 
   DISALLOW_COPY_AND_ASSIGN(WallpaperLoader);
 };
 
 DesktopBackgroundController::DesktopBackgroundController()
-    : command_line_for_testing_(NULL),
-      locked_(false),
+    : locked_(false),
       desktop_background_mode_(BACKGROUND_NONE),
-      current_default_wallpaper_resource_id_(-1),
-      weak_ptr_factory_(this),
       wallpaper_reload_delay_(kWallpaperReloadDelayMs) {
   Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 DesktopBackgroundController::~DesktopBackgroundController() {
-  CancelDefaultWallpaperLoader();
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
 gfx::ImageSkia DesktopBackgroundController::GetWallpaper() const {
   if (current_wallpaper_)
     return current_wallpaper_->image();
   return gfx::ImageSkia();
 }
 
 void DesktopBackgroundController::AddObserver(
@@ skipping 22 matching lines @@
   if (current_max_display_size_ != max_display_size) {
     current_max_display_size_ = max_display_size;
     if (desktop_background_mode_ == BACKGROUND_IMAGE &&
         current_wallpaper_.get())
       UpdateWallpaper();
   }
 
   InstallDesktopController(root_window);
 }
 
-bool DesktopBackgroundController::SetDefaultWallpaper(bool is_guest) {
-  VLOG(1) << "SetDefaultWallpaper: is_guest=" << is_guest;
-  const bool use_large =
-      GetAppropriateResolution() == WALLPAPER_RESOLUTION_LARGE;
-
-  base::FilePath file_path;
-  WallpaperLayout file_layout = use_large ? WALLPAPER_LAYOUT_CENTER_CROPPED :
-      WALLPAPER_LAYOUT_CENTER;
-  int resource_id = use_large ? IDR_AURA_WALLPAPER_DEFAULT_LARGE :
-      IDR_AURA_WALLPAPER_DEFAULT_SMALL;
-  WallpaperLayout resource_layout = WALLPAPER_LAYOUT_TILE;
-
-  CommandLine* command_line = command_line_for_testing_ ?
-      command_line_for_testing_ : CommandLine::ForCurrentProcess();
-  const char* switch_name = NULL;
-  if (is_guest) {
-    switch_name = use_large ? switches::kAshGuestWallpaperLarge :
-        switches::kAshGuestWallpaperSmall;
-  } else {
-    switch_name = use_large ? switches::kAshDefaultWallpaperLarge :
-        switches::kAshDefaultWallpaperSmall;
-  }
-  file_path = command_line->GetSwitchValuePath(switch_name);
-
-  if (DefaultWallpaperIsAlreadyLoadingOrLoaded(file_path, resource_id)) {
-    VLOG(1) << "Default wallpaper is already loading or loaded";
-    return false;
-  }
-
-  CancelDefaultWallpaperLoader();
-  default_wallpaper_loader_ = new WallpaperLoader(
-      file_path, file_layout, resource_id, resource_layout);
-  base::WorkerPool::PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&WallpaperLoader::LoadOnWorkerPoolThread,
-                 default_wallpaper_loader_),
-      base::Bind(&DesktopBackgroundController::OnDefaultWallpaperLoadCompleted,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 default_wallpaper_loader_),
-      true /* task_is_slow */);
-  return true;
-}
-
 void DesktopBackgroundController::SetCustomWallpaper(
     const gfx::ImageSkia& image,
     WallpaperLayout layout) {
   VLOG(1) << "SetCustomWallpaper: image_id="
           << WallpaperResizer::GetImageId(image) << " layout=" << layout;
-  CancelDefaultWallpaperLoader();
 
   if (CustomWallpaperIsAlreadyLoaded(image)) {
     VLOG(1) << "Custom wallpaper is already loaded";
     return;
   }
 
   current_wallpaper_.reset(new WallpaperResizer(
       image, GetMaxDisplaySizeInNative(), layout));
   current_wallpaper_->StartResize();
 
-  current_default_wallpaper_path_ = base::FilePath();
-  current_default_wallpaper_resource_id_ = -1;
-
   FOR_EACH_OBSERVER(DesktopBackgroundControllerObserver, observers_,
                     OnWallpaperDataChanged());
   SetDesktopBackgroundImageMode();
 }
 
-void DesktopBackgroundController::CancelDefaultWallpaperLoader() {
-  // Set canceled flag of previous request to skip unneeded loading.
-  if (default_wallpaper_loader_.get())
-    default_wallpaper_loader_->Cancel();
-
-  // Cancel reply callback for previous request.
-  weak_ptr_factory_.InvalidateWeakPtrs();
-}
-
 void DesktopBackgroundController::CreateEmptyWallpaper() {

[Daniel Erat, 2014/03/27 01:45:50]

delete this if it's not called anymore

[Alexander Alekseev, 2014/03/31 14:15:40]

It's used by Wallpapermanager, API, DefaultDelegate.

   current_wallpaper_.reset(NULL);
   SetDesktopBackgroundImageMode();
 }
 
 WallpaperResolution DesktopBackgroundController::GetAppropriateResolution() {

[Daniel Erat, 2014/03/27 01:45:50]

delete this if you don't use it

[Alexander Alekseev, 2014/03/31 14:15:40]

It's used by Wallpapermanager (to select cached wallpaper).

   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   gfx::Size size = GetMaxDisplaySizeInNative();
   return (size.width() > kSmallWallpaperMaxWidth ||
           size.height() > kSmallWallpaperMaxHeight) ?
       WALLPAPER_RESOLUTION_LARGE : WALLPAPER_RESOLUTION_SMALL;
 }
 
 bool DesktopBackgroundController::MoveDesktopToLockedContainer() {
   if (locked_)
     return false;
@@ skipping 18 matching lines @@
         current_wallpaper_.get()) {
       timer_.Stop();
       timer_.Start(FROM_HERE,
                    base::TimeDelta::FromMilliseconds(wallpaper_reload_delay_),
                    this,
                    &DesktopBackgroundController::UpdateWallpaper);
     }
   }
 }
 
-bool DesktopBackgroundController::DefaultWallpaperIsAlreadyLoadingOrLoaded(
-    const base::FilePath& image_file,
-    int image_resource_id) const {
-  return (default_wallpaper_loader_.get() &&
-          !default_wallpaper_loader_->IsCanceled() &&
-          default_wallpaper_loader_->file_path() == image_file &&
-          default_wallpaper_loader_->resource_id() == image_resource_id) ||
-         (current_wallpaper_.get() &&
-          current_default_wallpaper_path_ == image_file &&
-          current_default_wallpaper_resource_id_ == image_resource_id);
-}
-
 bool DesktopBackgroundController::CustomWallpaperIsAlreadyLoaded(
     const gfx::ImageSkia& image) const {
   return current_wallpaper_.get() &&
       (WallpaperResizer::GetImageId(image) ==
        current_wallpaper_->original_image_id());
 }
 
 void DesktopBackgroundController::SetDesktopBackgroundImageMode() {
   desktop_background_mode_ = BACKGROUND_IMAGE;
   InstallDesktopControllerForAllWindows();
 }
 
-void DesktopBackgroundController::OnDefaultWallpaperLoadCompleted(
-    scoped_refptr<WallpaperLoader> loader) {
-  VLOG(1) << "OnDefaultWallpaperLoadCompleted";
-  current_wallpaper_.reset(loader->ReleaseWallpaperResizer());
-  current_wallpaper_->StartResize();
-  current_default_wallpaper_path_ = loader->file_path();
-  current_default_wallpaper_resource_id_ = loader->resource_id();
-  FOR_EACH_OBSERVER(DesktopBackgroundControllerObserver, observers_,
-                    OnWallpaperDataChanged());
-
-  SetDesktopBackgroundImageMode();
-
-  DCHECK(loader.get() == default_wallpaper_loader_.get());
-  default_wallpaper_loader_ = NULL;
-}
-
 void DesktopBackgroundController::InstallDesktopController(
     aura::Window* root_window) {
   internal::DesktopBackgroundWidgetController* component = NULL;
   int container_id = GetBackgroundContainerId(locked_);
 
   switch (desktop_background_mode_) {
     case BACKGROUND_IMAGE: {
       views::Widget* widget = internal::CreateDesktopBackground(root_window,
                                                                 container_id);
       component = new internal::DesktopBackgroundWidgetController(widget);
@@ skipping 57 matching lines @@
   return moved;
 }
 
 int DesktopBackgroundController::GetBackgroundContainerId(bool locked) {
   return locked ? internal::kShellWindowId_LockScreenBackgroundContainer :
                   internal::kShellWindowId_DesktopBackgroundContainer;
 }
 
 void DesktopBackgroundController::UpdateWallpaper() {
   current_wallpaper_.reset(NULL);
-  current_default_wallpaper_path_ = base::FilePath();
-  current_default_wallpaper_resource_id_ = -1;
   ash::Shell::GetInstance()->user_wallpaper_delegate()->
       UpdateWallpaper(true /* clear cache */);
 }
 
 // static
 gfx::Size DesktopBackgroundController::GetMaxDisplaySizeInNative() {
   int width = 0;
   int height = 0;
   std::vector<gfx::Display> displays = Shell::GetScreen()->GetAllDisplays();
   internal::DisplayManager* display_manager =
       Shell::GetInstance()->display_manager();
 
   for (std::vector<gfx::Display>::iterator iter = displays.begin();
        iter != displays.end(); ++iter) {
     // Don't use size_in_pixel because we want to use the native pixel size.
     gfx::Size size_in_pixel =
         display_manager->GetDisplayInfo(iter->id()).bounds_in_native().size();
     if (iter->rotation() == gfx::Display::ROTATE_90 ||
         iter->rotation() == gfx::Display::ROTATE_270) {
       size_in_pixel = gfx::Size(size_in_pixel.height(), size_in_pixel.width());
     }
     width = std::max(size_in_pixel.width(), width);
     height = std::max(size_in_pixel.height(), height);
   }
   return gfx::Size(width, height);
 }
 
 }  // namespace ash