Clip the bitmap for creating the thumbnail on GPU when accelerated compositing is active.

chrome/browser/tab_contents/thumbnail_generator.cc

 // Copyright (c) 2012 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/bind.h"
@@ skipping 12 matching lines @@
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "googleurl/src/gurl.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/scrollbar_size.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
 // Overview
 // --------
 // This class provides current thumbnails for tabs. The simplest operation is
 // when a request for a thumbnail comes in, to grab the backing store and make
@@ skipping 41 matching lines @@
 //   result.height >= kThumbnailCopyScale * desired_size.height
 gfx::Size GetCopySizeForThumbnail(const gfx::Size& view_size,
                                   const gfx::Size& desired_size) {
   const double scale = kThumbnailCopyScale *
       std::max(static_cast<double>(desired_size.width()) / view_size.width(),
                static_cast<double>(desired_size.height()) / view_size.height());
   return gfx::Size(static_cast<int>(scale * view_size.width()),
                    static_cast<int>(scale * view_size.height()));
 }
 
+// Returns the clipping rectangle that is used for creating a thumbnail with
+// the size of |desired_size| from the bitmap with the size of |source_size|.
+// The type of clipping that needs to be done is assigned to |clip_result|.
+gfx::Rect GetClippingRect(const gfx::Size& source_size,
+                          const gfx::Size& desired_size,
+                          ThumbnailGenerator::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.
+  gfx::Rect clipping_rect;
+  if (source_size.width() < desired_size.width() ||
+      source_size.height() < desired_size.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.
+    clipping_rect = gfx::Rect(desired_size);
+    *clip_result = ThumbnailGenerator::kSourceIsSmaller;
+  } else {
+    float src_aspect =
+        static_cast<float>(source_size.width()) / source_size.height();
+    if (src_aspect > desired_aspect) {
+      // Wider than tall, clip horizontally: we center the smaller
+      // thumbnail in the wider screen.
+      int new_width = static_cast<int>(source_size.height() * desired_aspect);
+      int x_offset = (source_size.width() - new_width) / 2;
+      clipping_rect.SetRect(x_offset, 0, new_width, source_size.height());
+      *clip_result = (src_aspect >= ThumbnailScore::kTooWideAspectRatio) ?
+          ThumbnailGenerator::kTooWiderThanTall :
+          ThumbnailGenerator::kWiderThanTall;
+    } else if (src_aspect < desired_aspect) {
+      clipping_rect =
+          gfx::Rect(source_size.width(), source_size.width() / desired_aspect);
+      *clip_result = ThumbnailGenerator::kTallerThanWide;
+    } else {
+      clipping_rect = gfx::Rect(source_size);
+      *clip_result = ThumbnailGenerator::kNotClipped;
+    }
+  }
+  return clipping_rect;
+}
+
 // Creates a downsampled thumbnail from the given bitmap.
 // store. The returned bitmap will be isNull if there was an error creating it.
 SkBitmap CreateThumbnail(
-    const SkBitmap& bmp_with_scrollbars,
+    const SkBitmap& bitmap,
     int desired_width,
     int desired_height,
     ThumbnailGenerator::ClipResult* clip_result) {
   base::TimeTicks begin_compute_thumbnail = base::TimeTicks::Now();
 
-  // Clip the edgemost 15 pixels as that will commonly hold a scrollbar, which
-  // looks bad in thumbnails.
-  SkIRect scrollbarless_rect =
-      { 0, 0,
-        std::max(1, bmp_with_scrollbars.width() - 15),
-        std::max(1, bmp_with_scrollbars.height() - 15) };
-  SkBitmap bmp;
-  bmp_with_scrollbars.extractSubset(&bmp, scrollbarless_rect);
+  SkBitmap clipped_bitmap;
+  if (*clip_result == ThumbnailGenerator::kUnprocessed) {
+    // Clip the pixels that will commonly hold a scrollbar, which looks bad in
+    // thumbnails.
+    int scrollbar_size = gfx::scrollbar_size();
+    SkIRect scrollbarless_rect =
+        { 0, 0,
+          std::max(1, bitmap.width() - scrollbar_size),
+          std::max(1, bitmap.height() - scrollbar_size) };
+    SkBitmap bmp;
+    bitmap.extractSubset(&bmp, scrollbarless_rect);
 
-  SkBitmap clipped_bitmap = ThumbnailGenerator::GetClippedBitmap(
-      bmp, desired_width, desired_height, clip_result);
+    clipped_bitmap = ThumbnailGenerator::GetClippedBitmap(
+        bmp, desired_width, desired_height, clip_result);
+  } else {
+    clipped_bitmap = bitmap;
+  }
 
   // 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.
   SkBitmap result = SkBitmapOperations::DownsampleByTwoUntilSize(
       clipped_bitmap, desired_width, desired_height);
 #if !defined(USE_AURA)
   // 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
@@ skipping 245 matching lines @@
 
   int color_count = *std::max_element(histogram, histogram + 256);
   int pixel_count = bitmap.width() * bitmap.height();
   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 = (src_aspect >= ThumbnailScore::kTooWideAspectRatio) ?
-            ThumbnailGenerator::kTooWiderThanTall :
-            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;
-    }
-  }
-
+  gfx::Rect clipping_rect =
+      GetClippingRect(gfx::Size(bitmap.width(), bitmap.height()),
+                      gfx::Size(desired_width, desired_height),
+                      clip_result);
+  SkIRect src_rect = { clipping_rect.x(), clipping_rect.y(),
+                       clipping_rect.right(), clipping_rect.bottom() };
   SkBitmap clipped_bitmap;
   bitmap.extractSubset(&clipped_bitmap, src_rect);
   return clipped_bitmap;
 }
 
 void ThumbnailGenerator::UpdateThumbnailIfNecessary(
     WebContents* web_contents) {
   // Skip if a pending entry exists. WidgetHidden can be called while navigaing
   // pages and this is not a timing when thumbnails should be generated.
   if (web_contents->GetController().GetPendingEntry())
     return;
   const GURL& url = web_contents->GetURL();
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   history::TopSites* top_sites = profile->GetTopSites();
   // Skip if we don't need to update the thumbnail.
   if (!ShouldUpdateThumbnail(profile, top_sites, url))
     return;
 
   AsyncUpdateThumbnail(web_contents);
 }
 
 void ThumbnailGenerator::UpdateThumbnail(
     WebContents* web_contents, const SkBitmap& thumbnail,
-    const ThumbnailGenerator::ClipResult& clip_result) {
+    const ClipResult& clip_result) {
 
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   history::TopSites* top_sites = profile->GetTopSites();
   if (!top_sites)
     return;
 
   // Compute the thumbnail score.
   ThumbnailScore score;
   score.at_top =
@@ skipping 22 matching lines @@
 #if defined(OS_WIN)
     // On Windows XP, neither the backing store nor the compositing surface is
     // available in the browser when accelerated compositing is active, so ask
     // the renderer to send a snapshot for creating the thumbnail.
     if (base::win::GetVersion() < base::win::VERSION_VISTA) {
       gfx::Size view_size =
           render_widget_host->GetView()->GetViewBounds().size();
       AskForSnapshot(render_widget_host,
                      base::Bind(&ThumbnailGenerator::UpdateThumbnailWithBitmap,
                                 weak_factory_.GetWeakPtr(),
-                                web_contents),
+                                web_contents,
+                                ThumbnailGenerator::kUnprocessed),
                      view_size,
                      view_size);
     }
 #endif
     return;
   }
 
