Implement all resolution change policies for desktop and tab capture.

content/browser/media/capture/web_contents_video_capture_device_unittest.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 "content/browser/media/capture/web_contents_video_capture_device.h"
 
 #include "base/bind_helpers.h"
 #include "base/debug/debugger.h"
 #include "base/run_loop.h"
 #include "base/test/test_timeouts.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "content/browser/browser_thread_impl.h"
+#include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/media/capture/video_capture_oracle.h"
 #include "content/browser/media/capture/web_contents_capture_util.h"
 #include "content/browser/renderer_host/media/video_capture_buffer_pool.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
+#include "content/browser/web_contents/web_contents_impl.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "media/base/video_capture_types.h"
@@ skipping 41 matching lines @@
                            yuv, yuv + 1, yuv + 2, 1, 1, 1, 1, 1);
   return SkColorSetRGB(yuv[0], yuv[1], yuv[2]);
 }
 
 // Thread-safe class that controls the source pattern to be captured by the
 // system under test. The lifetime of this class is greater than the lifetime
 // of all objects that reference it, so it does not need to be reference
 // counted.
 class CaptureTestSourceController {
  public:
-
   CaptureTestSourceController()
       : color_(SK_ColorMAGENTA),
         copy_result_size_(kTestWidth, kTestHeight),
         can_copy_to_video_frame_(false),
         use_frame_subscriber_(false) {}
 
   void SetSolidColor(SkColor color) {
     base::AutoLock guard(lock_);
     color_ = color;
   }
@@ skipping 64 matching lines @@
 
 // A stub implementation which returns solid-color bitmaps in calls to
 // CopyFromCompositingSurfaceToVideoFrame(), and which allows the video-frame
 // readback path to be switched on and off. The behavior is controlled by a
 // CaptureTestSourceController.
 class CaptureTestView : public TestRenderWidgetHostView {
  public:
   explicit CaptureTestView(RenderWidgetHostImpl* rwh,
                            CaptureTestSourceController* controller)
       : TestRenderWidgetHostView(rwh),
-        controller_(controller) {}
+        controller_(controller),
+        fake_bounds_(100, 100, 100 + kTestWidth, 100 + kTestHeight) {}
 
   ~CaptureTestView() override {}
 
   // TestRenderWidgetHostView overrides.
   gfx::Rect GetViewBounds() const override {
-    return gfx::Rect(100, 100, 100 + kTestWidth, 100 + kTestHeight);
+    return fake_bounds_;
+  }
+
+  void SetSize(const gfx::Size& size) override {
+    SetBounds(gfx::Rect(fake_bounds_.origin(), size));
+  }
+
+  void SetBounds(const gfx::Rect& rect) override {
+    fake_bounds_ = rect;
   }
 
   bool CanCopyToVideoFrame() const override {
     return controller_->CanCopyToVideoFrame();
   }
 
   void CopyFromCompositingSurfaceToVideoFrame(
       const gfx::Rect& src_subrect,
       const scoped_refptr<media::VideoFrame>& target,
       const base::Callback<void(bool)>& callback) override {
@@ skipping 24 matching lines @@
       BrowserThread::PostTask(BrowserThread::UI,
                               FROM_HERE,
                               base::Bind(callback, present_time, true));
       controller_->SignalCopy();
     }
   }
 
  private:
   scoped_ptr<RenderWidgetHostViewFrameSubscriber> subscriber_;
   CaptureTestSourceController* const controller_;
+  gfx::Rect fake_bounds_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestView);
 };
 
 #if defined(COMPILER_MSVC)
 // MSVC warns on diamond inheritance. See comment for same warning on
 // RenderViewHostImpl.
 #pragma warning(push)
 #pragma warning(disable: 4250)
 #endif
