Reload wallpaper when display configuration changes.

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 21 matching lines @@
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/rect.h"
 #include "ui/views/widget/widget.h"
 
 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;
+
 const SkColor kTransparentColor = SkColorSetARGB(0x00, 0x00, 0x00, 0x00);
 
 internal::RootWindowLayoutManager* GetRootWindowLayoutManager(
     aura::RootWindow* root_window) {
   return static_cast<internal::RootWindowLayoutManager*>(
       root_window->layout_manager());
 }
 
 }  // namespace
 
@@ skipping 102 matching lines @@
   WallpaperLayout resource_layout_;
 
   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) {
+      weak_ptr_factory_(this),
+      wallpaper_reload_delay_(kWallpaperReloadDelayMs) {
+  Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 DesktopBackgroundController::~DesktopBackgroundController() {
   CancelPendingWallpaperOperation();
+  Shell::GetInstance()->display_controller()->RemoveObserver(this);
 }
 
 gfx::ImageSkia DesktopBackgroundController::GetWallpaper() const {
   if (current_wallpaper_)
     return current_wallpaper_->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;
 }
 
 void DesktopBackgroundController::OnRootWindowAdded(
     aura::RootWindow* root_window) {
   // The background hasn't been set yet.
   if (desktop_background_mode_ == BACKGROUND_NONE)
     return;
-
+  gfx::Size max_display_size = GetMaxDisplaySizeInNative();
   // Handle resolution change for "built-in" images.
   if (BACKGROUND_IMAGE == desktop_background_mode_ &&
-      current_wallpaper_.get()) {
-    gfx::Size root_window_size = root_window->GetHostSize();
-    int width = current_wallpaper_->wallpaper_image().width();
-    int height = current_wallpaper_->wallpaper_image().height();
-    // Reloads wallpaper if current wallpaper is smaller than the new added root
-    // window.
-    if (width < root_window_size.width() ||
-        height < root_window_size.height()) {
-      current_wallpaper_.reset(NULL);
-      current_default_wallpaper_path_ = base::FilePath();
-      current_default_wallpaper_resource_id_ = -1;
-      ash::Shell::GetInstance()->user_wallpaper_delegate()->
-          UpdateWallpaper();
-    }
+      current_wallpaper_.get() &&
+      current_max_display_size_ != max_display_size) {
+    current_max_display_size_ = max_display_size;
+    UpdateWallpaper();
   }
 
   InstallDesktopController(root_window);
 }
 
 bool DesktopBackgroundController::SetDefaultWallpaper(bool is_guest) {
   const bool use_large =
       GetAppropriateResolution() == WALLPAPER_RESOLUTION_LARGE;
 
   base::FilePath file_path;
@@ skipping 78 matching lines @@
 }
 
 bool DesktopBackgroundController::MoveDesktopToUnlockedContainer() {
   if (!locked_)
     return false;
   locked_ = false;
   return ReparentBackgroundWidgets(GetBackgroundContainerId(true),
                                    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;
+    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 (wallpaper_loader_.get() &&
           wallpaper_loader_->file_path() == image_file &&
           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 45 matching lines @@
 
   component->StartAnimating(internal::GetRootWindowController(root_window));
 }
 
 void DesktopBackgroundController::InstallDesktopControllerForAllWindows() {
   Shell::RootWindowList root_windows = Shell::GetAllRootWindows();
   for (Shell::RootWindowList::iterator iter = root_windows.begin();
        iter != root_windows.end(); ++iter) {
     InstallDesktopController(*iter);
   }
+  current_max_display_size_ = GetMaxDisplaySizeInNative();
 }
 
 bool DesktopBackgroundController::ReparentBackgroundWidgets(int src_container,
                                                             int dst_container) {
   bool moved = false;
   Shell::RootWindowControllerList controllers =
       Shell::GetAllRootWindowControllers();
   for (Shell::RootWindowControllerList::iterator iter = controllers.begin();
     iter != controllers.end(); ++iter) {
     internal::RootWindowController* root_window_controller = *iter;
@@ skipping 25 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();
+}
+
 // 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