Generate thumbnails in the browser process.

chrome/browser/tab_contents/thumbnail_generator.cc

 // Copyright (c) 2009 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/tab_contents/thumbnail_generator.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/metrics/histogram.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/renderer_host/backing_store.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/property_bag.h"
+#include "gfx/color_utils.h"
 #include "gfx/rect.h"
 #include "gfx/skbitmap_operations.h"
+#include "skia/ext/bitmap_platform_device.h"
+#include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 #if defined(OS_WIN)
 #include "app/win/win_util.h"
 #endif
 
 // Overview
 // --------
 // This class provides current thumbnails for tabs. The simplest operation is
@@ skipping 60 matching lines @@
   if (wt)
     return wt;
 
   GetThumbnailAccessor()->SetProperty(host->property_bag(),
                                       WidgetThumbnail());
   return GetThumbnailAccessor()->GetProperty(host->property_bag());
 }
 
 // Creates a downsampled thumbnail for the given backing store. The returned
 // bitmap will be isNull if there was an error creating it.
-SkBitmap GetBitmapForBackingStore(BackingStore* backing_store,
-                                  int desired_width,
-                                  int desired_height) {
+SkBitmap GetBitmapForBackingStore(
+    BackingStore* backing_store,
+    int desired_width,
+    int desired_height,
+    int options,
+    ThumbnailGenerator::ClipResult* clip_result) {
   base::TimeTicks begin_compute_thumbnail = base::TimeTicks::Now();
 
   SkBitmap result;
 
   // Get the bitmap as a Skia object so we can resample it. This is a large
   // allocation and we can tolerate failure here, so give up if the allocation
   // fails.
   skia::PlatformCanvas temp_canvas;
   if (!backing_store->CopyFromBackingStore(gfx::Rect(backing_store->size()),
                                            &temp_canvas))
     return result;
   const SkBitmap& bmp = temp_canvas.getTopPlatformDevice().accessBitmap(false);
 
-  // Need to resize it to the size we want, so downsample until it's
-  // close, and let the caller make it the exact size if desired.
-  result = SkBitmapOperations::DownsampleByTwoUntilSize(
-      bmp, desired_width, desired_height);
+  // Check if a clipped thumbnail is requested.
+  if (options & ThumbnailGenerator::kClippedThumbnail) {
+    SkBitmap clipped_bitmap = ThumbnailGenerator::GetClippedBitmap(
+        bmp, desired_width, desired_height, clip_result);
 
-  // This is a bit subtle. SkBitmaps are refcounted, but the magic
-  // ones in PlatformCanvas can't be assigned to SkBitmap with proper
-  // refcounting.  If the bitmap doesn't change, then the downsampler
-  // will return the input bitmap, which will be the reference to the
-  // weird PlatformCanvas one insetad of a regular one. To get a
-  // regular refcounted bitmap, we need to copy it.
-  if (bmp.width() == result.width() &&
-      bmp.height() == result.height())
-    bmp.copyTo(&result, SkBitmap::kARGB_8888_Config);
+    // Need to resize it to the size we want, so downsample until it's
+    // close, and let the caller make it the exact size if desired.
+    result = SkBitmapOperations::DownsampleByTwoUntilSize(
+        clipped_bitmap, desired_width, desired_height);
+  } else {
+    // Need to resize it to the size we want, so downsample until it's
+    // close, and let the caller make it the exact size if desired.
+    result = SkBitmapOperations::DownsampleByTwoUntilSize(
+        bmp, desired_width, desired_height);
+
+    // This is a bit subtle. SkBitmaps are refcounted, but the magic
+    // ones in PlatformCanvas can't be assigned to SkBitmap with proper
+    // refcounting.  If the bitmap doesn't change, then the downsampler
+    // will return the input bitmap, which will be the reference to the
+    // weird PlatformCanvas one insetad of a regular one. To get a
+    // regular refcounted bitmap, we need to copy it.
+    if (bmp.width() == result.width() &&
+        bmp.height() == result.height())
+      bmp.copyTo(&result, SkBitmap::kARGB_8888_Config);
+  }
 
   HISTOGRAM_TIMES(kThumbnailHistogramName,
                   base::TimeTicks::Now() - begin_compute_thumbnail);
   return result;
 }
 
 }  // namespace
 
 struct ThumbnailGenerator::AsyncRequestInfo {
   scoped_ptr<ThumbnailReadyCallback> callback;
@@ skipping 74 matching lines @@
                                         ThumbnailReadyCallback* callback,
                                         gfx::Size page_size,
                                         gfx::Size desired_size) {
   if (prefer_backing_store) {
     BackingStore* backing_store = renderer->GetBackingStore(false);
     if (backing_store) {
       // We were able to find a non-null backing store for this renderer, so
       // we'll go with it.
       SkBitmap first_try = GetBitmapForBackingStore(backing_store,
                                                     desired_size.width(),
-                                                    desired_size.height());
+                                                    desired_size.height(),
+                                                    kNone,
+                                                    NULL);
       callback->Run(first_try);
 
       delete callback;
       return;
     }
     // Now, if the backing store didn't exist, we will still try and
     // render asynchronously.
   }
 
   // We are going to render the thumbnail asynchronously now, so keep