+  gfx::Rect copy_rect = gfx::Rect(view->GetViewBounds().size());
+  // Clip the pixels that will commonly hold a scrollbar, which looks bad in
+  // thumbnails.
+  int scrollbar_size = gfx::scrollbar_size();
+  copy_rect.Inset(0, 0, scrollbar_size, scrollbar_size);
+  ClipResult clip_result = ThumbnailGenerator::kUnprocessed;
+  copy_rect = GetClippingRect(copy_rect.size(),
+                              gfx::Size(kThumbnailWidth, kThumbnailHeight),
+                              &clip_result);
   gfx::Size copy_size =
-      GetCopySizeForThumbnail(view->GetViewBounds().size(),
-                              gfx::Size(kThumbnailWidth, kThumbnailHeight));
+      gfx::Size(kThumbnailWidth, kThumbnailHeight).Scale(kThumbnailCopyScale);
   skia::PlatformCanvas* temp_canvas = new skia::PlatformCanvas;
   render_widget_host->CopyFromBackingStore(
-      gfx::Rect(),
+      copy_rect,
       copy_size,
       base::Bind(&ThumbnailGenerator::UpdateThumbnailWithCanvas,
                  weak_factory_.GetWeakPtr(),
                  web_contents,
+                 clip_result,
                  base::Owned(temp_canvas)),
       temp_canvas);
 }
 
 void ThumbnailGenerator::UpdateThumbnailWithBitmap(
     WebContents* web_contents,
+    ClipResult clip_result,
     const SkBitmap& bitmap) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (bitmap.isNull() || bitmap.empty())
     return;
 
-  ClipResult clip_result;
   SkBitmap thumbnail = CreateThumbnail(bitmap,
                                        kThumbnailWidth,
                                        kThumbnailHeight,
                                        &clip_result);
   UpdateThumbnail(web_contents, thumbnail, clip_result);
 }
 
 void ThumbnailGenerator::UpdateThumbnailWithCanvas(
     WebContents* web_contents,
+    ClipResult clip_result,
     skia::PlatformCanvas* temp_canvas,
     bool succeeded) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (!succeeded)
     return;
 
-  SkBitmap bmp_with_scrollbars =
-      skia::GetTopDevice(*temp_canvas)->accessBitmap(false);
-  UpdateThumbnailWithBitmap(web_contents, bmp_with_scrollbars);
+  SkBitmap bitmap = skia::GetTopDevice(*temp_canvas)->accessBitmap(false);
+  UpdateThumbnailWithBitmap(web_contents, clip_result, bitmap);
 }
 
 bool ThumbnailGenerator::ShouldUpdateThumbnail(Profile* profile,
                                                history::TopSites* top_sites,
                                                const GURL& url) {
   if (!profile || !top_sites)
     return false;
   // Skip if it's in the incognito mode.
   if (profile->IsOffTheRecord())
     return false;
@@ skipping 21 matching lines @@
 void ThumbnailGenerator::DidStartLoading(
     content::RenderViewHost* render_view_host) {
   load_interrupted_ = false;
 }
 
 void ThumbnailGenerator::StopNavigation() {
   // This function gets called when the page loading is interrupted by the
   // stop button.
   load_interrupted_ = true;
 }