Plugs in the new thumbnailing algorithm to ThumbnailTabHelper.

chrome/browser/thumbnails/simple_thumbnail_crop.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 "chrome/browser/thumbnails/simple_thumbnail_crop.h"
 
 #include "base/metrics/histogram.h"
 #include "content/public/browser/browser_thread.h"
 #include "skia/ext/platform_canvas.h"
 #include "ui/gfx/color_utils.h"
@@ skipping 18 matching lines @@
     ui::ScaleFactor scale_factor,
     gfx::Rect* clipping_rect,
     gfx::Size* target_size) const {
   DCHECK(!source_size.IsEmpty());
   ClipResult clip_result = thumbnails::CLIP_RESULT_NOT_CLIPPED;
   *clipping_rect = GetClippingRect(source_size, target_size_, &clip_result);
   *target_size = GetCopySizeForThumbnail(scale_factor, target_size_);
   return clip_result;
 }
 
-void SimpleThumbnailCrop::ProcessBitmap(ThumbnailingContext* context,
-                                        const ConsumerCallback& callback,
-                                        const SkBitmap& bitmap) {
+void SimpleThumbnailCrop::ProcessBitmap(
+    scoped_refptr<ThumbnailingContext> context,
+    const ConsumerCallback& callback,
+    const SkBitmap& bitmap) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (bitmap.isNull() || bitmap.empty())
     return;
 
-  SkBitmap thumbnail = CreateThumbnail(bitmap,
-                                       GetThumbnailSizeInPixel(),
-                                       &context->clip_result);
+  SkBitmap thumbnail = CreateThumbnail(
+      bitmap,
+      ComputeTargetSizeAtMaximumScale(target_size_),
+      &context->clip_result);
 
   context->score.boring_score = CalculateBoringScore(thumbnail);
   context->score.good_clipping =
       (context->clip_result == CLIP_RESULT_WIDER_THAN_TALL ||
        context->clip_result == CLIP_RESULT_TALLER_THAN_WIDE ||
        context->clip_result == CLIP_RESULT_NOT_CLIPPED);
 
   callback.Run(*context, thumbnail);
 }
 
@@ skipping 68 matching lines @@
     default:
       DLOG(WARNING) << "Unsupported scale factor. Use the same copy size as "
                     << "ui::SCALE_FACTOR_100P";
       copy_size = gfx::ToFlooredSize(gfx::ScaleSize(
           copy_size, ui::GetScaleFactorScale(ui::SCALE_FACTOR_200P)));
       break;
   }
   return copy_size;
 }
 
-SimpleThumbnailCrop::~SimpleThumbnailCrop() {
-}
-
-// Returns the size of the thumbnail stored in the database in pixel.
-gfx::Size SimpleThumbnailCrop::GetThumbnailSizeInPixel() const {
-  // Determine the resolution of the thumbnail based on the maximum scale
-  // factor.
-  // TODO(mazda|oshima): Update thumbnail when the max scale factor changes.
-  // crbug.com/159157.
-  float max_scale_factor =
-      ui::GetScaleFactorScale(ui::GetMaxScaleFactor());
-  return gfx::ToFlooredSize(gfx::ScaleSize(target_size_, max_scale_factor));
-}
-
 gfx::Rect SimpleThumbnailCrop::GetClippingRect(const gfx::Size& source_size,
                                                const gfx::Size& desired_size,
                                                ClipResult* clip_result) {
   DCHECK(clip_result);
 
   float desired_aspect =
       static_cast<float>(desired_size.width()) / desired_size.height();
 
   // Get the clipping rect so that we can preserve the aspect ratio while
   // filling the destination.
@@ skipping 22 matching lines @@
           gfx::Rect(source_size.width(), source_size.width() / desired_aspect);
       *clip_result = thumbnails::CLIP_RESULT_TALLER_THAN_WIDE;
     } else {
       clipping_rect = gfx::Rect(source_size);
       *clip_result = thumbnails::CLIP_RESULT_NOT_CLIPPED;
     }
   }
   return clipping_rect;
 }
 
+// static
+gfx::Size SimpleThumbnailCrop::ComputeTargetSizeAtMaximumScale(
+    const gfx::Size& given_size) {
+  // TODO(mazda|oshima): Update thumbnail when the max scale factor changes.
+  // crbug.com/159157.
+  float max_scale_factor =
+      ui::GetScaleFactorScale(ui::GetMaxScaleFactor());
+  return gfx::ToFlooredSize(gfx::ScaleSize(given_size, max_scale_factor));
+}
+
+SimpleThumbnailCrop::~SimpleThumbnailCrop() {
+}
+
 // Creates a downsampled thumbnail from the given bitmap.
 // store. The returned bitmap will be isNull if there was an error creating it.
 SkBitmap SimpleThumbnailCrop::CreateThumbnail(const SkBitmap& bitmap,
                                               const gfx::Size& desired_size,
                                               ClipResult* clip_result) {
   base::TimeTicks begin_compute_thumbnail = base::TimeTicks::Now();
 
   SkBitmap clipped_bitmap;
   if (*clip_result == thumbnails::CLIP_RESULT_UNPROCESSED) {
     // Clip the pixels that will commonly hold a scrollbar, which looks bad in
@@ skipping 34 matching lines @@
       clipped_bitmap.height() == result.height())
     clipped_bitmap.copyTo(&result, SkBitmap::kARGB_8888_Config);
 #endif
 
   HISTOGRAM_TIMES(kThumbnailHistogramName,
                   base::TimeTicks::Now() - begin_compute_thumbnail);
   return result;
 }
 
 }