@@ skipping 31 matching lines @@
     NOTREACHED() << "Callback already registered?";
     return;
   }
 
   renderer->PaintAtSize(
       renderer_dib_handle, sequence_num, page_size, desired_size);
 }
 
 SkBitmap ThumbnailGenerator::GetThumbnailForRenderer(
     RenderWidgetHost* renderer) const {
+  return GetThumbnailForRendererWithOptions(renderer, kNone, NULL);
+}
+
+SkBitmap ThumbnailGenerator::GetThumbnailForRendererWithOptions(
+    RenderWidgetHost* renderer,
+    int options,
+    ClipResult* clip_result) const {
   WidgetThumbnail* wt = GetDataForHost(renderer);
 
   BackingStore* backing_store = renderer->GetBackingStore(false);
   if (!backing_store) {
     // When we have no backing store, there's no choice in what to use. We
     // have to return either the existing thumbnail or the empty one if there
     // isn't a saved one.
     return wt->thumbnail;
   }
 
   // Now that we have a backing store, we have a choice to use it to make
   // a new thumbnail, or use a previously stashed one if we have it.
   //
   // Return the previously-computed one if we have it and it hasn't expired.
   if (!wt->thumbnail.isNull() &&
       (no_timeout_ ||
        base::TimeTicks::Now() -
        base::TimeDelta::FromMilliseconds(kVisibilitySlopMS) < wt->last_shown))
     return wt->thumbnail;
 
   // Save this thumbnail in case we need to use it again soon. It will be
   // invalidated on the next paint.
   wt->thumbnail = GetBitmapForBackingStore(backing_store,
                                            kThumbnailWidth,
-                                           kThumbnailHeight);
+                                           kThumbnailHeight,
+                                           options,
+                                           clip_result);
   return wt->thumbnail;
 }
 
 void ThumbnailGenerator::WidgetWillDestroyBackingStore(
     RenderWidgetHost* widget,
     BackingStore* backing_store) {
   // Since the backing store is going away, we need to save it as a thumbnail.
   WidgetThumbnail* wt = GetDataForHost(widget);
 
   // If there is already a thumbnail on the RWH that's visible, it means that
   // not enough time has elapsed since being shown, and we can ignore generating
   // a new one.
   if (!wt->thumbnail.isNull())
     return;
 
   // Save a scaled-down image of the page in case we're asked for the thumbnail
   // when there is no RenderViewHost. If this fails, we don't want to overwrite
   // an existing thumbnail.
   SkBitmap new_thumbnail = GetBitmapForBackingStore(backing_store,
                                                     kThumbnailWidth,
-                                                    kThumbnailHeight);
+                                                    kThumbnailHeight,
+                                                    kNone,
+                                                    NULL);
   if (!new_thumbnail.isNull())
     wt->thumbnail = new_thumbnail;
 }
 
 void ThumbnailGenerator::WidgetDidUpdateBackingStore(RenderWidgetHost* widget) {
   // Notify interested parties that they might want to update their
   // snapshots.
   NotificationService::current()->Notify(
       NotificationType::THUMBNAIL_GENERATOR_SNAPSHOT_CHANGED,
       Source<ThumbnailGenerator>(this),
@@ skipping 193 matching lines @@
                  &ThumbnailGenerator::ShownDelayHandler);
   }
 }
 
 void ThumbnailGenerator::EraseHostFromShownList(RenderWidgetHost* widget) {
   std::vector<RenderWidgetHost*>::iterator found =
       std::find(shown_hosts_.begin(), shown_hosts_.end(), widget);
   if (found != shown_hosts_.end())
     shown_hosts_.erase(found);
 }
