getUserMeida: report device starting states

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 225 matching lines @@
   MOCK_METHOD7(OnIncomingCapturedData,
                void(const uint8_t* data,
                     int length,
                     const media::VideoCaptureFormat& frame_format,
                     int rotation,
                     base::TimeTicks reference_time,
                     base::TimeDelta timestamp,
                     int frame_feedback_id));
 
   MOCK_METHOD0(DoOnIncomingCapturedBuffer, void(void));
+  MOCK_METHOD0(OnStarted, void(void));
 
   media::VideoCaptureDevice::Client::Buffer ReserveOutputBuffer(
       const gfx::Size& dimensions,
       media::VideoPixelFormat format,
       media::VideoPixelStorage storage,
       int frame_feedback_id) override {
     CHECK_EQ(format, media::PIXEL_FORMAT_I420);
     int buffer_id_to_drop =
         media::VideoCaptureBufferPool::kInvalidId;  // Ignored.
     const int buffer_id = buffer_pool_->ReserveForProducer(
@@ skipping 83 matching lines @@
         wait_color_yuv_(kWaitColorNotSet),
         expecting_frames_(true) {
     client_.reset(new StubClient(
         base::Bind(&StubClientObserver::DidDeliverFrame,
                    base::Unretained(this)),
         base::Bind(&StubClientObserver::OnError, base::Unretained(this))));
   }
 
   virtual ~StubClientObserver() {}
 
-  std::unique_ptr<media::VideoCaptureDevice::Client> PassClient() {
-    return std::move(client_);
-  }
+  std::unique_ptr<StubClient> PassClient() { return std::move(client_); }
 
   void SetIsExpectingFrames(bool expecting_frames) {
     expecting_frames_ = expecting_frames;
   }
 
   void QuitIfConditionsMet(SkColor color, const gfx::Size& size) {
     EXPECT_TRUE(expecting_frames_);
     if (error_encountered_ || wait_color_yuv_ == kNotInterested ||
         wait_color_yuv_ == color) {
       last_frame_color_yuv_ = color;
@@ skipping 267 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();
-  device()->AllocateAndStart(DefaultCaptureParams(),
-                             client_observer()->PassClient());
+  auto 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.
-  device()->AllocateAndStart(DefaultCaptureParams(),
-                             client_observer()->PassClient());
+  auto 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();
 
   // Post a task to close the tab. We should see an error reported to the
@@ skipping 23 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);
-  device()->AllocateAndStart(DefaultCaptureParams(),
-                             client_observer()->PassClient());
+  auto 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);
-  device()->AllocateAndStart(DefaultCaptureParams(), observer2.PassClient());
+  auto 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) {
-  device()->AllocateAndStart(DefaultCaptureParams(),
-                             client_observer()->PassClient());
+  auto 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));
 
     test_view()->SetSolidColor(SK_ColorGREEN);
@@ skipping 15 matching lines @@
   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();
   capture_params.resolution_change_policy =
       media::RESOLUTION_POLICY_FIXED_ASPECT_RATIO;
-  device()->AllocateAndStart(capture_params, client_observer()->PassClient());
+  auto 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(
       SK_ColorRED, gfx::Size(kTestWidth, kTestHeight));
 
@@ skipping 25 matching lines @@
   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();
   capture_params.resolution_change_policy =
       media::RESOLUTION_POLICY_ANY_WITHIN_LIMIT;
-  device()->AllocateAndStart(capture_params, client_observer()->PassClient());
+  auto 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(
       SK_ColorRED, gfx::Size(kTestWidth, kTestHeight));
 
@@ skipping 50 matching lines @@
         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();
     capture_params.requested_format.frame_size = oddball_size;
     capture_params.resolution_change_policy = policy;
     StubClientObserver unused_observer;
-    device()->AllocateAndStart(capture_params, unused_observer.PassClient());
+    auto 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();
     base::RunLoop().RunUntilIdle();
   };
@@ skipping 45 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) {
-  device()->AllocateAndStart(DefaultCaptureParams(),
-                             client_observer()->PassClient());
+  auto 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
     // occur.
     device()->MaybeSuspend();
@@ skipping 12 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) {
-  device()->AllocateAndStart(DefaultCaptureParams(),
-                             client_observer()->PassClient());
+  auto 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