getUserMeida: report device starting states

content/browser/renderer_host/media/video_capture_manager_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.
 
 // Unit test for VideoCaptureManager.
 
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 
 #include <stdint.h>
 
@@ skipping 119 matching lines @@
 
   MOCK_METHOD2(Opened, void(MediaStreamType, int));
   MOCK_METHOD2(Closed, void(MediaStreamType, int));
   MOCK_METHOD2(Aborted, void(MediaStreamType, int));
 };  // class MockMediaStreamProviderListener
 
 // Needed as an input argument to StartCaptureForClient().
 class MockFrameObserver : public VideoCaptureControllerEventHandler {
  public:
   MOCK_METHOD1(OnError, void(VideoCaptureControllerID id));
+  MOCK_METHOD1(OnStarted, void(VideoCaptureControllerID id));
 
   void OnBufferCreated(VideoCaptureControllerID id,
                        mojo::ScopedSharedBufferHandle handle,
                        int length, int buffer_id) override {}
   void OnBufferDestroyed(VideoCaptureControllerID id, int buffer_id) override {}
   void OnBufferReady(VideoCaptureControllerID id,
                      int buffer_id,
                      const scoped_refptr<media::VideoFrame>& frame) override {}
   void OnEnded(VideoCaptureControllerID id) override {}
 
@@ skipping 124 matching lines @@
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureManagerTest);
 };
 
 // Test cases
 
 // Try to open, start, stop and close a device.
 TEST_F(VideoCaptureManagerTest, CreateAndClose) {
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
   int video_session_id = vcm_->Open(devices_.front());
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
   StopClient(client_id);
   vcm_->Close(video_session_id);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->UnregisterListener();
 }
 
 TEST_F(VideoCaptureManagerTest, CreateAndCloseMultipleTimes) {
   InSequence s;
   for (int i = 1 ; i < 3 ; ++i) {
     EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, i));
