getUserMedia: handle the device starting status report.

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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 276 matching lines @@
       gfx::Rect visible_rect,
       const media::VideoFrameMetadata& additional_metadata) override {
     EXPECT_FALSE(visible_rect.IsEmpty());
     EXPECT_EQ(media::PIXEL_FORMAT_I420, format.pixel_format);
     EXPECT_EQ(kTestFramesPerSecond, format.frame_rate);
 
     // 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;
-    auto buffer_access = buffer.handle_provider->GetHandleForInProcessAccess();
-    auto frame = VideoFrame::WrapExternalSharedMemory(
-        media::PIXEL_FORMAT_I420, format.frame_size, visible_rect,
-        format.frame_size, buffer_access->data(), buffer_access->mapped_size(),
-        base::SharedMemory::NULLHandle(), 0u, base::TimeDelta());
+    std::unique_ptr<media::VideoCaptureBufferHandle> buffer_access =
+        buffer.handle_provider->GetHandleForInProcessAccess();
+    scoped_refptr<media::VideoFrame> frame =
+        VideoFrame::WrapExternalSharedMemory(
+            media::PIXEL_FORMAT_I420, format.frame_size, visible_rect,
+            format.frame_size, buffer_access->data(),
+            buffer_access->mapped_size(), base::SharedMemory::NULLHandle(), 0u,
+            base::TimeDelta());
     const gfx::Point center = 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]),
@@ skipping 235 matching lines @@
 
     // Schedule the update to occur when the test runs the event loop (and not
     // before expectations have been set).
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::Bind(&CaptureTestView::SimulateUpdate,
                                        base::Unretained(test_view())));
   }
 
   void SimulateSourceSizeChange(const gfx::Size& size) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