+
+double ThumbnailGenerator::CalculateBoringScore(SkBitmap* bitmap) {
+  int histogram[256] = {0};
+  color_utils::BuildLumaHistogram(bitmap, histogram);
+
+  int color_count = *std::max_element(histogram, histogram + 256);
+  int pixel_count = bitmap->width() * bitmap->height();
+  if (pixel_count == 0) {
+    return 1.0;
+  }
+  return static_cast<double>(color_count) / pixel_count;
+}
+
+SkBitmap ThumbnailGenerator::GetClippedBitmap(const SkBitmap& bitmap,
+                                              int desired_width,
+                                              int desired_height,
+                                              ClipResult* clip_result) {
+  const SkRect dest_rect = { 0, 0,
+                             SkIntToScalar(desired_width),
+                             SkIntToScalar(desired_height) };
+  const float dest_aspect = dest_rect.width() / dest_rect.height();
+
+  // Get the src rect so that we can preserve the aspect ratio while filling
+  // the destination.
+  SkIRect src_rect;
+  if (bitmap.width() < dest_rect.width() ||
+      bitmap.height() < dest_rect.height()) {
+    // Source image is smaller: we clip the part of source image within the
+    // dest rect, and then stretch it to fill the dest rect. We don't respect
+    // the aspect ratio in this case.
+    src_rect.set(0, 0, static_cast<S16CPU>(dest_rect.width()),
+                 static_cast<S16CPU>(dest_rect.height()));
+    if (clip_result)
+      *clip_result = ThumbnailGenerator::kSourceIsSmaller;
+  } else {
+    const float src_aspect =
+        static_cast<float>(bitmap.width()) / bitmap.height();
+    if (src_aspect > dest_aspect) {
+      // Wider than tall, clip horizontally: we center the smaller
+      // thumbnail in the wider screen.
+      S16CPU new_width = static_cast<S16CPU>(bitmap.height() * dest_aspect);
+      S16CPU x_offset = (bitmap.width() - new_width) / 2;
+      src_rect.set(x_offset, 0, new_width + x_offset, bitmap.height());
+      if (clip_result)
+        *clip_result = ThumbnailGenerator::kWiderThanTall;
+    } else if (src_aspect < dest_aspect) {
+      src_rect.set(0, 0, bitmap.width(),
+                   static_cast<S16CPU>(bitmap.width() / dest_aspect));
+      if (clip_result)
+        *clip_result = ThumbnailGenerator::kTallerThanWide;
+    } else {
+      src_rect.set(0, 0, bitmap.width(), bitmap.height());
+      if (clip_result)
+        *clip_result = ThumbnailGenerator::kNotClipped;
+    }
+  }
+
+  SkBitmap clipped_bitmap;
+  bitmap.extractSubset(&clipped_bitmap, src_rect);
+  return clipped_bitmap;
+}