Make ThumbnailGenerator support high DPI.

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 <cmath>
 #include <map>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/time.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/history/top_sites.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/thumbnail_score.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/notification_types.h"
 #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/base/layout.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/rect.h"
+#include "ui/gfx/screen.h"
 #include "ui/gfx/scrollbar_size.h"
 #include "ui/gfx/skbitmap_operations.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
+#include "ui/base/win/dpi.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
 // a smaller version of that. Clients of the class can send such a request by
 // AskForSnapshot().
 //
 // The class also provides a service for updating thumbnails to be used in
 // "Most visited" section of the new tab page. The service can be started
 // by StartThumbnailing(). The current algorithm of the service is as
 // simple as follows:
 //
 //    When a renderer is about to be hidden (this usually occurs when the
 //    current tab is closed or another tab is clicked), update the
 //    thumbnail for the tab rendered by the renderer, if needed. The
 //    heuristics to judge whether or not to update the thumbnail is
 //    implemented in ShouldUpdateThumbnail().
 //
 // We'll likely revise the algorithm to improve quality of thumbnails this
 // service generates.
 
 using content::RenderViewHost;
 using content::RenderWidgetHost;
 using content::WebContents;
 
 namespace {
 
+// The thumbnail size in DIP.
 static const int kThumbnailWidth = 212;
 static const int kThumbnailHeight = 132;
 
-// This factor determines the number of pixels to be copied by
-// RenderWidgetHost::CopyFromBackingStore for generating thumbnail.
-// Smaller scale is good for performance, but too small scale causes aliasing
-// because the resampling method is not good enough to retain the image quality.
-// TODO(mazda): the Improve resampling method and use a smaller scale
-// (http://crbug.com/118571).
-static const double kThumbnailCopyScale = 2.0;
-
 static const char kThumbnailHistogramName[] = "Thumbnail.ComputeMS";
 
-// Calculates the size used by RenderWidgetHost::CopyFromBackingStore.
-// The result is computed as the minimum size that satisfies the following
-// conditions.
-//   result.width : result.height == view_size.width : view_size.height
-//   result.width >= kThumbnailCopyScale * desired_size.width
-//   result.height >= kThumbnailCopyScale * desired_size.height
-gfx::Size GetCopySizeForThumbnail(const gfx::Size& view_size,
-                                  const gfx::Size& desired_size) {

[oshima, 2012/08/10 02:01:15]

so this wasn't used? Just want to confirm.

[mazda, 2012/08/17 06:10:51]

This function has not been used tentatively since the following CL
http://src.chromium.org/viewvc/chrome?view=rev&revision=150398,
but that's only until I'm adding the high DPI support in this CL.

-  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 size used by RenderWidgetHost::CopyFromBackingStore.
+//
+// The size is calculated in such a way that the copied size in pixel becomes
+// equal to (f * kThumbnailWidth, f * kThumbnailHeight), where f is the scale
+// of ui::SCALE_FACTOR_200P. Since RenderWidgetHost::CopyFromBackingStore takes
+// the size in DIP, we need to adjust the size based on |view|'s device scale
+// factor in order to copy the pixels with the size above.
+//
+// The copied size was chosen for the following reasons.
+//
+// 1. When the scale factor of the primary monitor is ui::SCALE_FACTOR_200P, the
+// generated thumbnail size is (f * kThumbnailWidth, f * kThumbnailHeight).
+// In order to avoid degrading the image quality by magnification, the size
+// of the copied pixels should be equal to or larger than this thumbnail size.
+//
+// 2. RenderWidgetHost::CopyFromBackingStore can be costly especially when
+// it is necessary to read back the web contents image data from GPU. As the
+// cost is roughly propotional to the number of the copied pixels, the size of
+// the copied pixels should be as small as possible.
+//
+// When the scale factor of the primary monitor is ui::SCALE_FACTOR_100P,
+// we still copy the pixels with the same size as ui::SCALE_FACTOR_200P because
+// the resampling method used in RenderWidgetHost::CopyFromBackingStore is not
+// good enough for the resampled image to be used directly for the thumbnail
+// (http://crbug.com/141235). We assume this is not an issue in case of
+// ui::SCALE_FACTOR_200P because the high resolution thumbnail on high density
+// display alleviates the aliasing.
+gfx::Size GetCopySizeForThumbnail(content::RenderWidgetHostView* view) {
+  gfx::Size copy_size(kThumbnailWidth, kThumbnailHeight);
+  ui::ScaleFactor scale_factor =
+      ui::GetScaleFactorForNativeView(view->GetNativeView());
+  switch (scale_factor) {
+    case ui::SCALE_FACTOR_100P:
+      copy_size =
+          copy_size.Scale(ui::GetScaleFactorScale(ui::SCALE_FACTOR_200P));
+      break;
+    case ui::SCALE_FACTOR_200P:
+      // Use the size as-is.
+      break;
+    default:
+      LOG(WARNING) << "Unsupported scale factor. Use the same copy size as "
+                   << "ui::SCALE_FACTOR_100P";
+      copy_size =
+          copy_size.Scale(ui::GetScaleFactorScale(ui::SCALE_FACTOR_200P));
+      break;
+  }
+  return copy_size;
+}
+
+// Returns the size of the thumbnail stored in the database in pixel.
+gfx::Size GetThumbnailSizeInPixel() {
+  gfx::Size thumbnail_size(kThumbnailWidth, kThumbnailHeight);
+  // Determine the resolution of the thumbnail based on the primary monitor.
+  // TODO(oshima): Use device's default scale factor.
+  gfx::Display primary_display = gfx::Screen::GetPrimaryDisplay();
+  return thumbnail_size.Scale(primary_display.device_scale_factor());
+}
+
+// Returns the scrollbar size in DIP.
+int GetScrollbarSize() {
+#if defined(OS_WIN) && !defined(USE_AURA)
+  // On windows gfx::scrollbar_size() returns the size taking into account DPI.
+  return static_cast<int>(std::ceil(gfx::scrollbar_size() / ui::GetDPIScale()));
+#else
+  // TODO(mazda): Revisit Win Aura case
+  return gfx::scrollbar_size();
+#endif
+}
+
+// Returns the scrollbar size in pixel.
+int GetScrollbarSizeInPixel(content::RenderWidgetHostView* view) {
+#if defined(OS_WIN) && !defined(USE_AURA)
+  // On windows gfx::scrollbar_size() returns the size taking into account DPI.
+  return gfx::scrollbar_size();
+#else
+  // TODO(mazda): Revisit Win Aura case
+  float scale_factor = ui::GetScaleFactorScale(ui::GetScaleFactorForNativeView(
+      view->GetNativeView()));
+  return static_cast<int>(scale_factor * gfx::scrollbar_size());
+#endif
 }
 
 // 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);
 
@@ skipping 31 matching lines @@
       *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& bitmap,
-    int desired_width,
-    int desired_height,
+    const gfx::Size& desired_size,
+    int scrollbar_size,
     ThumbnailGenerator::ClipResult* clip_result) {
   base::TimeTicks begin_compute_thumbnail = base::TimeTicks::Now();
 
   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);
 
     clipped_bitmap = ThumbnailGenerator::GetClippedBitmap(
-        bmp, desired_width, desired_height, clip_result);
+        bmp, desired_size.width(), desired_size.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);
+      clipped_bitmap, desired_size.width(), desired_size.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
   // weird PlatformCanvas one insetad of a regular one. To get a
   // regular refcounted bitmap, we need to copy it.
   //
   // On Aura, the PlatformCanvas is platform-independent and does not have
   // any native platform resources that can't be refounted, so this issue does
@@ skipping 328 matching lines @@
                      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();
+  int scrollbar_size = GetScrollbarSize();
   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 =
-      gfx::Size(kThumbnailWidth, kThumbnailHeight).Scale(kThumbnailCopyScale);
+  gfx::Size copy_size = GetCopySizeForThumbnail(view);
   skia::PlatformCanvas* temp_canvas = new skia::PlatformCanvas;
   render_widget_host->CopyFromBackingStore(
       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;
 
-  SkBitmap thumbnail = CreateThumbnail(bitmap,
-                                       kThumbnailWidth,
-                                       kThumbnailHeight,
-                                       &clip_result);
+  SkBitmap thumbnail = CreateThumbnail(
+      bitmap,
+      GetThumbnailSizeInPixel(),
+      GetScrollbarSizeInPixel(web_contents->GetRenderViewHost()->GetView()),
+      &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)
@@ skipping 35 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;
 }