ABANDONED: ash: Support changing default wallpaper at runtime.

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 137 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) {
+      wallpaper_reload_delay_(
+          base::TimeDelta::FromMilliseconds(kWallpaperReloadDelayMs)) {
   Shell::GetInstance()->display_controller()->AddObserver(this);
+  InitWallpaperPathsFromCommandLine(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::AddObserver(
     DesktopBackgroundControllerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void DesktopBackgroundController::RemoveObserver(
     DesktopBackgroundControllerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 WallpaperLayout DesktopBackgroundController::GetWallpaperLayout() const {
   if (current_wallpaper_)
     return current_wallpaper_->layout();
   return WALLPAPER_LAYOUT_CENTER_CROPPED;
 }
 
+gfx::ImageSkia DesktopBackgroundController::GetWallpaper() const {
+  if (current_wallpaper_)
+    return current_wallpaper_->image();
+  return gfx::ImageSkia();
+}
+
 void DesktopBackgroundController::OnRootWindowAdded(aura::Window* root_window) {
   // The background hasn't been set yet.
   if (desktop_background_mode_ == BACKGROUND_NONE)
     return;
 
   // Handle resolution change for "built-in" images.
   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())
       UpdateWallpaper();
   }
 
   InstallDesktopController(root_window);
 }
 
+void DesktopBackgroundController::InitWallpaperPathsFromCommandLine(
+    base::CommandLine* cl) {
+  small_default_wallpaper_path_ =
+      cl->GetSwitchValuePath(switches::kAshDefaultWallpaperSmall);
+  large_default_wallpaper_path_ =
+      cl->GetSwitchValuePath(switches::kAshDefaultWallpaperLarge);
+  small_guest_wallpaper_path_ =
+      cl->GetSwitchValuePath(switches::kAshGuestWallpaperSmall);
+  large_guest_wallpaper_path_ =
+      cl->GetSwitchValuePath(switches::kAshGuestWallpaperLarge);
+}
+
+void DesktopBackgroundController::SetDefaultWallpaperPaths(
+    const base::FilePath& small_path,
+    const base::FilePath& large_path,
+    bool is_guest) {
+  base::FilePath old_path;
+  WallpaperLayout old_layout;
+  GetDefaultWallpaperInfo(is_guest, &old_path, &old_layout, NULL, NULL);

[Alexander Alekseev, 2014/03/24 23:04:12]

This call returns "Future wallpaper parameters, that would be applied if a call
to SetDefaultWallpaper() is done".
First of all, it depends on "flacky" GetAppropriateResolution() (because another
monitor could be attached and electrical connector could be unstable).

[Daniel Erat, 2014/03/24 23:12:05]

"first of all" -> is this the only concern?

is your concern that there could be a previously-scheduled call to
DesktopBackgroundController::UpdateWallpaper() still pending? we could cache the
current small/large status and use that in GetDefaultWallpaperInfo() instead of
re-checking the display size there.

+
+  small_default_wallpaper_path_ = small_path;
+  large_default_wallpaper_path_ = large_path;

[Alexander Alekseev, 2014/03/24 23:04:12]

if (is_guest) {
...
} else {
...
}

?

[Daniel Erat, 2014/03/24 23:12:05]

do you need to override the default guest wallpaper? we don't allow it to be
customized by OEMs currently, so i was planning to make this method just be used
to change the non-guest default wallpaper.

+
+  // If the default was previously in use, update it.
+  if (DefaultWallpaperIsAlreadyLoadingOrLoaded(old_path, old_layout))
+    SetDefaultWallpaper(is_guest);
+}
+
 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);
+  int resource_id;
+  WallpaperLayout file_layout, resource_layout;
+  GetDefaultWallpaperInfo(
+      is_guest, &file_path, &file_layout, &resource_id, &resource_layout);
 
   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(
@@ skipping 69 matching lines @@
                                    GetBackgroundContainerId(false));
 }
 
 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,
+      timer_.Start(FROM_HERE, wallpaper_reload_delay_, this,
                    &DesktopBackgroundController::UpdateWallpaper);
     }
   }
 }
 
+void DesktopBackgroundController::GetDefaultWallpaperInfo(
+    bool is_guest,
+    base::FilePath* file_path,
+    WallpaperLayout* file_layout,
+    int* resource_id,
+    WallpaperLayout* resource_layout) {
+  const bool use_large =
+      GetAppropriateResolution() == WALLPAPER_RESOLUTION_LARGE;
+
+  if (file_path) {
+    if (is_guest) {
+      *file_path = use_large ? large_guest_wallpaper_path_ :
+          small_guest_wallpaper_path_;
+    } else {
+      *file_path = use_large ? large_default_wallpaper_path_ :
+          small_default_wallpaper_path_;
+    }
+  }
+  if (file_layout) {
+    *file_layout = use_large ? WALLPAPER_LAYOUT_CENTER_CROPPED :
+        WALLPAPER_LAYOUT_CENTER;
+  }
+
+  if (resource_id) {
+    *resource_id = use_large ? IDR_AURA_WALLPAPER_DEFAULT_LARGE :
+        IDR_AURA_WALLPAPER_DEFAULT_SMALL;
+  }
+  if (resource_layout)
+    *resource_layout = WALLPAPER_LAYOUT_TILE;
+}
+
 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);
@@ skipping 127 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