-    auto* const view = test_view();
+    CaptureTestView* const view = test_view();
     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);
   }
 
   // Repeatedly schedules draw events and scans for frames until the output from
   // the capture device matches the given RGB |color| and frame |size|.
   void SimulateDrawsUntilNewFrameSizeArrives(SkColor color,
                                              const gfx::Size& size) {
     const base::TimeTicks start_time = base::TimeTicks::Now();
     while ((base::TimeTicks::Now() - start_time) <
                TestTimeouts::action_max_timeout()) {
       SimulateDrawEvent();
-      const auto color_and_size = client_observer()->WaitForNextFrame();
+      const std::pair<SkColor, gfx::Size>& color_and_size =
+          client_observer()->WaitForNextFrame();
       if (color_and_size.first == ConvertRgbToYuv(color) &&
           color_and_size.second == size) {
         return;
       }
     }
     DeadlineExceeded(base::Closure());
   }
 
   void SimulateRefreshFrameRequest() {
     // Force at least three frame period's worth of time to pass. The wait is
@@ skipping 47 matching lines @@
   std::unique_ptr<media::VideoCaptureDevice> device_;
 };
 
 // In real-world use cases, there can exist a race condition between starting
 // capture on a WebContents and having the WebContents be destroyed in the
 // meantime. This tests that WebContentsVideoCaptureDevice errors-out
 // gracefully.
 TEST_F(WebContentsVideoCaptureDeviceTest,
        SafelyStartsUpAfterWebContentsHasGone) {
   ResetWebContents();
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(DefaultCaptureParams(), std::move(client));
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForError());
   device()->StopAndDeAllocate();
 }
 
 // Tests that WebContentsVideoCaptureDevice starts, captures a frame, and then
 // gracefully errors-out if the WebContents is destroyed before the device is
 // stopped.
 TEST_F(WebContentsVideoCaptureDeviceTest,
        RunsThenErrorsOutWhenWebContentsIsDestroyed) {
   // We'll simulate the tab being closed after the capture pipeline is up and
   // running.
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(DefaultCaptureParams(), std::move(client));
 
   // Do one capture to prove the tab is initially open and being captured
   // normally.
   test_view()->SetSolidColor(SK_ColorRED);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 
   base::RunLoop().RunUntilIdle();
@@ skipping 25 matching lines @@
   // wind up in the idle state.
   base::RunLoop().RunUntilIdle();
 }
 
 // Tests that frames are delivered to different clients across restarts of the
 // same instance.
 TEST_F(WebContentsVideoCaptureDeviceTest,
        DeliversToCorrectClientAcrossRestarts) {
   // While the device is up-and-running, expect frame captures.
   client_observer()->SetIsExpectingFrames(true);
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(DefaultCaptureParams(), std::move(client));
   base::RunLoop().RunUntilIdle();
   test_view()->SetSolidColor(SK_ColorRED);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
   SimulateDrawEvent();
   test_view()->SetSolidColor(SK_ColorGREEN);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
   SimulateDrawEvent();
   device()->StopAndDeAllocate();
 
   base::RunLoop().RunUntilIdle();
 
   // Now that the device is stopped, expect frames are no longer captured.
   client_observer()->SetIsExpectingFrames(false);
   SimulateDrawEvent();
   SimulateDrawEvent();
   base::RunLoop().RunUntilIdle();
 
   // Re-start the device with a different client. Only the second client should
   // expect to see any frame captures.
   StubClientObserver observer2;
   observer2.SetIsExpectingFrames(true);
-  auto client2 = observer2.PassClient();
+  std::unique_ptr<StubClient> client2 = observer2.PassClient();
   EXPECT_CALL(*client2, OnStarted());
   device()->AllocateAndStart(DefaultCaptureParams(), std::move(client2));
   test_view()->SetSolidColor(SK_ColorBLUE);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(observer2.WaitForNextColor(SK_ColorBLUE));
   test_view()->SetSolidColor(SK_ColorYELLOW);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(observer2.WaitForNextColor(SK_ColorYELLOW));
   device()->StopAndDeAllocate();
 }
 
 // The "happy case" test.  No scaling is needed, so we should be able to change
 // the picture emitted from the source and expect to see each delivered to the
 // consumer. The test will alternate between the RGB/SkBitmap and YUV/VideoFrame
 // capture paths.
 TEST_F(WebContentsVideoCaptureDeviceTest, GoesThroughAllTheMotions) {
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(DefaultCaptureParams(), std::move(client));
 
   for (int i = 0; i < 3; i++) {
     SCOPED_TRACE(base::StringPrintf("Iteration #%d", i));
 
     test_view()->SetSolidColor(SK_ColorRED);
     for (int j = 0; j <= i; j++)
       SimulateDrawEvent();
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
@@ skipping 14 matching lines @@
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorBLACK));
   }
 
   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) {
-  auto capture_params = DefaultCaptureParams();
+  media::VideoCaptureParams capture_params = DefaultCaptureParams();
   capture_params.resolution_change_policy =
       media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(capture_params, std::move(client));
 
   // Source size equals maximum size.  Expect delivered frames to be
   // kTestWidth by kTestHeight.
   test_view()->SetSolidColor(SK_ColorRED);
   const float device_scale_factor = GetDeviceScaleFactor();
   SimulateSourceSizeChange(gfx::ConvertSizeToDIP(
       device_scale_factor, gfx::Size(kTestWidth, kTestHeight)));
   SimulateDrawsUntilNewFrameSizeArrives(
@@ skipping 24 matching lines @@
   SimulateDrawsUntilNewFrameSizeArrives(
       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) {
-  auto capture_params = DefaultCaptureParams();
+  media::VideoCaptureParams capture_params = DefaultCaptureParams();
   capture_params.resolution_change_policy =
       media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(capture_params, std::move(client));
 
   // Source size equals maximum size.  Expect delivered frames to be
   // kTestWidth by kTestHeight.
   test_view()->SetSolidColor(SK_ColorRED);
   const float device_scale_factor = GetDeviceScaleFactor();
   SimulateSourceSizeChange(gfx::ConvertSizeToDIP(
       device_scale_factor, gfx::Size(kTestWidth, kTestHeight)));
   SimulateDrawsUntilNewFrameSizeArrives(
@@ skipping 48 matching lines @@
     // the |oddball_size| is always the expected size; whereas for the
     // variable-resolution cases, the |standard_size| is the expected size.
     // Also, adjust to account for the device scale factor.
     gfx::Size capture_preferred_size = gfx::ScaleToFlooredSize(
         policy == media::RESOLUTION_POLICY_FIXED_RESOLUTION ? oddball_size
                                                             : standard_size,
         1.0f / GetDeviceScaleFactor());
     ASSERT_NE(capture_preferred_size, web_contents()->GetPreferredSize());
 
     // Start the WebContentsVideoCaptureDevice.
-    auto capture_params = DefaultCaptureParams();
+    media::VideoCaptureParams capture_params = DefaultCaptureParams();
     capture_params.requested_format.frame_size = oddball_size;
     capture_params.resolution_change_policy = policy;
     StubClientObserver unused_observer;
-    auto client = unused_observer.PassClient();
+    std::unique_ptr<StubClient> client = unused_observer.PassClient();
     EXPECT_CALL(*client, OnStarted());
     device()->AllocateAndStart(capture_params, std::move(client));
     base::RunLoop().RunUntilIdle();
 
     // Check that the preferred size of the WebContents matches the one provided
     // by WebContentsVideoCaptureDevice.
     EXPECT_EQ(capture_preferred_size, web_contents()->GetPreferredSize());
 
     // Stop the WebContentsVideoCaptureDevice.
     device()->StopAndDeAllocate();
@@ skipping 47 matching lines @@
         policies[i], gfx::Size(1000, 1000), gfx::Size(1000, 1000));
     RunTestForPreferredSize(
         policies[i], gfx::Size(1600, 1000), gfx::Size(1600, 1000));
     RunTestForPreferredSize(
         policies[i], gfx::Size(837, 999), gfx::Size(837, 999));
   }
 }
 
 // Tests the Suspend/Resume() functionality.
 TEST_F(WebContentsVideoCaptureDeviceTest, SuspendsAndResumes) {
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(DefaultCaptureParams(), std::move(client));
 
   for (int i = 0; i < 3; ++i) {
     // Draw a RED frame and wait for a normal frame capture to occur.
     test_view()->SetSolidColor(SK_ColorRED);
     SimulateDrawEvent();
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 
     // Suspend capture and then draw a GREEN frame. No frame capture should
@@ skipping 14 matching lines @@
     test_view()->SetSolidColor(SK_ColorBLUE);
     SimulateDrawEvent();
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorBLUE));
   }
 
   device()->StopAndDeAllocate();
 }
 
 // Tests the RequestRefreshFrame() functionality.
 TEST_F(WebContentsVideoCaptureDeviceTest, ProvidesRefreshFrames) {
-  auto client = client_observer()->PassClient();
+  std::unique_ptr<StubClient> client = client_observer()->PassClient();
   EXPECT_CALL(*client, OnStarted());
   device()->AllocateAndStart(DefaultCaptureParams(), std::move(client));
 
   // Request a refresh frame before the first frame has been drawn.  This forces
   // a capture.
   test_view()->SetSolidColor(SK_ColorRED);
   SimulateRefreshFrameRequest();
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorRED));
 
   // Now, draw a frame and wait for a normal frame capture to occur.
   test_view()->SetSolidColor(SK_ColorGREEN);
   SimulateDrawEvent();
   ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
 
   // Now, make three more refresh frame requests. Although the source has
   // changed to BLUE, no draw event has occurred. Therefore, expect the refresh
   // frames to contain the content from the last drawn frame, which is GREEN.
   test_view()->SetSolidColor(SK_ColorBLUE);
   for (int i = 0; i < 3; ++i) {
     SimulateRefreshFrameRequest();
     ASSERT_NO_FATAL_FAILURE(client_observer()->WaitForNextColor(SK_ColorGREEN));
   }
 
   device()->StopAndDeAllocate();
 }
 
 }  // namespace
 }  // namespace content