[Mojo Video Capture] Add content_browsertest for exercising video capture

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 289 matching lines @@
 
 // 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());
+  int video_session_id = vcm_->Open(devices_.front().device);
   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();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 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());
+    int video_session_id = vcm_->Open(devices_.front().device);
     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();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // 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());
+  int video_session_id = vcm_->Open(devices_.front().device);
   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);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 TEST_F(VideoCaptureManagerTest, AddObserver) {
   InSequence s;
   MockVideoCaptureObserver observer;
   vcm_->AddVideoCaptureObserver(&observer);
 
   EXPECT_CALL(observer,
               OnVideoCaptureStarted(WrappedDeviceFactory::DEFAULT_FACING));
   EXPECT_CALL(observer,
               OnVideoCaptureStopped(WrappedDeviceFactory::DEFAULT_FACING));
 
-  int video_session_id = vcm_->Open(devices_.front());
+  int video_session_id = vcm_->Open(devices_.front().device);
   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();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Open the same device twice.
 TEST_F(VideoCaptureManagerTest, OpenTwice) {
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
 
-  int video_session_id_first = vcm_->Open(devices_.front());
+  int video_session_id_first = vcm_->Open(devices_.front().device);
 
   // This should trigger an error callback with error code
   // 'kDeviceAlreadyInUse'.
-  int video_session_id_second = vcm_->Open(devices_.front());
+  int video_session_id_second = vcm_->Open(devices_.front().device);
   EXPECT_NE(video_session_id_first, video_session_id_second);
 
   vcm_->Close(video_session_id_first);
   vcm_->Close(video_session_id_second);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Connect and disconnect devices.
 TEST_F(VideoCaptureManagerTest, ConnectAndDisconnectDevices) {
   int number_of_devices_keep =
     video_capture_device_factory_->number_of_devices();
 
   // Simulate we remove 1 fake device.
   video_capture_device_factory_->SetToDefaultDevicesConfig(1);
   base::RunLoop run_loop;
   vcm_->EnumerateDevices(
       base::Bind(&VideoCaptureManagerTest::HandleEnumerationResult,
                  base::Unretained(this), run_loop.QuitClosure()));
   run_loop.Run();
   ASSERT_EQ(devices_.size(), 1u);
 
   // Simulate we add 2 fake devices.
   video_capture_device_factory_->SetToDefaultDevicesConfig(3);
   base::RunLoop run_loop2;
   vcm_->EnumerateDevices(
       base::Bind(&VideoCaptureManagerTest::HandleEnumerationResult,
                  base::Unretained(this), run_loop2.QuitClosure()));
   run_loop2.Run();
   ASSERT_EQ(devices_.size(), 3u);
 
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
   video_capture_device_factory_->SetToDefaultDevicesConfig(
       number_of_devices_keep);
 }
 
 // Enumerate devices and open the first, then check the list of supported
 // formats. Then start the opened device. The capability list should stay the
 // same. Finally stop the device and check that the capabilities stay unchanged.
 TEST_F(VideoCaptureManagerTest, ManipulateDeviceAndCheckCapabilities) {
   // Before enumerating the devices, requesting formats should return false.
   int video_session_id = 0;
   media::VideoCaptureFormats supported_formats;
   supported_formats.clear();
   EXPECT_FALSE(
       vcm_->GetDeviceSupportedFormats(video_session_id, &supported_formats));
 
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
-  video_session_id = vcm_->Open(devices_.front());
+  video_session_id = vcm_->Open(devices_.front().device);
   base::RunLoop().RunUntilIdle();
 
   // Right after opening the device, we should see all its formats.
   supported_formats.clear();
   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);
@@ skipping 24 matching lines @@
   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);
 
   vcm_->Close(video_session_id);
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Enumerate devices, then check the list of supported formats. Then open and
 // start the first device. The capability list should stay the same. Finally
 // stop the device and check that the capabilities stay unchanged.
 TEST_F(VideoCaptureManagerTest,
        ManipulateDeviceAndCheckCapabilitiesWithDeviceId) {
   // Requesting formats should work even before enumerating/opening devices.
   std::string device_id = devices_.front().device.id;
   media::VideoCaptureFormats supported_formats;
   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);
 
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
-  int video_session_id = vcm_->Open(devices_.front());
+  int video_session_id = vcm_->Open(devices_.front().device);
   base::RunLoop().RunUntilIdle();
 
   // Right after opening the device, we should see all its formats.
   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 21 matching lines @@
   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);
 
   vcm_->Close(video_session_id);
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Enumerate devices and open the first, then check the formats currently in
 // use, which should be an empty vector. Then start the opened device. The
 // format(s) in use should be just one format (the one used when configuring-
 // starting the device). Finally stop the device and check that the formats in
 // use is an empty vector.
 TEST_F(VideoCaptureManagerTest, StartDeviceAndGetDeviceFormatInUse) {
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
-  int video_session_id = vcm_->Open(devices_.front());
+  int video_session_id = vcm_->Open(devices_.front().device);
   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();
@@ skipping 11 matching lines @@
 
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   StopClient(client_id);
   base::RunLoop().RunUntilIdle();
   // After StopClient(), the device's formats in use should be empty again.
   EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(video_session_id, &formats_in_use));
   EXPECT_TRUE(formats_in_use.empty());
 
   vcm_->Close(video_session_id);
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Enumerate devices and open the first, then check the formats currently in
 // use, which should be an empty vector. Then start the opened device. The
 // format(s) in use should be just one format (the one used when configuring-
 // starting the device). Finally stop the device and check that the formats in
 // use is an empty vector.
 TEST_F(VideoCaptureManagerTest,
        StartDeviceAndGetDeviceFormatInUseWithDeviceId) {
   std::string device_id = devices_.front().device.id;
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
-  int video_session_id = vcm_->Open(devices_.front());
+  int video_session_id = vcm_->Open(devices_.front().device);
   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);
