ash: Fix DesktopBackgroundController getting stuck.

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 52 matching lines @@
   WallpaperLoader(const base::FilePath& file_path,
                   WallpaperLayout file_layout,
                   int resource_id,
                   WallpaperLayout resource_layout)
       : file_path_(file_path),
         file_layout_(file_layout),
         resource_id_(resource_id),
         resource_layout_(resource_layout) {
   }
 
-  static void LoadOnWorkerPoolThread(scoped_refptr<WallpaperLoader> loader) {

[Daniel Erat, 2013/12/26 20:52:00]

i don't know why this was a static method; making it be an instance method
instead

+  void LoadOnWorkerPoolThread() {
     DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
-    loader->LoadWallpaper();
+    if (cancel_flag_.IsSet())
+      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_);
+      wallpaper_resizer_.reset(new WallpaperResizer(
+          image, GetMaxDisplaySizeInNative(), file_layout_));
+    } else {
+      wallpaper_resizer_.reset(new WallpaperResizer(
+          resource_id_, GetMaxDisplaySizeInNative(), resource_layout_));
+    }
   }
 
   const base::FilePath& file_path() const { return file_path_; }
   int resource_id() const { return resource_id_; }
 
   void Cancel() {
     cancel_flag_.Set();
   }
 
+  bool IsCanceled() {
+    return cancel_flag_.IsSet();
+  }
+
   WallpaperResizer* ReleaseWallpaperResizer() {
     return wallpaper_resizer_.release();
   }
 
  private:
   friend class base::RefCountedThreadSafe<
       DesktopBackgroundController::WallpaperLoader>;
 
   // Loads a JPEG image from |path|, a trusted file -- note that the image
   // is not loaded in a sandboxed process. Returns an empty pointer on
   // error.
   static scoped_ptr<SkBitmap> LoadSkBitmapFromJPEGFile(
       const base::FilePath& path) {
     std::string data;
     if (!base::ReadFileToString(path, &data)) {
       LOG(ERROR) << "Unable to read data from " << path.value();
       return scoped_ptr<SkBitmap>();
     }
 
     scoped_ptr<SkBitmap> bitmap(gfx::JPEGCodec::Decode(
         reinterpret_cast<const unsigned char*>(data.data()), data.size()));
     if (!bitmap)
       LOG(ERROR) << "Unable to decode JPEG data from " << path.value();
     return bitmap.Pass();
   }
 
-  void LoadWallpaper() {
-    if (cancel_flag_.IsSet())
-      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_);
-      wallpaper_resizer_.reset(new WallpaperResizer(
-          image, GetMaxDisplaySizeInNative(), file_layout_));
-    } else {
-      wallpaper_resizer_.reset(new WallpaperResizer(
-          resource_id_, GetMaxDisplaySizeInNative(), resource_layout_));
-    }
-  }
-
   ~WallpaperLoader() {}
 
   base::CancellationFlag cancel_flag_;
 
   // Bitmap loaded from |file_path_|.
   scoped_ptr<SkBitmap> file_bitmap_;
 
   scoped_ptr<WallpaperResizer> wallpaper_resizer_;
 
   // Path to a trusted JPEG file.
@@ skipping 15 matching lines @@
     : 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) {
   Shell::GetInstance()->display_controller()->AddObserver(this);
 }
 
 DesktopBackgroundController::~DesktopBackgroundController() {
-  CancelPendingWallpaperOperation();
+  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(
@@ skipping 48 matching lines @@
         switches::kAshGuestWallpaperSmall;
   } else {
     switch_name = use_large ? switches::kAshDefaultWallpaperLarge :
         switches::kAshDefaultWallpaperSmall;
   }
   file_path = command_line->GetSwitchValuePath(switch_name);
 
   if (DefaultWallpaperIsAlreadyLoadingOrLoaded(file_path, resource_id))
     return false;
 
-  CancelPendingWallpaperOperation();
-  wallpaper_loader_ = new WallpaperLoader(
+  CancelDefaultWallpaperLoader();
+  default_wallpaper_loader_ = new WallpaperLoader(
       file_path, file_layout, resource_id, resource_layout);
   base::WorkerPool::PostTaskAndReply(
       FROM_HERE,
-      base::Bind(&WallpaperLoader::LoadOnWorkerPoolThread, wallpaper_loader_),
+      base::Bind(&WallpaperLoader::LoadOnWorkerPoolThread,
+                 default_wallpaper_loader_),
       base::Bind(&DesktopBackgroundController::OnDefaultWallpaperLoadCompleted,
                  weak_ptr_factory_.GetWeakPtr(),
-                 wallpaper_loader_),
+                 default_wallpaper_loader_),
       true /* task_is_slow */);
   return true;
 }
 
 void DesktopBackgroundController::SetCustomWallpaper(
     const gfx::ImageSkia& image,
     WallpaperLayout layout) {
-  CancelPendingWallpaperOperation();
+  CancelDefaultWallpaperLoader();
+
   if (CustomWallpaperIsAlreadyLoaded(image))
     return;
 
   current_wallpaper_.reset(new WallpaperResizer(
       image, GetMaxDisplaySizeInNative(), layout));
   current_wallpaper_->StartResize();
 
   current_default_wallpaper_path_ = base::FilePath();
   current_default_wallpaper_resource_id_ = -1;
 
   FOR_EACH_OBSERVER(DesktopBackgroundControllerObserver, observers_,
                     OnWallpaperDataChanged());
   SetDesktopBackgroundImageMode();
 }
 
-void DesktopBackgroundController::CancelPendingWallpaperOperation() {
+void DesktopBackgroundController::CancelDefaultWallpaperLoader() {
   // Set canceled flag of previous request to skip unneeded loading.
-  if (wallpaper_loader_.get())
-    wallpaper_loader_->Cancel();
+  if (default_wallpaper_loader_.get())
+    default_wallpaper_loader_->Cancel();
 
   // Cancel reply callback for previous request.
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void DesktopBackgroundController::CreateEmptyWallpaper() {
   current_wallpaper_.reset(NULL);
   SetDesktopBackgroundImageMode();
 }
 
@@ skipping 30 matching lines @@
       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) ||
+    const base::FilePath& image_file,
+    int image_resource_id) const {
+  return (default_wallpaper_loader_.get() &&
+          !default_wallpaper_loader_->IsCanceled() &&

[Daniel Erat, 2013/12/26 20:52:00]

this is the fix

+          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::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();
 }
 
 void DesktopBackgroundController::OnDefaultWallpaperLoadCompleted(
     scoped_refptr<WallpaperLoader> loader) {
   current_wallpaper_.reset(loader->ReleaseWallpaperResizer());
   current_wallpaper_->StartResize();
   current_default_wallpaper_path_ = loader->file_path();
   current_default_wallpaper_resource_id_ = loader->resource_id();
   FOR_EACH_OBSERVER(DesktopBackgroundControllerObserver, observers_,
                     OnWallpaperDataChanged());
 
   SetDesktopBackgroundImageMode();
 
-  DCHECK(loader.get() == wallpaper_loader_.get());
-  wallpaper_loader_ = NULL;
+  DCHECK(loader.get() == default_wallpaper_loader_.get());
+  default_wallpaper_loader_ = NULL;
 }
 
 void DesktopBackgroundController::InstallDesktopController(
     aura::Window* root_window) {
   internal::DesktopBackgroundWidgetController* component = NULL;
   int container_id = GetBackgroundContainerId(locked_);
 
   switch (desktop_background_mode_) {
     case BACKGROUND_IMAGE: {
       views::Widget* widget = internal::CreateDesktopBackground(root_window,
@@ skipping 89 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