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"
 #include "ash/desktop_background/user_wallpaper_delegate.h"
 #include "ash/desktop_background/wallpaper_resizer.h"
 #include "ash/display/display_info.h"
 #include "ash/display/display_manager.h"
 #include "ash/root_window_controller.h"
 #include "ash/shell.h"
+#include "ash/shell_delegate.h"
 #include "ash/shell_factory.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/root_window_layout_manager.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/synchronization/cancellation_flag.h"
 #include "base/threading/worker_pool.h"
 #include "content/public/browser/browser_thread.h"
@@ skipping 120 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);
 };
 
+void DesktopBackgroundController::SetDefaultWallpaperPathFromCommandLine(
+    base::CommandLine* command_line) {
+  default_small_wallpaper_file_ =
+      command_line->GetSwitchValuePath(switches::kAshDefaultWallpaperSmall);
+  default_large_wallpaper_file_ =
+      command_line->GetSwitchValuePath(switches::kAshDefaultWallpaperLarge);
+  guest_default_small_wallpaper_file_ =
+      command_line->GetSwitchValuePath(switches::kAshGuestWallpaperSmall);
+  guest_default_large_wallpaper_file_ =
+      command_line->GetSwitchValuePath(switches::kAshGuestWallpaperLarge);
+}
+
 DesktopBackgroundController::DesktopBackgroundController()
     : command_line_for_testing_(NULL),
       locked_(false),
       desktop_background_mode_(BACKGROUND_NONE),
       current_default_wallpaper_resource_id_(-1),
       weak_ptr_factory_(this),
-      wallpaper_reload_delay_(kWallpaperReloadDelayMs) {
+      wallpaper_reload_delay_(kWallpaperReloadDelayMs),
+      customization_applied_(false) {
   Shell::GetInstance()->display_controller()->AddObserver(this);
+  SetDefaultWallpaperPathFromCommandLine(
+      base::CommandLine::ForCurrentProcess());
 }
 
 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::set_command_line_for_testing(
+    base::CommandLine* command_line) {
+  command_line_for_testing_ = command_line;
+  SetDefaultWallpaperPathFromCommandLine(command_line);
+}
+
 void DesktopBackgroundController::AddObserver(
     DesktopBackgroundControllerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void DesktopBackgroundController::RemoveObserver(
     DesktopBackgroundControllerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
@@ skipping 13 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);
 }
 
+void DesktopBackgroundController::CheckForCustomization() {
+  if (customization_applied_)
+    return;
+  customization_applied_ = true;
+
+  ShellDelegate* delegate = ash::Shell::GetInstance()->delegate();

[Daniel Erat, 2014/03/24 19:24:40]

i still don't understand why this needs to go through a delegate. why can't the
chrome code just call SetDefaultWallpaperPath() directly?

i can write and upload the DesktopBackgroundController change that i was
suggesting if the previous comment was unclear.

[Alexander Alekseev, 2014/03/24 19:47:54]

To be sure that DesktopBackgroundController would never try to show
non-customized wallpaper.

Probably I do not understand the details of your idea. I see two options:

1) To move all this code to delegate->SetDefaultWallpaperPath(), which would
call SetDefaultWallpaperPath() by itself. This
requires modification of DesktopBackgroundController::SetDefaultWallpaperPath()
to support modifying paths when no wallpaper has ever been set. (So that 
SetDefaultWallpaper() should not be called).

2) To drop ShellDelegate::*Wallapper* completely and to ensure
DesktopBackgroundController::SetWallpaperPath() is called before any wallpaper
has been ever displayed. First, it requires the same modification of
DesktopBackgroundController::SetDefaultWallpaperPath(), Second, there would be
no compiled-time enforcement of wallpaper customization before first wallpaper
is shown.

I can implement any of 1) or 2) if you think it would be better than this CL.
But I think 1) would be less readable than this CL, and 2) seems to be unstable
against new modifications. So we might get into situation when we would show
command-line wallpaper first, and then customized wallpaper.

+  if (delegate->ShouldUseCustomizedDefaultWallpaper()) {
+    default_small_wallpaper_file_ =
+        delegate->GetCustomizedWallpaperDefaultRescaledSmallFileName();
+    default_large_wallpaper_file_ =
+        delegate->GetCustomizedWallpaperDefaultRescaledLargeFileName();
+    VLOG(1) << "Start with customized wallpapers: small_file_name = '"
+            << default_small_wallpaper_file_.value() << "', large_file_name = '"
+            << default_large_wallpaper_file_.value() << "'";
+  }
+}
+
 bool DesktopBackgroundController::SetDefaultWallpaper(bool is_guest) {
   VLOG(1) << "SetDefaultWallpaper: is_guest=" << is_guest;
   const bool use_large =
       GetAppropriateResolution() == WALLPAPER_RESOLUTION_LARGE;
 
+  CheckForCustomization();
+
   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;
+  if (is_guest) {
+    file_path = use_large ? guest_default_large_wallpaper_file_
+                          : guest_default_small_wallpaper_file_;
+  } else {
+    file_path = use_large ? default_large_wallpaper_file_
+                          : default_small_wallpaper_file_;
+  }
+  return DoSetDefaultWallpaper(file_path, use_large);
+}
+
+bool DesktopBackgroundController::DoSetDefaultWallpaper(
+    const base::FilePath& file_path,
+    const bool use_large) {
+  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,
@@ skipping 61 matching lines @@
 }
 
 bool DesktopBackgroundController::MoveDesktopToUnlockedContainer() {
   if (!locked_)
     return false;
   locked_ = false;
   return ReparentBackgroundWidgets(GetBackgroundContainerId(true),
                                    GetBackgroundContainerId(false));
 }
 
+void DesktopBackgroundController::SetDefaultWallpaperPath(
+    const base::FilePath& default_small_wallpaper_file,
+    const base::FilePath& default_large_wallpaper_file) {
+  customization_applied_ = true;
+  const bool need_reset = DefaultWallpaperFileIsAlreadyLoadingOrLoaded(
+                              default_small_wallpaper_file_) ||
+                          DefaultWallpaperFileIsAlreadyLoadingOrLoaded(
+                              default_large_wallpaper_file_);
+  default_small_wallpaper_file_ = default_small_wallpaper_file;
+  default_large_wallpaper_file_ = default_large_wallpaper_file;
+  if (need_reset) {
+    const bool use_large =
+        GetAppropriateResolution() == WALLPAPER_RESOLUTION_LARGE;
+    DoSetDefaultWallpaper((use_large ? default_large_wallpaper_file_
+                                     : default_small_wallpaper_file_),
+                          use_large);
+  }
+}
+
 void DesktopBackgroundController::OnDisplayConfigurationChanged() {
   gfx::Size max_display_size = GetMaxDisplaySizeInNative();
   if (current_max_display_size_ != max_display_size) {
     current_max_display_size_ = max_display_size;
     if (desktop_background_mode_ == BACKGROUND_IMAGE &&
         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::DefaultWallpaperFileIsAlreadyLoadingOrLoaded(
+    const base::FilePath& image_file) const {
+  return (default_wallpaper_loader_.get() &&
+          !default_wallpaper_loader_->IsCanceled() &&
+          default_wallpaper_loader_->file_path() == image_file) ||
+         (current_wallpaper_.get() &&
+          current_default_wallpaper_path_ == image_file);
+}
+
 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();
@@ skipping 115 matching lines @@
         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