ash: Avoid reloading already-resized custom wallpaper.

ash/desktop_background/wallpaper_resizer.cc

 // Copyright (c) 2013 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/wallpaper_resizer.h"
 
 #include "ash/desktop_background/wallpaper_resizer_observer.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/worker_pool.h"
 #include "content/public/browser/browser_thread.h"
+#include "third_party/skia/include/core/SkImage.h"
 #include "ui/base/resource/resource_bundle.h"
+#include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/skia_util.h"
 
 using content::BrowserThread;
 
 namespace ash {
 namespace {
 
 // For our scaling ratios we need to round positive numbers.
 int RoundPositive(double x) {
   return static_cast<int>(floor(x + 0.5));
@@ skipping 60 matching lines @@
         }
     }
   }
 
   *resized_bitmap_out = new_bitmap;
   resized_bitmap_out->setImmutable();
 }
 
 }  // namespace
 
+// static
+uint32_t WallpaperResizer::GetImageId(const gfx::ImageSkia& image) {
+  const gfx::ImageSkiaRep& image_rep = image.GetRepresentation(1.0f);

[Daniel Erat, 2013/11/22 15:33:20]

Oshima, can you comment on whether I'm doing the right thing with all of the
ImageSkia::MakeThreadSafe() calls that I'm adding to this code? Without them,
this GetRepresentation() call appears to result in failed "image_skia.cc(403)]
Check failed: CanRead()." asserts later when I run tests -- see e.g.
http://build.chromium.org/p/tryserver.chromium/builders/linux_chromeos/builds....

These images _are_ getting accessed from multiple threads (e.g. we first find
the generation ID on the browser thread, then resize the image on the blocking
pool, and then create a new image based on the resized data on the browser
thread again.

I think that the MakeThreadSafe() call in OnResizeFinished() may be extraneous
(since the resized image should only be accessed from the browser thread); I'll
try removing it.

+  return image_rep.is_null() ? 0 : image_rep.sk_bitmap().getGenerationID();
+}
+
 WallpaperResizer::WallpaperResizer(int image_resource_id,
                                    const gfx::Size& target_size,
                                    WallpaperLayout layout)
-    : wallpaper_image_(*(ui::ResourceBundle::GetSharedInstance().
+    : image_(*(ui::ResourceBundle::GetSharedInstance().
           GetImageNamed(image_resource_id).ToImageSkia())),
+      original_image_id_(GetImageId(image_)),
       target_size_(target_size),
       layout_(layout),
       weak_ptr_factory_(this) {
+  image_.MakeThreadSafe();
 }
 
 WallpaperResizer::WallpaperResizer(const gfx::ImageSkia& image,
                                    const gfx::Size& target_size,
                                    WallpaperLayout layout)
-    : wallpaper_image_(image),
+    : image_(image),
+      original_image_id_(GetImageId(image_)),
       target_size_(target_size),
       layout_(layout),
       weak_ptr_factory_(this) {
 }
 
 WallpaperResizer::~WallpaperResizer() {
 }
 
 void WallpaperResizer::StartResize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   SkBitmap* resized_bitmap = new SkBitmap;
   if (!content::BrowserThread::PostBlockingPoolTaskAndReply(
           FROM_HERE,
-          base::Bind(&Resize, *wallpaper_image_.bitmap(), target_size_,
+          base::Bind(&Resize, *image_.bitmap(), target_size_,
                      layout_, resized_bitmap),
           base::Bind(&WallpaperResizer::OnResizeFinished,
                      weak_ptr_factory_.GetWeakPtr(),
                      base::Owned(resized_bitmap)))) {
     LOG(WARNING) << "PostSequencedWorkerTask failed. "
                  << "Wallpaper may not be resized.";
   }
 }
 
 void WallpaperResizer::AddObserver(WallpaperResizerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WallpaperResizer::RemoveObserver(WallpaperResizerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WallpaperResizer::OnResizeFinished(SkBitmap* resized_bitmap) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  wallpaper_image_ = gfx::ImageSkia::CreateFrom1xBitmap(*resized_bitmap);
+  image_ = gfx::ImageSkia::CreateFrom1xBitmap(*resized_bitmap);
+  image_.MakeThreadSafe();
   FOR_EACH_OBSERVER(WallpaperResizerObserver, observers_,
                     OnWallpaperResized());
 }
 
 } // namespace ash