@@ skipping 14 matching lines @@
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   StopClient(client_id);
   base::RunLoop().RunUntilIdle();
   // After StopClient(), the device's formats in use should be empty again.
   EXPECT_TRUE(vcm_->GetDeviceFormatsInUse(MEDIA_DEVICE_VIDEO_CAPTURE, device_id,
                                           &formats_in_use));
   EXPECT_TRUE(formats_in_use.empty());
 
   vcm_->Close(video_session_id);
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Open two different devices.
 TEST_F(VideoCaptureManagerTest, OpenTwo) {
   InSequence s;
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
 
   StreamDeviceInfoArray::iterator it = devices_.begin();
 
-  int video_session_id_first = vcm_->Open(*it);
+  int video_session_id_first = vcm_->Open(it->device);
   ++it;
-  int video_session_id_second = vcm_->Open(*it);
+  int video_session_id_second = vcm_->Open(it->device);
 
   vcm_->Close(video_session_id_first);
   vcm_->Close(video_session_id_second);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Try open a non-existing device.
 TEST_F(VideoCaptureManagerTest, OpenNotExisting) {
   InSequence s;
   EXPECT_CALL(*frame_observer_, OnError(_));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
   MediaStreamType stream_type = MEDIA_DEVICE_VIDEO_CAPTURE;
   std::string device_name("device_doesnt_exist");
   std::string device_id("id_doesnt_exist");
-  StreamDeviceInfo dummy_device(stream_type, device_name, device_id);
+  MediaStreamDevice dummy_device(stream_type, device_id, device_name);
 
   // This should fail with an error to the controller.
   int session_id = vcm_->Open(dummy_device);
   VideoCaptureControllerID client_id = StartClient(session_id, true);
   base::RunLoop().RunUntilIdle();
 
   StopClient(client_id);
   vcm_->Close(session_id);
   base::RunLoop().RunUntilIdle();
 
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // Start a device without calling Open, using a non-magic ID.
 TEST_F(VideoCaptureManagerTest, StartInvalidSession) {
   StartClient(22, false);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // 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());
+  int video_session_id = vcm_->Open(devices_.front().device);
 
   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();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 // 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 int video_session_id = vcm_->Open(devices_.front().device);
   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);
 
   // Attempting to resume the client a second time should not cause any calls to
   // VideoCaptureDevice::Resume().
   ResumeClient(video_session_id, client_id);
 
   // Add a second client that is never paused, then pause/resume the first
   // client, and no calls to VideoCaptureDevice::MaybeSuspend() or Resume() are
   // made.
   const VideoCaptureControllerID client_id2 =
       StartClient(video_session_id, true);
   PauseClient(client_id);
   ResumeClient(video_session_id, client_id);
 
   StopClient(client_id);
   StopClient(client_id2);
 
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   vcm_->Close(video_session_id);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 
 #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());
+  int video_session_id = vcm_->Open(devices_.front().device);
   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(
       base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
   ApplicationStateChange(
       base::android::APPLICATION_STATE_HAS_STOPPED_ACTIVITIES);
   ApplicationStateChange(
       base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
   ApplicationStateChange(
       base::android::APPLICATION_STATE_HAS_RUNNING_ACTIVITIES);
 
   StopClient(client_id);
   vcm_->Close(video_session_id);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
-  vcm_->UnregisterListener();
+  vcm_->UnregisterListener(listener_.get());
 }
 #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