mash: Migrate wallpaper controllers to ash/common.

components/wallpaper/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 "components/wallpaper/wallpaper_resizer.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "base/threading/worker_pool.h"
+#include "base/task_runner.h"
 #include "components/wallpaper/wallpaper_resizer_observer.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "ui/gfx/image/image_skia_rep.h"
 #include "ui/gfx/skia_util.h"
 
-using base::SequencedWorkerPool;
-
 namespace wallpaper {
 namespace {
 
 // For our scaling ratios we need to round positive numbers.
 int RoundPositive(double x) {
   return static_cast<int>(floor(x + 0.5));
 }
 
 // Resizes |orig_bitmap| to |target_size| using |layout| and stores the
 // resulting bitmap at |resized_bitmap_out|.
 void Resize(SkBitmap orig_bitmap,
             const gfx::Size& target_size,
             WallpaperLayout layout,
             SkBitmap* resized_bitmap_out,
-            SequencedWorkerPool* worker_pool) {
-  DCHECK(worker_pool->RunsTasksOnCurrentThread());
+            base::TaskRunner* task_runner) {
+  DCHECK(task_runner->RunsTasksOnCurrentThread());
   SkBitmap new_bitmap = orig_bitmap;
 
   const int orig_width = orig_bitmap.width();
   const int orig_height = orig_bitmap.height();
   const int new_width = target_size.width();
   const int new_height = target_size.height();
 
   if (orig_width > new_width || orig_height > new_height) {
     gfx::Rect wallpaper_rect(0, 0, orig_width, orig_height);
     gfx::Size cropped_size = gfx::Size(std::min(new_width, orig_width),
@@ skipping 55 matching lines @@
 
 // static
 uint32_t WallpaperResizer::GetImageId(const gfx::ImageSkia& image) {
   const gfx::ImageSkiaRep& image_rep = image.GetRepresentation(1.0f);
   return image_rep.is_null() ? 0 : image_rep.sk_bitmap().getGenerationID();
 }
 
 WallpaperResizer::WallpaperResizer(const gfx::ImageSkia& image,
                                    const gfx::Size& target_size,
                                    WallpaperLayout layout,
-                                   base::SequencedWorkerPool* worker_pool_ptr)
+                                   base::TaskRunner* task_runner)
     : image_(image),
       original_image_id_(GetImageId(image_)),
       target_size_(target_size),
       layout_(layout),
-      worker_pool_(worker_pool_ptr),
+      task_runner_(task_runner),
       weak_ptr_factory_(this) {
   image_.MakeThreadSafe();
 }
 
 WallpaperResizer::~WallpaperResizer() {
 }
 
 void WallpaperResizer::StartResize() {
   SkBitmap* resized_bitmap = new SkBitmap;
-  scoped_refptr<SequencedWorkerPool> worker_pool_refptr(worker_pool_);
-  if (!worker_pool_->PostTaskAndReply(
+  scoped_refptr<base::TaskRunner> task_runner_refptr(task_runner_);

[James Cook, 2016/09/07 21:27:05]

I see you haven't changed this, but just for my knowledge... Is this a common
pattern with refptrs? It seems odd that we cache a raw pointer in |task_runner_|
then turn around later and make a refptr out of it to bump its refcount during
the task processing. It kinda seems like either the pointer should outline
WallpaperResizer, and hence shouldn't need refcounting, or it should be stored
in a refptr member variable.

[msw, 2016/09/07 22:28:24]

I'm also not too familiar with this pattern or the reasoning behind it;
WallpaperResizer is very short lived and should outlive the task runner, so your
suggestion makes sense. I gave it a shot.

+  if (!task_runner_->PostTaskAndReply(
           FROM_HERE,
           base::Bind(&Resize, *image_.bitmap(), target_size_, layout_,
-                     resized_bitmap, base::RetainedRef(worker_pool_refptr)),
+                     resized_bitmap, base::RetainedRef(task_runner_refptr)),
           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) {
   image_ = gfx::ImageSkia::CreateFrom1xBitmap(*resized_bitmap);
   FOR_EACH_OBSERVER(WallpaperResizerObserver, observers_, OnWallpaperResized());
 }
 
 }  // namespace wallpaper