Implement all resolution change policies for desktop and 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 61 matching lines @@
 #include "content/public/browser/render_process_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.h"
 #include "media/base/video_capture_types.h"
 #include "media/base/video_util.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::Rect& visible_rect,
-                                     const gfx::Size& content_size) {
-
-  gfx::Rect result = media::ComputeLetterboxRegion(visible_rect, content_size);
-
-  result.set_x(MakeEven(result.x()));
-  result.set_y(MakeEven(result.y()));
-  result.set_width(std::max(kMinFrameWidth, MakeEven(result.width())));
-  result.set_height(std::max(kMinFrameHeight, MakeEven(result.height())));
-
-  return result;
-}
-
 void DeleteOnWorkerThread(scoped_ptr<base::Thread> render_thread,
                           const base::Closure& callback) {
   render_thread.reset();
 
   // After thread join call the callback on UI thread.
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
 
 // Responsible for logging the effective frame rate.
 class VideoFrameDeliveryLog {
@@ skipping 136 matching lines @@
   // Response callback for RWHVP::CopyFromCompositingSurfaceToVideoFrame().
   void DidCopyFromCompositingSurfaceToVideoFrame(
       const base::TimeTicks& start_time,
       const RenderWidgetHostViewFrameSubscriber::DeliverFrameCallback&
           deliver_frame_cb,
       bool success);
 
   // Remove the old subscription, and start a new one if |rwh| is not NULL.
   void RenewFrameSubscription(RenderWidgetHost* rwh);
 
+  // Called whenever the render widget is resized.
+  void UpdateCaptureSize(RenderWidgetHost* rwh);
+
   // Parameters saved in constructor.
   const int initial_render_process_id_;
   const int initial_main_render_frame_id_;
 
   // Tracks events and calls back to RenewFrameSubscription() to maintain
   // capture on the correct RenderWidgetHost.
   const scoped_refptr<WebContentsTracker> tracker_;
 
   // A dedicated worker thread on which SkBitmap->VideoFrame conversion will
   // occur. Only used when this activity cannot be done on the GPU.
@@ skipping 119 matching lines @@
   }
 
   // Sanity-check the output buffer.
   if (output->format() != media::VideoFrame::I420) {
     NOTREACHED();
     return;
   }
 
   // Calculate the width and height of the content region in the |output|, based
   // on the aspect ratio of |input|.
-  gfx::Rect region_in_frame = ComputeYV12LetterboxRegion(
+  const gfx::Rect region_in_frame = media::ComputeLetterboxRegion(
       output->visible_rect(), gfx::Size(input.width(), input.height()));
 
   // Scale the bitmap to the required size, if necessary.
   SkBitmap scaled_bitmap;
   if (input.width() != region_in_frame.width() ||
       input.height() != region_in_frame.height()) {
 
     skia::ImageOperations::ResizeMethod method;
     if (input.width() < region_in_frame.width() ||
         input.height() < region_in_frame.height()) {
       // Avoid box filtering when magnifying, because it's actually
       // nearest-neighbor.
       method = skia::ImageOperations::RESIZE_HAMMING1;
     } else {
       method = skia::ImageOperations::RESIZE_BOX;
     }
 
     TRACE_EVENT_ASYNC_STEP_INTO0("gpu.capture",
                                  "Capture", output.get(), "Scale");
     scaled_bitmap = skia::ImageOperations::Resize(input, method,
                                                   region_in_frame.width(),
                                                   region_in_frame.height());
   } else {
     scaled_bitmap = input;
   }
 
   TRACE_EVENT_ASYNC_STEP_INTO0("gpu.capture", "Capture", output.get(), "YUV");
   {
+    // Align to 2x2 pixel boundaries, as required by
+    // media::CopyRGBToVideoFrame().
+    const gfx::Rect region_in_yv12_frame(region_in_frame.x() & ~1,
+                                         region_in_frame.y() & ~1,
+                                         region_in_frame.width() & ~1,
+                                         region_in_frame.height() & ~1);
+    if (region_in_yv12_frame.IsEmpty())
+      return;
+
     SkAutoLockPixels scaled_bitmap_locker(scaled_bitmap);
-
     media::CopyRGBToVideoFrame(
         reinterpret_cast<uint8*>(scaled_bitmap.getPixels()),
         scaled_bitmap.rowBytes(),
-        region_in_frame,
+        region_in_yv12_frame,
         output.get());
   }
 
   // The result is now ready.
   ignore_result(failure_handler.Release());
   done_cb.Run(true);
 }
 
 VideoFrameDeliveryLog::VideoFrameDeliveryLog()
     : last_frame_rate_log_time_(),
@@ skipping 50 matching lines @@
 
   render_thread_.reset(new base::Thread("WebContentsVideo_RenderThread"));
   if (!render_thread_->Start()) {
     DVLOG(1) << "Failed to spawn render thread.";
     render_thread_.reset();
     return false;
   }
 
   // Note: Creation of the first WeakPtr in the following statement will cause
   // IsStarted() to return true from now on.
+  tracker_->SetResizeChangeCallback(
+      base::Bind(&WebContentsCaptureMachine::UpdateCaptureSize,
+                 weak_ptr_factory_.GetWeakPtr()));
   tracker_->Start(initial_render_process_id_, initial_main_render_frame_id_,
                   base::Bind(&WebContentsCaptureMachine::RenewFrameSubscription,
                              weak_ptr_factory_.GetWeakPtr()));
 
   return true;
 }
 
 void WebContentsCaptureMachine::Stop(const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 30 matching lines @@
 
   RenderWidgetHost* rwh = tracker_->GetTargetRenderWidgetHost();
   RenderWidgetHostViewBase* view =
       rwh ? static_cast<RenderWidgetHostViewBase*>(rwh->GetView()) : NULL;
   if (!view) {
     deliver_frame_cb.Run(base::TimeTicks(), false);
     return;
   }
 
   gfx::Size view_size = view->GetViewBounds().size();
-  gfx::Size fitted_size;
-  if (!view_size.IsEmpty()) {
-    fitted_size = ComputeYV12LetterboxRegion(target->visible_rect(),
-                                             view_size).size();
-  }
   if (view_size != last_view_size_) {
     last_view_size_ = view_size;
 
     // Measure the number of kilopixels.
     UMA_HISTOGRAM_COUNTS_10000(
         "TabCapture.ViewChangeKiloPixels",
         view_size.width() * view_size.height() / 1024);
   }
 
   if (view->CanCopyToVideoFrame()) {
     view->CopyFromCompositingSurfaceToVideoFrame(
         gfx::Rect(view_size),
         target,
         base::Bind(&WebContentsCaptureMachine::
                         DidCopyFromCompositingSurfaceToVideoFrame,
                    weak_ptr_factory_.GetWeakPtr(),
                    start_time, deliver_frame_cb));
   } else {
+    const gfx::Size fitted_size = view_size.IsEmpty() ? gfx::Size() :
+        media::ComputeLetterboxRegion(target->visible_rect(), view_size).size();
     rwh->CopyFromBackingStore(
         gfx::Rect(),
         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_CURRENTLY_ON(BrowserThread::UI);
 
-  gfx::Size optimal_size = oracle_proxy_->GetCaptureSize();
+  // TODO(miu): Propagate capture frame size changes as new "preferred size"
+  // updates, rather than just using the max frame size.  This value here
+  // determines the size of the fullscreen-within-tab widget.
+  gfx::Size optimal_size = oracle_proxy_->max_frame_size();
 
   // 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 = tracker_->GetTargetRenderWidgetHost();
   RenderWidgetHostView* const rwhv = rwh ? rwh->GetView() : NULL;
   if (rwhv) {
     const gfx::NativeView view = rwhv->GetNativeView();
@@ skipping 78 matching lines @@
   if (!had_subscription && tracker_->web_contents()) {
     tracker_->web_contents()->IncrementCapturerCount(
         ComputeOptimalTargetSize());
   }
 
   subscription_.reset(new ContentCaptureSubscription(*rwh, oracle_proxy_,
       base::Bind(&WebContentsCaptureMachine::Capture,
                  weak_ptr_factory_.GetWeakPtr())));
 }
 
+void WebContentsCaptureMachine::UpdateCaptureSize(RenderWidgetHost* rwh) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (!oracle_proxy_)
+    return;
+  RenderWidgetHostView* const view = rwh ? rwh->GetView() : nullptr;
+  if (!view)
+    return;
+  oracle_proxy_->UpdateCaptureSize(view->GetViewBounds().size());
+}
+
 }  // namespace
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
     int render_process_id, int main_render_frame_id)
     : core_(new ContentVideoCaptureDeviceCore(scoped_ptr<VideoCaptureMachine>(
         new WebContentsCaptureMachine(
             render_process_id, main_render_frame_id)))) {}
 
 WebContentsVideoCaptureDevice::~WebContentsVideoCaptureDevice() {
   DVLOG(2) << "WebContentsVideoCaptureDevice@" << this << " destroying.";
@@ skipping 19 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