@@ skipping 75 matching lines @@
  private:
   CaptureTestSourceController* controller_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CaptureTestRenderViewHostFactory);
 };
 
 // A stub consumer of captured video frames, which checks the output of
 // WebContentsVideoCaptureDevice.
 class StubClient : public media::VideoCaptureDevice::Client {
  public:
-  StubClient(const base::Callback<void(SkColor)>& color_callback,
-             const base::Closure& error_callback)
-      : color_callback_(color_callback),
+  StubClient(
+      const base::Callback<void(SkColor, const gfx::Size&)>& report_callback,
+      const base::Closure& error_callback)
+      : report_callback_(report_callback),
         error_callback_(error_callback) {
     buffer_pool_ = new VideoCaptureBufferPool(2);
   }
   ~StubClient() override {}
 
   MOCK_METHOD5(OnIncomingCapturedData,
                void(const uint8* data,
                     int length,
                     const media::VideoCaptureFormat& frame_format,
                     int rotation,
@@ skipping 29 matching lines @@
   void OnIncomingCapturedBuffer(scoped_ptr<Buffer> buffer,
                                 const media::VideoCaptureFormat& frame_format,
                                 const base::TimeTicks& timestamp) override {
     DoOnIncomingCapturedBuffer();
   }
 
   void OnIncomingCapturedVideoFrame(
       scoped_ptr<Buffer> buffer,
       const scoped_refptr<media::VideoFrame>& frame,
       const base::TimeTicks& timestamp) override {
-    EXPECT_EQ(gfx::Size(kTestWidth, kTestHeight), frame->visible_rect().size());
+    EXPECT_FALSE(frame->visible_rect().IsEmpty());
     EXPECT_EQ(media::VideoFrame::I420, frame->format());
     double frame_rate = 0;
     EXPECT_TRUE(
         frame->metadata()->GetDouble(media::VideoFrameMetadata::FRAME_RATE,
                                      &frame_rate));
     EXPECT_EQ(kTestFramesPerSecond, frame_rate);
-    uint8 yuv[3];
-    for (int plane = 0; plane < 3; ++plane)
-      yuv[plane] = frame->visible_data(plane)[0];
-    // TODO(nick): We just look at the first pixel presently, because if
-    // the analysis is too slow, the backlog of frames will grow without bound
-    // and trouble erupts. http://crbug.com/174519
-    color_callback_.Run((SkColorSetRGB(yuv[0], yuv[1], yuv[2])));
+
+    // TODO(miu): We just look at the center pixel presently, because if the
+    // analysis is too slow, the backlog of frames will grow without bound and
+    // trouble erupts. http://crbug.com/174519
+    using media::VideoFrame;
+    const gfx::Point center = frame->visible_rect().CenterPoint();
+    const int center_offset_y =
+        (frame->stride(VideoFrame::kYPlane) * center.y()) + center.x();
+    const int center_offset_uv =
+        (frame->stride(VideoFrame::kUPlane) * (center.y() / 2)) +
+            (center.x() / 2);
+    report_callback_.Run(
+        SkColorSetRGB(frame->data(VideoFrame::kYPlane)[center_offset_y],
+                      frame->data(VideoFrame::kUPlane)[center_offset_uv],
+                      frame->data(VideoFrame::kVPlane)[center_offset_uv]),
+        frame->visible_rect().size());
   }
 
   void OnError(const std::string& reason) override { error_callback_.Run(); }
 
  private:
   class AutoReleaseBuffer : public media::VideoCaptureDevice::Client::Buffer {
    public:
     AutoReleaseBuffer(
         const scoped_refptr<VideoCaptureBufferPool>& pool,
         scoped_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle,
@@ skipping 13 matching lines @@
 
    private:
     ~AutoReleaseBuffer() override { pool_->RelinquishProducerReservation(id_); }
 
     const int id_;
     const scoped_refptr<VideoCaptureBufferPool> pool_;
     const scoped_ptr<VideoCaptureBufferPool::BufferHandle> buffer_handle_;
   };
 
   scoped_refptr<VideoCaptureBufferPool> buffer_pool_;
-  base::Callback<void(SkColor)> color_callback_;
+  base::Callback<void(SkColor, const gfx::Size&)> report_callback_;
   base::Closure error_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(StubClient);
 };
 
 class StubClientObserver {
  public:
   StubClientObserver()
       : error_encountered_(false),
-        wait_color_yuv_(0xcafe1950) {
+        wait_color_yuv_(0xcafe1950),
+        wait_size_(kTestWidth, kTestHeight) {
     client_.reset(new StubClient(
-        base::Bind(&StubClientObserver::OnColor, base::Unretained(this)),
+        base::Bind(&StubClientObserver::DidDeliverFrame,
+                   base::Unretained(this)),
         base::Bind(&StubClientObserver::OnError, base::Unretained(this))));
   }
 
   virtual ~StubClientObserver() {}
 
   scoped_ptr<media::VideoCaptureDevice::Client> PassClient() {
     return client_.Pass();
   }
 
-  void QuitIfConditionMet(SkColor color) {
+  void QuitIfConditionsMet(SkColor color, const gfx::Size& size) {
     base::AutoLock guard(lock_);
-    if (wait_color_yuv_ == color || error_encountered_)
+    if (error_encountered_)
+      base::MessageLoop::current()->Quit();
+    else if (wait_color_yuv_ == color && wait_size_.IsEmpty())
+      base::MessageLoop::current()->Quit();
+    else if (wait_color_yuv_ == color && wait_size_ == size)
       base::MessageLoop::current()->Quit();
   }
 
+  // Run the current loop until a frame is delivered with the |expected_color|
+  // and any non-empty frame size.
   void WaitForNextColor(SkColor expected_color) {
+    WaitForNextColorAndFrameSize(expected_color, gfx::Size());
+  }
+
+  // Run the current loop until a frame is delivered with the |expected_color|
+  // and is of the |expected_size|.
+  void WaitForNextColorAndFrameSize(SkColor expected_color,
+                                    const gfx::Size& expected_size) {
     {
       base::AutoLock guard(lock_);
       wait_color_yuv_ = ConvertRgbToYuv(expected_color);
+      wait_size_ = expected_size;
       error_encountered_ = false;
     }
     RunCurrentLoopWithDeadline();
     {
       base::AutoLock guard(lock_);
       ASSERT_FALSE(error_encountered_);
     }
   }
 
   void WaitForError() {
     {
       base::AutoLock guard(lock_);
       wait_color_yuv_ = kNotInterested;
+      wait_size_ = gfx::Size();
       error_encountered_ = false;
     }
     RunCurrentLoopWithDeadline();
     {
       base::AutoLock guard(lock_);
       ASSERT_TRUE(error_encountered_);
     }
   }
 
   bool HasError() {
     base::AutoLock guard(lock_);
     return error_encountered_;
   }
 
   void OnError() {
     {
       base::AutoLock guard(lock_);
       error_encountered_ = true;
     }
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-        &StubClientObserver::QuitIfConditionMet,
+        &StubClientObserver::QuitIfConditionsMet,
         base::Unretained(this),
-        kNothingYet));
+        kNothingYet,
+        gfx::Size()));
   }
 
-  void OnColor(SkColor color) {
+  void DidDeliverFrame(SkColor color, const gfx::Size& size) {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-        &StubClientObserver::QuitIfConditionMet,
+        &StubClientObserver::QuitIfConditionsMet,
         base::Unretained(this),
-        color));
+        color,
+        size));
   }
 
  private:
   base::Lock lock_;
   bool error_encountered_;
   SkColor wait_color_yuv_;
