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 15 matching lines @@
 #include "content/public/browser/browser_thread.h"
 #include "grit/ash_resources.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/widget/widget.h"
 
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/login/wallpaper_manager.h"

[Daniel Erat, 2014/03/24 16:25:48]

ash isn't allowed to depend on chrome. you need to make the chrome code call
into this class instead. see suggestions below.

[Alexander Alekseev, 2014/03/24 17:33:43]

Done.

+#endif
+
 using ash::internal::DesktopBackgroundWidgetController;
 using content::BrowserThread;
 
 namespace ash {
 namespace {
 
 // How long to wait reloading the wallpaper after the max display has
 // changed?
 const int kWallpaperReloadDelayMs = 2000;
 
@@ skipping 107 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(WallpaperLoader);
 };
 
 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);
 }
 
 DesktopBackgroundController::~DesktopBackgroundController() {
   CancelDefaultWallpaperLoader();
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
 gfx::ImageSkia DesktopBackgroundController::GetWallpaper() const {
   if (current_wallpaper_)
@@ skipping 27 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 defined(OS_CHROMEOS)
+  if (customization_applied_)
+    return;
+  customization_applied_ = true;
+
+  if (chromeos::WallpaperManager::ShouldUseCustomizedDefaultWallpaper()) {
+    customized_default_wallpaper_file_small_ = chromeos::WallpaperManager::
+        GetCustomizedWallpaperDefaultRescaledSmallFileName();
+    customized_default_wallpaper_file_large_ = chromeos::WallpaperManager::
+        GetCustomizedWallpaperDefaultRescaledLargeFileName();
+    VLOG(1) << "Start with customized wallpapers: small_file_name = '"
+            << customized_default_wallpaper_file_small_.value()
+            << "', large_file_name = '"
+            << customized_default_wallpaper_file_large_.value() << "'";
+  }
+#endif
+}
+
 bool DesktopBackgroundController::SetDefaultWallpaper(bool is_guest) {
   VLOG(1) << "SetDefaultWallpaper: is_guest=" << is_guest;
   const bool use_large =
       GetAppropriateResolution() == WALLPAPER_RESOLUTION_LARGE;
+  CommandLine* command_line = command_line_for_testing_ ?
+      command_line_for_testing_ : CommandLine::ForCurrentProcess();
+
+  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) {
+    const char* switch_name = use_large ? switches::kAshGuestWallpaperLarge
+                                        : switches::kAshGuestWallpaperSmall;
+    file_path = command_line->GetSwitchValuePath(switch_name);
+  } else if (use_large && !customized_default_wallpaper_file_large_.empty()) {
+    file_path = customized_default_wallpaper_file_large_;
+  } else if (!use_large && !customized_default_wallpaper_file_small_.empty()) {
+    file_path = customized_default_wallpaper_file_small_;
+  } else {
+    const char* switch_name = use_large ? switches::kAshDefaultWallpaperLarge
+                                        : switches::kAshDefaultWallpaperSmall;
+    file_path = command_line->GetSwitchValuePath(switch_name);
+  }
+  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,
       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::SetDefaultWallpaperPath(
+    const base::FilePath& customized_default_wallpaper_file_small,
+    const base::FilePath& customized_default_wallpaper_file_large) {
+  customization_applied_ = true;
+  const bool need_reset = DefaultWallpaperFileIsAlreadyLoadingOrLoaded(
+                              customized_default_wallpaper_file_small_) ||
+                          DefaultWallpaperFileIsAlreadyLoadingOrLoaded(
+                              customized_default_wallpaper_file_large_);

[Daniel Erat, 2014/03/24 16:25:48]

why is all this stuff necessary? does the following simpler approach work?

- add default_small_wallpaper_path_ and default_large_wallpaper_path_ members
- initialize them to the values from the flags in the c'tor
- make SetDefaultWallpaperPath() just update the members and call
SetDefaultWallpaper()
- make SetDefaultWallpaper() use the members instead of checking the switches
and leave it otherwise unchanged

[Alexander Alekseev, 2014/03/24 17:33:43]

Done.

+  customized_default_wallpaper_file_small_ =
+      customized_default_wallpaper_file_small;
+  customized_default_wallpaper_file_large_ =
+      customized_default_wallpaper_file_large;
+  if (need_reset) {
+    const bool use_large =
+        GetAppropriateResolution() == WALLPAPER_RESOLUTION_LARGE;
+    DoSetDefaultWallpaper(
+        (use_large ? customized_default_wallpaper_file_large_
+                   : customized_default_wallpaper_file_small_),
+        use_large);
+  }
+}
+
 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;
@@ skipping 69 matching lines @@
     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 {

[Daniel Erat, 2014/03/24 16:25:48]

why do you need this method? it looks like it's mostly a copy-and-paste of the
existing method.

[Alexander Alekseev, 2014/03/24 17:33:43]

I need to detect the usage of default wallpaper regardless of the layout. Would
you prefer to add additional parameter to existing method
DefaultWallpaperIsAlreadyLoadingOrLoaded() to ignore resource_id?

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

resource_id is just a fallback that we use if we can't load the image off of the
disk, i think. i don't understand what you mean about the layout -- it looks
like it's always WALLPAPER_LAYOUT_TILE for the resource.

[Alexander Alekseev, 2014/03/24 19:52:58]

bool DesktopBackgroundController::DoSetDefaultWallpaper() :
...
  int resource_id = use_large ? IDR_AURA_WALLPAPER_DEFAULT_LARGE                

                              : IDR_AURA_WALLPAPER_DEFAULT_SMALL;  
...

Sorry, I do not know most of this code (may be resource_id check can be dropped
from existing method). I only wanted not to call
DefaultWallpaperIsAlreadyLoadingOrLoaded() twice with different resource_id . 

+  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