+    EXPECT_CALL(*frame_observer_, OnStarted(_));
     EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, i));
     int video_session_id = vcm_->Open(devices_.front());
     VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
     StopClient(client_id);
     vcm_->Close(video_session_id);
   }
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->UnregisterListener();
 }
 
 // Try to open, start, and abort a device.
 TEST_F(VideoCaptureManagerTest, CreateAndAbort) {
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   EXPECT_CALL(*listener_, Aborted(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
   int video_session_id = vcm_->Open(devices_.front());
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
   // Wait for device opened.
   base::RunLoop().RunUntilIdle();
 
   vcm_->StopCaptureForClient(controllers_[client_id], client_id,
                              frame_observer_.get(), true);
@@ skipping 72 matching lines @@
   EXPECT_TRUE(
       vcm_->GetDeviceSupportedFormats(video_session_id, &supported_formats));
   ASSERT_GT(supported_formats.size(), 1u);
   EXPECT_GT(supported_formats[0].frame_size.width(), 1);
   EXPECT_GT(supported_formats[0].frame_size.height(), 1);
   EXPECT_GT(supported_formats[0].frame_rate, 1);
   EXPECT_GT(supported_formats[1].frame_size.width(), 1);
   EXPECT_GT(supported_formats[1].frame_size.height(), 1);
   EXPECT_GT(supported_formats[1].frame_rate, 1);
 
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
   base::RunLoop().RunUntilIdle();
   // After StartClient(), device's supported formats should stay the same.
   supported_formats.clear();
   EXPECT_TRUE(
       vcm_->GetDeviceSupportedFormats(video_session_id, &supported_formats));
   ASSERT_GE(supported_formats.size(), 2u);
   EXPECT_GT(supported_formats[0].frame_size.width(), 1);
   EXPECT_GT(supported_formats[0].frame_size.height(), 1);
   EXPECT_GT(supported_formats[0].frame_rate, 1);
@@ skipping 46 matching lines @@
   supported_formats.clear();
   EXPECT_TRUE(vcm_->GetDeviceSupportedFormats(device_id, &supported_formats));
   ASSERT_GE(supported_formats.size(), 2u);
   EXPECT_GT(supported_formats[0].frame_size.width(), 1);
   EXPECT_GT(supported_formats[0].frame_size.height(), 1);
   EXPECT_GT(supported_formats[0].frame_rate, 1);
   EXPECT_GT(supported_formats[1].frame_size.width(), 1);
   EXPECT_GT(supported_formats[1].frame_size.height(), 1);
   EXPECT_GT(supported_formats[1].frame_rate, 1);
 
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
   base::RunLoop().RunUntilIdle();
   // After StartClient(), device's supported formats should stay the same.
   supported_formats.clear();
   EXPECT_TRUE(vcm_->GetDeviceSupportedFormats(device_id, &supported_formats));
   ASSERT_GE(supported_formats.size(), 2u);
   EXPECT_GT(supported_formats[0].frame_size.width(), 1);
   EXPECT_GT(supported_formats[0].frame_size.height(), 1);
   EXPECT_GT(supported_formats[0].frame_rate, 1);
   EXPECT_GT(supported_formats[1].frame_size.width(), 1);
@@ skipping 26 matching lines @@
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   int video_session_id = vcm_->Open(devices_.front());
   base::RunLoop().RunUntilIdle();
 
   // Right after opening the device, we should see no format in use.
   media::VideoCaptureFormats formats_in_use;
   EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(video_session_id, &formats_in_use));
   EXPECT_TRUE(formats_in_use.empty());
 
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
   base::RunLoop().RunUntilIdle();
   // After StartClient(), |formats_in_use| should contain one valid format.
   EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(video_session_id, &formats_in_use));
   EXPECT_EQ(formats_in_use.size(), 1u);
   if (formats_in_use.size()) {
     media::VideoCaptureFormat& format_in_use = formats_in_use.front();
     EXPECT_TRUE(format_in_use.IsValid());
     EXPECT_GT(format_in_use.frame_size.width(), 1);
     EXPECT_GT(format_in_use.frame_size.height(), 1);
@@ skipping 25 matching lines @@
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   int video_session_id = vcm_->Open(devices_.front());
   base::RunLoop().RunUntilIdle();
 
   // Right after opening the device, we should see no format in use.
   media::VideoCaptureFormats formats_in_use;
   EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(MEDIA_DEVICE_VIDEO_CAPTURE, device_id,
                                           &formats_in_use));
   EXPECT_TRUE(formats_in_use.empty());
 
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
   base::RunLoop().RunUntilIdle();
   // After StartClient(), |formats_in_use| should contain one valid format.
   EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(MEDIA_DEVICE_VIDEO_CAPTURE, device_id,
                                           &formats_in_use));
   EXPECT_EQ(formats_in_use.size(), 1u);
   if (formats_in_use.size()) {
     media::VideoCaptureFormat& format_in_use = formats_in_use.front();
     EXPECT_TRUE(format_in_use.IsValid());
     EXPECT_GT(format_in_use.frame_size.width(), 1);
@@ skipping 65 matching lines @@
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->UnregisterListener();
 }
 
 // Open and start a device, close it before calling Stop.
 TEST_F(VideoCaptureManagerTest, CloseWithoutStop) {
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
   int video_session_id = vcm_->Open(devices_.front());
 
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
   // Close will stop the running device, an assert will be triggered in
   // VideoCaptureManager destructor otherwise.
   vcm_->Close(video_session_id);
   StopClient(client_id);
 
   // Wait to check callbacks before removing the listener
   base::RunLoop().RunUntilIdle();
   vcm_->UnregisterListener();
 }
 
 // Try to open, start, pause and resume a device. Confirm the device is
 // paused/resumed at the correct times in both single-client and multiple-client
 // scenarios.
 TEST_F(VideoCaptureManagerTest, PauseAndResumeClient) {
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
 
   const int video_session_id = vcm_->Open(devices_.front());
   const VideoCaptureControllerID client_id =
       StartClient(video_session_id, true);
 
   // Test pause/resume when only one client is present.
   EXPECT_CALL(*video_capture_device_factory_, WillSuspendDevice()).Times(1);
   PauseClient(client_id);
   EXPECT_CALL(*video_capture_device_factory_, WillResumeDevice()).Times(1);
   ResumeClient(video_session_id, client_id);
@@ skipping 19 matching lines @@
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->UnregisterListener();
 }
 
 #if defined(OS_ANDROID)
 // Try to open, start, pause and resume a device.
 TEST_F(VideoCaptureManagerTest, PauseAndResumeDevice) {
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
+  EXPECT_CALL(*frame_observer_, OnStarted(_));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
   int video_session_id = vcm_->Open(devices_.front());
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
   // Release/ResumeDevices according to ApplicationStatus. Should cause no
   // problem in any order. Check https://crbug.com/615557 for more details.
   ApplicationStateChange(
       base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
   ApplicationStateChange(
@@ skipping 11 matching lines @@
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->UnregisterListener();
 }
 #endif
 
 // TODO(mcasas): Add a test to check consolidation of the supported formats
 // provided by the device when http://crbug.com/323913 is closed.
 
 }  // namespace content