+  gfx::Size wait_size_;
   scoped_ptr<StubClient> client_;
 
   DISALLOW_COPY_AND_ASSIGN(StubClientObserver);
 };
 
 // A dummy implementation of gfx::Screen, since WebContentsVideoCaptureDevice
 // needs access to a gfx::Display's device scale factor.
 class FakeScreen : public gfx::Screen {
  public:
   FakeScreen() : the_one_display_(0x1337, gfx::Rect(0, 0, 2560, 1440)) {
@@ skipping 114 matching lines @@
       test_view->SimulateUpdate();
     } else {
       // Simulate a non-accelerated paint.
       NotificationService::current()->Notify(
           NOTIFICATION_RENDER_WIDGET_HOST_DID_UPDATE_BACKING_STORE,
           Source<RenderWidgetHost>(web_contents_->GetRenderViewHost()),
           NotificationService::NoDetails());
     }
   }
 
+  void SimulateSourceSizeChange(const gfx::Size& size) {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    CaptureTestView* test_view = static_cast<CaptureTestView*>(
+        web_contents_->GetRenderViewHost()->GetView());
+    test_view->SetSize(size);
+    // Normally, RenderWidgetHostImpl would notify WebContentsImpl that the size
+    // has changed.  However, in this test setup where there is no render
+    // process, we must notify WebContentsImpl directly.
+    WebContentsImpl* const as_web_contents_impl =
+        static_cast<WebContentsImpl*>(web_contents_.get());
+    RenderWidgetHostDelegate* const as_rwh_delegate =
+        static_cast<RenderWidgetHostDelegate*>(as_web_contents_impl);
+    as_rwh_delegate->RenderWidgetWasResized(
+        as_web_contents_impl->GetMainFrame()->GetRenderWidgetHost(), true);
+  }
+
   void DestroyVideoCaptureDevice() { device_.reset(); }
 
   StubClientObserver* client_observer() {
     return &client_observer_;
   }
 
  private:
   FakeScreen fake_screen_;
 
   StubClientObserver client_observer_;
