ash: Avoid reloading already-resized custom wallpaper.

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 102 matching lines @@
       return;
 
     if (!file_path_.empty())
       file_bitmap_ = LoadSkBitmapFromJPEGFile(file_path_);
 
     if (cancel_flag_.IsSet())
       return;
 
     if (file_bitmap_) {
       gfx::ImageSkia image = gfx::ImageSkia::CreateFrom1xBitmap(*file_bitmap_);
+      image.MakeThreadSafe();
       wallpaper_resizer_.reset(new WallpaperResizer(
           image, GetMaxDisplaySizeInNative(), file_layout_));
     } else {
       wallpaper_resizer_.reset(new WallpaperResizer(
           resource_id_, GetMaxDisplaySizeInNative(), resource_layout_));
     }
   }
 
   ~WallpaperLoader() {}
 
@@ skipping 29 matching lines @@
   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 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;
 }
 
 void DesktopBackgroundController::OnRootWindowAdded(
     aura::Window* 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_ &&
+  if (desktop_background_mode_ == BACKGROUND_IMAGE &&
       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) {
@@ skipping 87 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) {
+  if (desktop_background_mode_ == BACKGROUND_IMAGE &&
+      current_wallpaper_.get() &&
+      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);
 }
 
 bool DesktopBackgroundController::CustomWallpaperIsAlreadyLoaded(
     const gfx::ImageSkia& image) const {
   return current_wallpaper_.get() &&
-      current_wallpaper_->wallpaper_image().BackedBySameObjectAs(image);
+      (WallpaperResizer::GetImageId(image) ==
+       current_wallpaper_->original_image_id());
 }
 
 void DesktopBackgroundController::SetDesktopBackgroundImageMode() {
   desktop_background_mode_ = BACKGROUND_IMAGE;
   InstallDesktopControllerForAllWindows();
 }
 
 void DesktopBackgroundController::OnDefaultWallpaperLoadCompleted(
     scoped_refptr<WallpaperLoader> loader) {
   current_wallpaper_.reset(loader->ReleaseWallpaperResizer());
@@ skipping 109 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