Account for DIP when setting the preferred size for tab capture.

content/browser/media/capture/web_contents_video_capture_device.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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance. Spanning several threads, the process of capturing has been
 // split up into four conceptual stages:
 //
 //   1. Reserve Buffer: Before a frame can be captured, a slot in the client's
@@ skipping 62 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "media/base/video_util.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "ui/gfx/display.h"
+#include "ui/gfx/geometry/size.h"
+#include "ui/gfx/geometry/size_conversions.h"
+#include "ui/gfx/screen.h"
 
 namespace content {
 
 namespace {
 
 // Compute a letterbox region, aligned to even coordinates.
 gfx::Rect ComputeYV12LetterboxRegion(const gfx::Size& frame_size,
                                      const gfx::Size& content_size) {
 
   gfx::Rect result = media::ComputeLetterboxRegion(gfx::Rect(frame_size),
@@ skipping 173 matching lines @@
 
   virtual void DidNavigateMainFrame(
       const LoadCommittedDetails& details,
       const FrameNavigateParams& params) OVERRIDE {
     RenewFrameSubscription();
   }
 
   virtual void WebContentsDestroyed() OVERRIDE;
 
  private:
+  // Computes the preferred size of the target RenderWidget for optimal capture.
+  gfx::Size ComputeOptimalTargetSize() const;
+
   // Starts observing the web contents, returning false if lookup fails.
   bool StartObservingWebContents();
 
   // Helper function to determine the view that we are currently tracking.
-  RenderWidgetHost* GetTarget();
+  RenderWidgetHost* GetTarget() const;
 
   // Response callback for RenderWidgetHost::CopyFromBackingStore().
   void DidCopyFromBackingStore(
       const base::TimeTicks& start_time,
       const scoped_refptr<media::VideoFrame>& target,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
           deliver_frame_cb,
       bool success,
       const SkBitmap& bitmap);
 
@@ skipping 377 matching lines @@
         fitted_size,  // Size here is a request not always honored.
         base::Bind(&WebContentsCaptureMachine::DidCopyFromBackingStore,
                    weak_ptr_factory_.GetWeakPtr(),
                    start_time,
                    target,
                    deliver_frame_cb),
         kN32_SkColorType);
   }
 }
 
+gfx::Size WebContentsCaptureMachine::ComputeOptimalTargetSize() const {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  gfx::Size optimal_size = oracle_proxy_->GetCaptureSize();
+
+  // If the ratio between physical and logical pixels is greater than 1:1,
+  // shrink |optimal_size| by that amount.  Then, when external code resizes the
+  // render widget to the "preferred size," the widget will be physically
+  // rendered at the exact capture size, thereby eliminating unnecessary scaling
+  // operations in the graphics pipeline.
+  RenderWidgetHost* const rwh = GetTarget();
+  RenderWidgetHostView* const rwhv = rwh ? rwh->GetView() : NULL;
+  if (rwhv) {
+    const gfx::NativeView view = rwhv->GetNativeView();
+    gfx::Screen* const screen = gfx::Screen::GetScreenFor(view);
+    if (screen->IsDIPEnabled()) {
+      const gfx::Display display = screen->GetDisplayNearestWindow(view);
+      const float scale = display.device_scale_factor();
+      if (scale > 1.0f) {
+        const gfx::Size shrunk_size(
+            gfx::ToFlooredSize(gfx::ScaleSize(optimal_size, 1.0f / scale)));
+        if (shrunk_size.width() > 0 && shrunk_size.height() > 0)
+          optimal_size = shrunk_size;
+      }
+    }
+  }
+
+  VLOG(1) << "Computed optimal target size: " << optimal_size.ToString();
+  return optimal_size;
+}
+
 bool WebContentsCaptureMachine::StartObservingWebContents() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
   // Look-up the RenderFrameHost and, from that, the WebContents that wraps it.
   // If successful, begin observing the WebContents instance.
   //
   // Why this can be unsuccessful: The request for mirroring originates in a
   // render process, and this request is based on the current main RenderFrame
   // associated with a tab.  However, by the time we get up-and-running here,
   // there have been multiple back-and-forth IPCs between processes, as well as
   // a bit of indirection across threads.  It's easily possible that, in the
   // meantime, the original RenderFrame may have gone away.
   Observe(WebContents::FromRenderFrameHost(RenderFrameHost::FromID(
       initial_render_process_id_, initial_main_render_frame_id_)));
   DVLOG_IF(1, !web_contents())
       << "Could not find WebContents associated with main RenderFrameHost "
       << "referenced by render_process_id=" << initial_render_process_id_
       << ", routing_id=" << initial_main_render_frame_id_;
 
   WebContentsImpl* contents = static_cast<WebContentsImpl*>(web_contents());
   if (contents) {
-    contents->IncrementCapturerCount(oracle_proxy_->GetCaptureSize());
+    contents->IncrementCapturerCount(ComputeOptimalTargetSize());
     fullscreen_widget_id_ = contents->GetFullscreenWidgetRoutingID();
     RenewFrameSubscription();
     return true;
   }
   return false;
 }
 
 void WebContentsCaptureMachine::WebContentsDestroyed() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   subscription_.reset();
   web_contents()->DecrementCapturerCount();
   oracle_proxy_->ReportError("WebContentsDestroyed()");
 }
 
-RenderWidgetHost* WebContentsCaptureMachine::GetTarget() {
+RenderWidgetHost* WebContentsCaptureMachine::GetTarget() const {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!web_contents())
     return NULL;
 
   RenderWidgetHost* rwh = NULL;
   if (fullscreen_widget_id_ != MSG_ROUTING_NONE) {
     RenderProcessHost* process = web_contents()->GetRenderProcessHost();
     if (process)
       rwh = RenderWidgetHost::FromID(process->GetID(), fullscreen_widget_id_);
   } else {
@@ skipping 92 matching lines @@
     scoped_ptr<Client> client) {
   DVLOG(1) << "Allocating " << params.requested_format.frame_size.ToString();
   core_->AllocateAndStart(params, client.Pass());
 }
 
 void WebContentsVideoCaptureDevice::StopAndDeAllocate() {
   core_->StopAndDeAllocate();
 }
 
 }  // namespace content