@@ skipping 237 matching lines @@
   // Now push some good frames through; they should be processed normally.
   source()->SetCopyResultSize(kTestWidth, kTestHeight);
   source()->SetSolidColor(SK_ColorGREEN);
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
   source()->SetSolidColor(SK_ColorRED);
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 
   device()->StopAndDeAllocate();
 }
 
+// Tests that, when configured with the FIXED_ASPECT_RATIO resolution change
+// policy, the source size changes result in video frames of possibly varying
+// resolutions, but all with the same aspect ratio.
+TEST_F(WebContentsVideoCaptureDeviceTest, VariableResolution_FixedAspectRatio) {
+  media::VideoCaptureParams capture_params;
+  capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
+  capture_params.requested_format.frame_rate = kTestFramesPerSecond;
+  capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
+  capture_params.resolution_change_policy =
+      media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
+
+  device()->AllocateAndStart(capture_params, client_observer()->PassClient());
+
+  for (int i = 0; i < 6; i++) {
+    const char* name = NULL;
+    switch (i % 3) {
+      case 0:
+        source()->SetCanCopyToVideoFrame(true);
+        source()->SetUseFrameSubscriber(false);
+        name = "VideoFrame";
+        break;
+      case 1:
+        source()->SetCanCopyToVideoFrame(false);
+        source()->SetUseFrameSubscriber(true);
+        name = "Subscriber";
+        break;
+      case 2:
+        source()->SetCanCopyToVideoFrame(false);
+        source()->SetUseFrameSubscriber(false);
+        name = "SkBitmap";
+        break;
+      default:
+        FAIL();
+    }
+
+    SCOPED_TRACE(base::StringPrintf("Using %s path, iteration #%d", name, i));
+
+    // Source size equals maximum size.  Expect delivered frames to be
+    // kTestWidth by kTestHeight.
+    source()->SetSolidColor(SK_ColorRED);
+    SimulateSourceSizeChange(gfx::Size(kTestWidth, kTestHeight));
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorRED, gfx::Size(kTestWidth, kTestHeight)));
+
+    // Source size is half in both dimensions.  Expect delivered frames to be of
+    // the same aspect ratio as kTestWidth by kTestHeight, but larger than the
+    // half size because the minimum height is 180 lines.
+    source()->SetSolidColor(SK_ColorGREEN);
+    SimulateSourceSizeChange(gfx::Size(kTestWidth / 2, kTestHeight / 2));
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorGREEN, gfx::Size(180 * kTestWidth / kTestHeight, 180)));
+
+    // Source size changes aspect ratio.  Expect delivered frames to be padded
+    // in the horizontal dimension to preserve aspect ratio.
+    source()->SetSolidColor(SK_ColorBLUE);
+    SimulateSourceSizeChange(gfx::Size(kTestWidth / 2, kTestHeight));
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorBLUE, gfx::Size(kTestWidth, kTestHeight)));
+
+    // Source size changes aspect ratio again.  Expect delivered frames to be
+    // padded in the vertical dimension to preserve aspect ratio.
+    source()->SetSolidColor(SK_ColorBLACK);
+    SimulateSourceSizeChange(gfx::Size(kTestWidth, kTestHeight / 2));
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorBLACK, gfx::Size(kTestWidth, kTestHeight)));
+  }
+
+  device()->StopAndDeAllocate();
+}
+
+// Tests that, when configured with the ANY_WITHIN_LIMIT resolution change
+// policy, the source size changes result in video frames of possibly varying
+// resolutions.
+TEST_F(WebContentsVideoCaptureDeviceTest, VariableResolution_AnyWithinLimits) {
+  media::VideoCaptureParams capture_params;
+  capture_params.requested_format.frame_size.SetSize(kTestWidth, kTestHeight);
+  capture_params.requested_format.frame_rate = kTestFramesPerSecond;
+  capture_params.requested_format.pixel_format = media::PIXEL_FORMAT_I420;
+  capture_params.resolution_change_policy =
+      media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
+
+  device()->AllocateAndStart(capture_params, client_observer()->PassClient());
+
+  for (int i = 0; i < 6; i++) {
+    const char* name = NULL;
+    switch (i % 3) {
+      case 0:
+        source()->SetCanCopyToVideoFrame(true);
+        source()->SetUseFrameSubscriber(false);
+        name = "VideoFrame";
+        break;
+      case 1:
+        source()->SetCanCopyToVideoFrame(false);
+        source()->SetUseFrameSubscriber(true);
+        name = "Subscriber";
+        break;
+      case 2:
+        source()->SetCanCopyToVideoFrame(false);
+        source()->SetUseFrameSubscriber(false);
+        name = "SkBitmap";
+        break;
+      default:
+        FAIL();
+    }
+
+    SCOPED_TRACE(base::StringPrintf("Using %s path, iteration #%d", name, i));
+
+    // Source size equals maximum size.  Expect delivered frames to be
+    // kTestWidth by kTestHeight.
+    source()->SetSolidColor(SK_ColorRED);
+    SimulateSourceSizeChange(gfx::Size(kTestWidth, kTestHeight));
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorRED, gfx::Size(kTestWidth, kTestHeight)));
+
+    // Source size is half in both dimensions.  Expect delivered frames to also
+    // be half in both dimensions.
+    source()->SetSolidColor(SK_ColorGREEN);
+    SimulateSourceSizeChange(gfx::Size(kTestWidth / 2, kTestHeight / 2));
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorGREEN, gfx::Size(kTestWidth / 2, kTestHeight / 2)));
+
+    // Source size changes to something arbitrary.  Since the source size is
+    // less than the maximum size, expect delivered frames to be the same size
+    // as the source size.
+    source()->SetSolidColor(SK_ColorBLUE);
+    gfx::Size arbitrary_source_size(kTestWidth / 2 + 42, kTestHeight - 10);
+    SimulateSourceSizeChange(arbitrary_source_size);
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorBLUE, arbitrary_source_size));
+
+    // Source size changes to something arbitrary that exceeds the maximum frame
+    // size.  Since the source size exceeds the maximum size, expect delivered
+    // frames to be downscaled.
+    source()->SetSolidColor(SK_ColorBLACK);
+    arbitrary_source_size = gfx::Size(kTestWidth * 2 + 99, kTestHeight / 2);
+    SimulateSourceSizeChange(arbitrary_source_size);
+    SimulateDrawEvent();
+    ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColorAndFrameSize(
+        SK_ColorBLACK, gfx::Size(kTestWidth,
+                                 kTestWidth * arbitrary_source_size.height() /
+                                     arbitrary_source_size.width())));
+  }
+
+  device()->StopAndDeAllocate();
+}
+
 }  // namespace
 }  // namespace content