Remove device enumeration, caching and monitoring from MediaStreamManager.

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 23 matching lines @@
 namespace content {
 
 // Listener class used to track progress of VideoCaptureManager test.
 class MockMediaStreamProviderListener : public MediaStreamProviderListener {
  public:
   MockMediaStreamProviderListener() {}
   ~MockMediaStreamProviderListener() {}
 
   MOCK_METHOD2(Opened, void(MediaStreamType, int));
   MOCK_METHOD2(Closed, void(MediaStreamType, int));
+  MOCK_METHOD2(Aborted, void(MediaStreamType, int));
+
+  // No longer part of MediaStreamProviderListener, but still useful for
+  // testing.

[hta - Chromium, 2016/09/20 09:41:39]

Does this mean that we mock a method that isn't provided on the interface we're
mocking? This seems weird - should at least give pointers - "this is added as a
mock, and dispatched to in HandleEnumerationResult, because it's easier to write
tests in terms of a mocked DevicesEnumerated function than with other ways to
write the same thing".

[Guido Urdaneta, 2016/09/20 13:59:27]

Removed the method.

   MOCK_METHOD2(DevicesEnumerated, void(MediaStreamType,
                                        const StreamDeviceInfoArray&));
-  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));
 
   void OnBufferCreated(VideoCaptureControllerID id,
                        base::SharedMemoryHandle handle,
                        int length, int buffer_id) override {}
   void OnBufferCreated2(VideoCaptureControllerID id,
                         const std::vector<gfx::GpuMemoryBufferHandle>& handles,
                         const gfx::Size& size,
                         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 {}
 
   void OnGotControllerCallback(VideoCaptureControllerID) {}
 };
 
+static void HandleEnumerationResult(
+    MockMediaStreamProviderListener* listener,
+    const media::VideoCaptureDeviceDescriptors& descriptors) {
+  StreamDeviceInfoArray devices;
+  for (const auto& descriptor : descriptors) {
+    devices.emplace_back(MEDIA_DEVICE_VIDEO_CAPTURE,
+                         descriptor.GetNameAndModel(), descriptor.device_id);
+  }
+  listener->DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, devices);
+}
+
 // Test class
 class VideoCaptureManagerTest : public testing::Test {
  public:
   VideoCaptureManagerTest() : next_client_id_(1) {}
   ~VideoCaptureManagerTest() override {}
 
  protected:
   void SetUp() override {
     listener_.reset(new MockMediaStreamProviderListener());
     message_loop_.reset(new base::MessageLoopForIO);
@@ skipping 104 matching lines @@
 // Try to open, start, stop and close a device.
 TEST_F(VideoCaptureManagerTest, CreateAndClose) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   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_->Unregister();
 }
 
 TEST_F(VideoCaptureManagerTest, CreateAndCloseMultipleTimes) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   for (int i = 1 ; i < 3 ; ++i) {
     EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, i));
     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_->Unregister();
 }
 
 // Try to open, start, and abort a device.
 TEST_F(VideoCaptureManagerTest, CreateAndAbort) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   EXPECT_CALL(*listener_, Aborted(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   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);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->Unregister();
 }
 
 // Open the same device twice.
 TEST_F(VideoCaptureManagerTest, OpenTwice) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   int video_session_id_first = vcm_->Open(devices.front());
 
   // This should trigger an error callback with error code
   // 'kDeviceAlreadyInUse'.
   int video_session_id_second = vcm_->Open(devices.front());
   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_->Unregister();
 }
 
 // Connect and disconnect devices.
 TEST_F(VideoCaptureManagerTest, ConnectAndDisconnectDevices) {
   StreamDeviceInfoArray devices;
   int number_of_devices_keep =
     video_capture_device_factory_->number_of_devices();
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(devices.size(), 2u);
 
   // Simulate we remove 1 fake device.
   video_capture_device_factory_->set_number_of_devices(1);
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(devices.size(), 1u);
 
   // Simulate we add 2 fake devices.
   video_capture_device_factory_->set_number_of_devices(3);
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
   base::RunLoop().RunUntilIdle();
   ASSERT_EQ(devices.size(), 3u);
 
   vcm_->Unregister();
   video_capture_device_factory_->set_number_of_devices(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) {
   StreamDeviceInfoArray devices;
 
   // 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_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
   base::RunLoop().RunUntilIdle();
   ASSERT_GE(devices.size(), 2u);
 
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   video_session_id = vcm_->Open(devices.front());
   base::RunLoop().RunUntilIdle();
 
   // Right after opening the device, we should see all its formats.
   supported_formats.clear();
   EXPECT_TRUE(
@@ skipping 42 matching lines @@
 // 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) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
   base::RunLoop().RunUntilIdle();
   ASSERT_GE(devices.size(), 2u);
 
   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));
@@ skipping 28 matching lines @@
 // Open two different devices.
 TEST_F(VideoCaptureManagerTest, OpenTwo) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _)).Times(2);
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   StreamDeviceInfoArray::iterator it = devices.begin();
 
   int video_session_id_first = vcm_->Open(*it);
   ++it;
   int video_session_id_second = vcm_->Open(*it);
 
   vcm_->Close(video_session_id_first);
   vcm_->Close(video_session_id_second);
 
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->Unregister();
 }
 
 // Try open a non-existing device.
 TEST_F(VideoCaptureManagerTest, OpenNotExisting) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
   EXPECT_CALL(*frame_observer_, OnError(_));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   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);
 
   // This should fail with an error to the controller.
