src/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 because
 110 // the resampling method used in RenderWidgetHost::CopyFromBackingStore is not
 111 // good enough for the resampled image to be used directly for the thumbnail
 112 // (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(
 125           copy_size, ui::GetImageScale(ui::SCALE_FACTOR_200P)));
 126       break;
 127     case ui::SCALE_FACTOR_200P:
 128       // Use the size as-is.
 129       break;
 130     default:
 131       DLOG(WARNING) << "Unsupported scale factor. Use the same copy size as "
 132                     << "ui::SCALE_FACTOR_100P";
 133       copy_size = gfx::ToFlooredSize(gfx::ScaleSize(
 134           copy_size, gfx::ImageSkia::GetMaxSupportedScale()));
 135       break;
 136   }
 137   return copy_size;
 138 }
 139
 140 gfx::Rect SimpleThumbnailCrop::GetClippingRect(const gfx::Size& source_size,
 141                                                const gfx::Size& desired_size,
 142                                                ClipResult* clip_result) {
 143   DCHECK(clip_result);
 144
 145   float desired_aspect =
 146       static_cast<float>(desired_size.width()) / desired_size.height();
 147
 148   // Get the clipping rect so that we can preserve the aspect ratio while
 149   // filling the destination.
 150   gfx::Rect clipping_rect;
 151   if (source_size.width() < desired_size.width() ||
 152       source_size.height() < desired_size.height()) {
 153     // Source image is smaller: we clip the part of source image within the
 154     // dest rect, and then stretch it to fill the dest rect. We don't respect
 155     // the aspect ratio in this case.
 156     clipping_rect = gfx::Rect(desired_size);
 157     *clip_result = thumbnails::CLIP_RESULT_SOURCE_IS_SMALLER;
 158   } else {
 159     float src_aspect =
 160         static_cast<float>(source_size.width()) / source_size.height();
 161     if (src_aspect > desired_aspect) {
 162       // Wider than tall, clip horizontally: we center the smaller
 163       // thumbnail in the wider screen.
 164       int new_width = static_cast<int>(source_size.height() * desired_aspect);
 165       int x_offset = (source_size.width() - new_width) / 2;
 166       clipping_rect.SetRect(x_offset, 0, new_width, source_size.height());
 167       *clip_result = (src_aspect >= ThumbnailScore::kTooWideAspectRatio) ?
 168           thumbnails::CLIP_RESULT_MUCH_WIDER_THAN_TALL :
 169           thumbnails::CLIP_RESULT_WIDER_THAN_TALL;
 170     } else if (src_aspect < desired_aspect) {
 171       clipping_rect =
 172           gfx::Rect(source_size.width(), source_size.width() / desired_aspect);
 173       *clip_result = thumbnails::CLIP_RESULT_TALLER_THAN_WIDE;
 174     } else {
 175       clipping_rect = gfx::Rect(source_size);
 176       *clip_result = thumbnails::CLIP_RESULT_NOT_CLIPPED;
 177     }
 178   }
 179   return clipping_rect;
 180 }
 181
 182 // static
 183 gfx::Size SimpleThumbnailCrop::ComputeTargetSizeAtMaximumScale(
 184     const gfx::Size& given_size) {
 185   // TODO(mazda|oshima): Update thumbnail when the max scale factor changes.
 186   // crbug.com/159157.
 187   float max_scale_factor = gfx::ImageSkia::GetMaxSupportedScale();
 188   return gfx::ToFlooredSize(gfx::ScaleSize(given_size, max_scale_factor));
 189 }
 190
 191 SimpleThumbnailCrop::~SimpleThumbnailCrop() {
 192 }
 193
 194 // Creates a downsampled thumbnail from the given bitmap.
 195 // store. The returned bitmap will be isNull if there was an error creating it.
 196 SkBitmap SimpleThumbnailCrop::CreateThumbnail(const SkBitmap& bitmap,
 197                                               const gfx::Size& desired_size,
 198                                               ClipResult* clip_result) {
 199   base::TimeTicks begin_compute_thumbnail = base::TimeTicks::Now();
 200
 201   SkBitmap clipped_bitmap;
 202   if (*clip_result == thumbnails::CLIP_RESULT_UNPROCESSED) {
 203     // Clip the pixels that will commonly hold a scrollbar, which looks bad in
 204     // thumbnails.
 205     int scrollbar_size = gfx::scrollbar_size();
 206     SkIRect scrollbarless_rect =
 207         { 0, 0,
 208           std::max(1, bitmap.width() - scrollbar_size),
 209           std::max(1, bitmap.height() - scrollbar_size) };
 210     SkBitmap bmp;
 211     bitmap.extractSubset(&bmp, scrollbarless_rect);
 212
 213     clipped_bitmap = GetClippedBitmap(
 214         bmp, desired_size.width(), desired_size.height(), clip_result);
 215   } else {
 216     clipped_bitmap = bitmap;
 217   }
 218
 219   // Need to resize it to the size we want, so downsample until it's
 220   // close, and let the caller make it the exact size if desired.
 221   SkBitmap result = SkBitmapOperations::DownsampleByTwoUntilSize(
 222       clipped_bitmap, desired_size.width(), desired_size.height());
 223 #if !defined(USE_AURA)
 224   // This is a bit subtle. SkBitmaps are refcounted, but the magic
 225   // ones in PlatformCanvas can't be assigned to SkBitmap with proper
 226   // refcounting.  If the bitmap doesn't change, then the downsampler
 227   // will return the input bitmap, which will be the reference to the
 228   // weird PlatformCanvas one insetad of a regular one. To get a
 229   // regular refcounted bitmap, we need to copy it.
 230   //
 231   // On Aura, the PlatformCanvas is platform-independent and does not have
 232   // any native platform resources that can't be refounted, so this issue does
 233   // not occur.
 234   //
 235   // Note that GetClippedBitmap() does extractSubset() but it won't copy
 236   // the pixels, hence we check result size == clipped_bitmap size here.
 237   if (clipped_bitmap.width() == result.width() &&
 238       clipped_bitmap.height() == result.height())
 239     clipped_bitmap.copyTo(&result, kPMColor_SkColorType);
 240 #endif
 241
 242   HISTOGRAM_TIMES(kThumbnailHistogramName,
 243                   base::TimeTicks::Now() - begin_compute_thumbnail);
 244   return result;
 245 }
 246
 247 } // namespace thumbnails