[Large Icon Service] Move icon resizing into worker thread.

components/favicon/core/large_icon_service.cc

 // Copyright 2015 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/favicon/core/large_icon_service.h"
 
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
+#include "base/task_runner.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "components/favicon/core/favicon_service.h"
 #include "components/favicon_base/fallback_icon_style.h"
-#include "components/favicon_base/favicon_types.h"
+#include "content/public/browser/browser_thread.h"
 #include "skia/ext/image_operations.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/geometry/size.h"
 
+namespace {
+
+}  // namespace
+
 namespace favicon {
 
-LargeIconService::LargeIconService(FaviconService* favicon_service)
-    : favicon_service_(favicon_service) {
-  large_icon_types_.push_back(favicon_base::IconType::FAVICON);
-  large_icon_types_.push_back(favicon_base::IconType::TOUCH_ICON);
-  large_icon_types_.push_back(favicon_base::IconType::TOUCH_PRECOMPOSED_ICON);
+LargeIconService::Session::Session(
+    int min_source_size_in_pixel,
+    int desired_size_in_pixel,
+    favicon_base::LargeIconCallback callback,
+    scoped_refptr<base::TaskRunner> background_task_runner,
+    base::CancelableTaskTracker* tracker)
+    : min_source_size_in_pixel_(min_source_size_in_pixel),
+      desired_size_in_pixel_(desired_size_in_pixel),
+      callback_(callback),
+      background_task_runner_(background_task_runner),
+      caller_task_runner_(base::MessageLoop::current()->task_runner()),
+      tracker_(tracker) {
 }
 
-LargeIconService::~LargeIconService() {
+LargeIconService::Session::~Session() {
 }
 
-base::CancelableTaskTracker::TaskId
-    LargeIconService::GetLargeIconOrFallbackStyle(
-        const GURL& page_url,
-        int min_source_size_in_pixel,
-        int desired_size_in_pixel,
-        const favicon_base::LargeIconCallback& callback,
-        base::CancelableTaskTracker* tracker) {
-  DCHECK_LE(1, min_source_size_in_pixel);
-  DCHECK_LE(0, desired_size_in_pixel);
-
-  // TODO(beaudoin): For now this is just a wrapper around
-  //   GetLargestRawFaviconForPageURL. Add the logic required to select the best
-  //   possible large icon. Also add logic to fetch-on-demand when the URL of
-  //   a large icon is known but its bitmap is not available.
-  return favicon_service_->GetLargestRawFaviconForPageURL(
-      page_url,
-      large_icon_types_,
-      std::max(min_source_size_in_pixel, desired_size_in_pixel),
-      base::Bind(&LargeIconService::RunLargeIconCallback,
-                 base::Unretained(this), callback, min_source_size_in_pixel,
-                 desired_size_in_pixel),
-      tracker);
+void LargeIconService::Session::OnIconLookupComplete(
+    const favicon_base::FaviconRawBitmapResult& bitmap_result) {
+  bitmap_result_ = bitmap_result;
+  tracker_->PostTask(
+      background_task_runner_.get(), FROM_HERE,
+      base::Bind(&LargeIconService::Session::ProcessIconOnBackgroundThread,
+                 this));

[pkotwicz, 2015/05/11 14:35:08]

Shouldn't you use CancelableTaskTracker::PostTaskAndReply()

[huangs, 2015/05/11 15:20:39]

Nice! Done.

 }
 
-bool LargeIconService::ResizeLargeIconIfValid(
+void LargeIconService::Session::ProcessIconOnBackgroundThread() {
+  favicon_base::FaviconRawBitmapResult resized_bitmap_result;
+  if (ResizeLargeIconOnBackgroundThreadIfValid(min_source_size_in_pixel_,
+          desired_size_in_pixel_, bitmap_result_, &resized_bitmap_result)) {
+    result_.reset(
+        new favicon_base::LargeIconResult(resized_bitmap_result));
+  } else {
+    // Failed to resize |bitmap_result|, so compute fallback icon style.
+    scoped_ptr<favicon_base::FallbackIconStyle> fallback_icon_style(
+        new favicon_base::FallbackIconStyle());
+    if (bitmap_result_.is_valid()) {
+      favicon_base::SetDominantColorAsBackground(
+          bitmap_result_.bitmap_data, fallback_icon_style.get());
+    }
+    result_.reset(
+        new favicon_base::LargeIconResult(fallback_icon_style.release()));
+  }
+
+  // Should not use |tracker_|, which should only be used in the caller thread.
+  caller_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&LargeIconService::Session::OnIconProcessingComplete, this));
+}
+
+// static
+bool LargeIconService::Session::ResizeLargeIconOnBackgroundThreadIfValid(
     int min_source_size_in_pixel,
     int desired_size_in_pixel,
     const favicon_base::FaviconRawBitmapResult& bitmap_result,
     favicon_base::FaviconRawBitmapResult* resized_bitmap_result) {
   // Require bitmap to be valid and square.
   if (!bitmap_result.is_valid() ||
       bitmap_result.pixel_size.width() != bitmap_result.pixel_size.height())
     return false;
 
   // Require bitmap to be large enough. It's square, so just check width.
@@ skipping 21 matching lines @@
   if (!gfx::PNGCodec::EncodeBGRASkBitmap(resized_bitmap, false, &bitmap_data))
     return false;
 
   resized_bitmap_result->pixel_size =
       gfx::Size(desired_size_in_pixel, desired_size_in_pixel);
   resized_bitmap_result->bitmap_data =
       base::RefCountedBytes::TakeVector(&bitmap_data);
   return true;
 }
 
-void LargeIconService::RunLargeIconCallback(
-    const favicon_base::LargeIconCallback& callback,
-    int min_source_size_in_pixel,
-    int desired_size_in_pixel,
-    const favicon_base::FaviconRawBitmapResult& bitmap_result) {
-  favicon_base::FaviconRawBitmapResult resized_bitmap_result;
-  if (ResizeLargeIconIfValid(min_source_size_in_pixel, desired_size_in_pixel,
-                             bitmap_result, &resized_bitmap_result)) {
-    callback.Run(favicon_base::LargeIconResult(resized_bitmap_result));
-    return;
-  }
+void LargeIconService::Session::OnIconProcessingComplete() {
+  callback_.Run(*result_);
+}
 
-  // Failed to resize |bitmap_result|, so compute fallback icon style.
-  favicon_base::LargeIconResult result(new favicon_base::FallbackIconStyle());
-  if (bitmap_result.is_valid()) {
-    favicon_base::SetDominantColorAsBackground(
-        bitmap_result.bitmap_data, result.fallback_icon_style.get());
-  }
-  callback.Run(result);
+LargeIconService::LargeIconService(FaviconService* favicon_service)
+    : favicon_service_(favicon_service) {
+  large_icon_types_.push_back(favicon_base::IconType::FAVICON);
+  large_icon_types_.push_back(favicon_base::IconType::TOUCH_ICON);
+  large_icon_types_.push_back(favicon_base::IconType::TOUCH_PRECOMPOSED_ICON);
+}
+
+LargeIconService::~LargeIconService() {
+}
+
+base::CancelableTaskTracker::TaskId
+    LargeIconService::GetLargeIconOrFallbackStyle(
+        const GURL& page_url,
+        int min_source_size_in_pixel,
+        int desired_size_in_pixel,
+        const favicon_base::LargeIconCallback& callback,
+        base::CancelableTaskTracker* tracker) {
+  DCHECK_LE(1, min_source_size_in_pixel);
+  DCHECK_LE(0, desired_size_in_pixel);
+
+  scoped_refptr<LargeIconService::Session> session =
+      new LargeIconService::Session(min_source_size_in_pixel,
+          desired_size_in_pixel, callback, GetBackgroundTaskRunner(), tracker);
+
+  // TODO(beaudoin): For now this is just a wrapper around
+  //   GetLargestRawFaviconForPageURL. Add the logic required to select the best
+  //   possible large icon. Also add logic to fetch-on-demand when the URL of
+  //   a large icon is known but its bitmap is not available.
+  return favicon_service_->GetLargestRawFaviconForPageURL(
+      page_url, large_icon_types_, desired_size_in_pixel,
+      base::Bind(&LargeIconService::Session::OnIconLookupComplete, session),
+      tracker);
+}
+
+// Returns TaskRunner used to execute background task.
+scoped_refptr<base::TaskRunner> LargeIconService::GetBackgroundTaskRunner() {
+  return content::BrowserThread::GetBlockingPool()
+      ->GetTaskRunnerWithShutdownBehavior(
+          base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
 }
 
 }  // namespace favicon