@@ skipping 23 matching lines @@
   base::RunLoop run_loop;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(
           DoAll(SaveArg<1>(&devices),
                 InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit)));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   run_loop.Run();
   ASSERT_FALSE(devices.empty());
   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_->Unregister();
 }
 
 // Try to open, start, pause and resume a device.
 TEST_F(VideoCaptureManagerTest, PauseAndResumeClient) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));

[hta - Chromium, 2016/09/20 09:41:39]

With the number of calls to this particular function, should it be an utility in
the test fixture? This could allow you to hide HandleEnmuerationResult too - it
seems from a quick read that all that DevicesEnumerated does is to save its
argument in &devices, which means that if you put |devices| into the fixture
too, you can avoid the strange mock completely.

[Guido Urdaneta, 2016/09/20 13:59:27]

Done. The only slightly ugly thing is that HandleEnumerationResult is public so
that it can be used by the test that simulates device removals and additions.

 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   int video_session_id = vcm_->Open(devices.front());
   VideoCaptureControllerID client_id = StartClient(video_session_id, true);
 
   // Resume client a second time should cause no problem.
   PauseClient(client_id);
   ResumeClient(video_session_id, client_id);
@@ skipping 11 matching lines @@
 // Try to open, start, pause and resume a device.
 TEST_F(VideoCaptureManagerTest, PauseAndResumeDevice) {
   StreamDeviceInfoArray devices;
 
   InSequence s;
   EXPECT_CALL(*listener_, DevicesEnumerated(MEDIA_DEVICE_VIDEO_CAPTURE, _))
       .WillOnce(SaveArg<1>(&devices));
   EXPECT_CALL(*listener_, Opened(MEDIA_DEVICE_VIDEO_CAPTURE, _));
   EXPECT_CALL(*listener_, Closed(MEDIA_DEVICE_VIDEO_CAPTURE, _));
 
-  vcm_->EnumerateDevices(MEDIA_DEVICE_VIDEO_CAPTURE);
+  vcm_->EnumerateDevices(base::Bind(&HandleEnumerationResult, listener_.get()));
 
   // Wait to get device callback.
   base::RunLoop().RunUntilIdle();
 
   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(
@@ skipping 13 matching lines @@
   // Wait to check callbacks before removing the listener.
   base::RunLoop().RunUntilIdle();
   vcm_->Unregister();
 }
 #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