chrome/browser/thumbnails/simple_thumbnail_crop.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/thumbnails/simple_thumbnail_crop.h"
   6
   7 #include "base/metrics/histogram.h"
   8 #include "content/public/browser/browser_thread.h"
   9 #include "skia/ext/platform_canvas.h"
  10 #include "ui/gfx/color_utils.h"
  11 #include "ui/gfx/image/image_skia.h"
  12 #include "ui/gfx/screen.h"
  13 #include "ui/gfx/scrollbar_size.h"
  14 #include "ui/gfx/size_conversions.h"
  15 #include "ui/gfx/skbitmap_operations.h"
  16
  17 namespace {
  18 static const char kThumbnailHistogramName[] = "Thumbnail.ComputeMS";
  19 }
  20
  21 namespace thumbnails {
  22
  23 SimpleThumbnailCrop::SimpleThumbnailCrop(const gfx::Size& target_size)
  24     : target_size_(target_size) {
  25   DCHECK(!target_size.IsEmpty());
  26 }
  27
  28 ClipResult SimpleThumbnailCrop::GetCanvasCopyInfo(
  29     const gfx::Size& source_size,
  30     ui::ScaleFactor scale_factor,
  31     gfx::Rect* clipping_rect,
  32     gfx::Size* target_size) const {
  33   DCHECK(!source_size.IsEmpty());
  34   ClipResult clip_result = thumbnails::CLIP_RESULT_NOT_CLIPPED;
  35   *clipping_rect = GetClippingRect(source_size, target_size_, &clip_result);
  36   *target_size = GetCopySizeForThumbnail(scale_factor, target_size_);
  37   return clip_result;
  38 }
  39
  40 void SimpleThumbnailCrop::ProcessBitmap(
  41     scoped_refptr<ThumbnailingContext> context,
  42     const ConsumerCallback& callback,
  43     const SkBitmap& bitmap) {
  44   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
  45   if (bitmap.isNull() || bitmap.empty())
  46     return;
  47
  48   SkBitmap thumbnail = CreateThumbnail(
  49       bitmap,
  50       ComputeTargetSizeAtMaximumScale(target_size_),
  51       &context->clip_result);
  52
  53   context->score.boring_score = CalculateBoringScore(thumbnail);
  54   context->score.good_clipping =
  55       (context->clip_result == CLIP_RESULT_WIDER_THAN_TALL ||
  56        context->clip_result == CLIP_RESULT_TALLER_THAN_WIDE ||
  57        context->clip_result == CLIP_RESULT_NOT_CLIPPED);
  58
  59   callback.Run(*context.get(), thumbnail);
  60 }
  61
  62 double SimpleThumbnailCrop::CalculateBoringScore(const SkBitmap& bitmap) {
  63   if (bitmap.isNull() || bitmap.empty())
  64     return 1.0;
  65   int histogram[256] = {0};
  66   color_utils::BuildLumaHistogram(bitmap, histogram);
  67
  68   int color_count = *std::max_element(histogram, histogram + 256);
  69   int pixel_count = bitmap.width() * bitmap.height();
  70   return static_cast<double>(color_count) / pixel_count;
  71 }
  72
  73 SkBitmap SimpleThumbnailCrop::GetClippedBitmap(const SkBitmap& bitmap,
  74                                                int desired_width,
  75                                                int desired_height,
  76                                                ClipResult* clip_result) {
  77   gfx::Rect clipping_rect =
  78       GetClippingRect(gfx::Size(bitmap.width(), bitmap.height()),
  79                       gfx::Size(desired_width, desired_height),
  80                       clip_result);
  81   SkIRect src_rect = { clipping_rect.x(), clipping_rect.y(),
  82                        clipping_rect.right(), clipping_rect.bottom() };
  83   SkBitmap clipped_bitmap;
  84   bitmap.extractSubset(&clipped_bitmap, src_rect);
  85   return clipped_bitmap;
  86 }
  87
  88 // Returns the size used by RenderWidgetHost::CopyFromBackingStore.
  89 //
  90 // The size is calculated in such a way that the copied size in pixel becomes
  91 // equal to (f * kThumbnailWidth, f * kThumbnailHeight), where f is the scale
  92 // of ui::SCALE_FACTOR_200P. Since RenderWidgetHost::CopyFromBackingStore takes
  93 // the size in DIP, we need to adjust the size based on |view|'s device scale
  94 // factor in order to copy the pixels with the size above.
  95 //
  96 // The copied size was chosen for the following reasons.
  97 //
  98 // 1. When the scale factor of the primary monitor is ui::SCALE_FACTOR_200P, the
  99 // generated thumbnail size is (f * kThumbnailWidth, f * kThumbnailHeight).
 100 // In order to avoid degrading the image quality by magnification, the size
 101 // of the copied pixels should be equal to or larger than this thumbnail size.
 102 //
 103 // 2. RenderWidgetHost::CopyFromBackingStore can be costly especially when
 104 // it is necessary to read back the web contents image data from GPU. As the
 105 // cost is roughly propotional to the number of the copied pixels, the size of
 106 // the copied pixels should be as small as possible.
 107 //
 108 // When the scale factor of the primary monitor is ui::SCALE_FACTOR_100P,
 109 // we still copy the pixels with the same size as ui::SCALE_FACTOR_200P (2.0f)
 110 // because the resampling method used in RenderWidgetHost::CopyFromBackingStore
 111 // is not good enough for the resampled image to be used directly for the
 112 // thumbnail (http://crbug.com/141235). We assume this is not an issue in case of
 113 // ui::SCALE_FACTOR_200P because the high resolution thumbnail on high density
 114 // display alleviates the aliasing.
 115 // TODO(mazda): Copy the pixels with the smaller size in the case of
 116 // ui::SCALE_FACTOR_100P once the resampling method has been improved.
 117 // static
 118 gfx::Size SimpleThumbnailCrop::GetCopySizeForThumbnail(
 119     ui::ScaleFactor scale_factor,
 120     const gfx::Size& thumbnail_size) {
 121   gfx::Size copy_size(thumbnail_size);
 122   switch (scale_factor) {
 123     case ui::SCALE_FACTOR_100P:
 124       copy_size = gfx::ToFlooredSize(gfx::ScaleSize(copy_size, 2.0f));
 125       break;
 126     case ui::SCALE_FACTOR_200P:
 127       // Use the size as-is.
 128       break;
 129     default:
 130       DLOG(WARNING) << "Unsupported scale factor. Use the same copy size as "
 131                     << "ui::SCALE_FACTOR_100P";
 132       copy_size = gfx::ToFlooredSize(gfx::ScaleSize(
 133           copy_size, gfx::ImageSkia::GetMaxSupportedScale()));
 134       break;
 135   }
 136   return copy_size;
 137 }
 138
 139 gfx::Rect SimpleThumbnailCrop::GetClippingRect(const gfx::Size& source_size,
 140                                                const gfx::Size& desired_size,
 141                                                ClipResult* clip_result) {
 142   DCHECK(clip_result);
 143
 144   float desired_aspect =
 145       static_cast<float>(desired_size.width()) / desired_size.height();
 146
 147   // Get the clipping rect so that we can preserve the aspect ratio while
 148   // filling the destination.
 149   gfx::Rect clipping_rect;
 150   if (source_size.width() < desired_size.width() ||
 151       source_size.height() < desired_size.height()) {
 152     // Source image is smaller: we clip the part of source image within the
 153     // dest rect, and then stretch it to fill the dest rect. We don't respect
 154     // the aspect ratio in this case.
 155     clipping_rect = gfx::Rect(desired_size);
 156     *clip_result = thumbnails::CLIP_RESULT_SOURCE_IS_SMALLER;
 157   } else {
 158     float src_aspect =
 159         static_cast<float>(source_size.width()) / source_size.height();
 160     if (src_aspect > desired_aspect) {
 161       // Wider than tall, clip horizontally: we center the smaller
 162       // thumbnail in the wider screen.
 163       int new_width = static_cast<int>(source_size.height() * desired_aspect);
 164       int x_offset = (source_size.width() - new_width) / 2;
 165       clipping_rect.SetRect(x_offset, 0, new_width, source_size.height());
 166       *clip_result = (src_aspect >= ThumbnailScore::kTooWideAspectRatio) ?
 167           thumbnails::CLIP_RESULT_MUCH_WIDER_THAN_TALL :
 168           thumbnails::CLIP_RESULT_WIDER_THAN_TALL;
 169     } else if (src_aspect < desired_aspect) {
 170       clipping_rect =
 171           gfx::Rect(source_size.width(), source_size.width() / desired_aspect);
 172       *clip_result = thumbnails::CLIP_RESULT_TALLER_THAN_WIDE;
 173     } else {
 174       clipping_rect = gfx::Rect(source_size);
 175       *clip_result = thumbnails::CLIP_RESULT_NOT_CLIPPED;
 176     }
 177   }
 178   return clipping_rect;
 179 }
 180
 181 // static
 182 gfx::Size SimpleThumbnailCrop::ComputeTargetSizeAtMaximumScale(
 183     const gfx::Size& given_size) {
 184   // TODO(mazda|oshima): Update thumbnail when the max scale factor changes.
 185   // crbug.com/159157.
 186   float max_scale_factor = gfx::ImageSkia::GetMaxSupportedScale();
 187   return gfx::ToFlooredSize(gfx::ScaleSize(given_size, max_scale_factor));
 188 }
 189
 190 SimpleThumbnailCrop::~SimpleThumbnailCrop() {
 191 }
 192
 193 // Creates a downsampled thumbnail from the given bitmap.
 194 // store. The returned bitmap will be isNull if there was an error creating it.
 195 SkBitmap SimpleThumbnailCrop::CreateThumbnail(const SkBitmap& bitmap,
 196                                               const gfx::Size& desired_size,
 197                                               ClipResult* clip_result) {
 198   base::TimeTicks begin_compute_thumbnail = base::TimeTicks::Now();
 199
 200   SkBitmap clipped_bitmap;
 201   if (*clip_result == thumbnails::CLIP_RESULT_UNPROCESSED) {
 202     // Clip the pixels that will commonly hold a scrollbar, which looks bad in
 203     // thumbnails.
 204     int scrollbar_size = gfx::scrollbar_size();
 205     SkIRect scrollbarless_rect =
 206         { 0, 0,
 207           std::max(1, bitmap.width() - scrollbar_size),
 208           std::max(1, bitmap.height() - scrollbar_size) };
 209     SkBitmap bmp;
 210     bitmap.extractSubset(&bmp, scrollbarless_rect);
 211
 212     clipped_bitmap = GetClippedBitmap(
 213         bmp, desired_size.width(), desired_size.height(), clip_result);
 214   } else {
 215     clipped_bitmap = bitmap;
 216   }
 217
 218   // Need to resize it to the size we want, so downsample until it's
 219   // close, and let the caller make it the exact size if desired.
 220   SkBitmap result = SkBitmapOperations::DownsampleByTwoUntilSize(
 221       clipped_bitmap, desired_size.width(), desired_size.height());
 222 #if !defined(USE_AURA)
 223   // This is a bit subtle. SkBitmaps are refcounted, but the magic
 224   // ones in PlatformCanvas can't be assigned to SkBitmap with proper
 225   // refcounting.  If the bitmap doesn't change, then the downsampler
 226   // will return the input bitmap, which will be the reference to the
 227   // weird PlatformCanvas one insetad of a regular one. To get a
 228   // regular refcounted bitmap, we need to copy it.
 229   //
 230   // On Aura, the PlatformCanvas is platform-independent and does not have
 231   // any native platform resources that can't be refounted, so this issue does
 232   // not occur.
 233   //
 234   // Note that GetClippedBitmap() does extractSubset() but it won't copy
 235   // the pixels, hence we check result size == clipped_bitmap size here.
 236   if (clipped_bitmap.width() == result.width() &&
 237       clipped_bitmap.height() == result.height())
 238     clipped_bitmap.copyTo(&result, kN32_SkColorType);
 239 #endif
 240
 241   HISTOGRAM_TIMES(kThumbnailHistogramName,
 242                   base::TimeTicks::Now() - begin_compute_thumbnail);
 243   return result;
 244 }
 245
 246 } // namespace thumbnails