[Mojo Video Capture] Fix VideoCaptureManager exposing implementation details to clients

content/browser/renderer_host/media/media_stream_dispatcher_host_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/renderer_host/media/media_stream_dispatcher_host.h"
 
 #include <stddef.h>
 #include <memory>
 #include <queue>
 #include <string>
@@ skipping 35 matching lines @@
 #include "url/origin.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
 #endif
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::InSequence;
+using ::testing::Invoke;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 const int kProcessId = 5;
 const int kRenderId = 6;
 const int kPageRequestId = 7;
+static const char* kRegularVideoDeviceId = "stub_device_0";

[miu, 2017/04/03 21:31:23]

Prefer constexpr to static const here.

Also, all these constants (old and new) should be moved into the anonymous
namespace (below).

[chfremer, 2017/04/04 21:59:32]

Done.

+static const char* kDepthVideoDeviceId = "stub_device_1 (depth)";
+static const double kStubFocalLengthX = 135.0;
+static const double kStubFocalLengthY = 135.6;
+static const double kStubDepthNear = 0.0;
+static const double kStubDepthFar = 65.535;
 
 namespace content {
 
 namespace {
 
 void AudioInputDevicesEnumerated(base::Closure quit_closure,
                                  media::AudioDeviceDescriptions* out,
                                  const MediaDeviceEnumeration& enumeration) {
   for (const auto& info : enumeration[MEDIA_DEVICE_TYPE_AUDIO_INPUT]) {
     out->emplace_back(info.label, info.device_id, info.group_id);
   }
   quit_closure.Run();
 }
 
-}  // namespace
+}  // anonymous namespace
 
 class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
                                       public TestContentBrowserClient {
  public:
   MockMediaStreamDispatcherHost(
       const std::string& salt,
       const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
       MediaStreamManager* manager)
       : MediaStreamDispatcherHost(kProcessId, salt, manager),
         task_runner_(task_runner),
@@ skipping 134 matching lines @@
 };
 
 class MockMediaStreamUIProxy : public FakeMediaStreamUIProxy {
  public:
   MOCK_METHOD2(
       OnStarted,
       void(const base::Closure& stop,
            const MediaStreamUIProxy::WindowIdCallback& window_id_callback));
 };
 
+class MockVideoCaptureSystem : public media::VideoCaptureSystem {
+ public:
+  MOCK_METHOD1(GetDeviceInfosAsync,
+               void(const base::Callback<
+                    void(const std::vector<media::VideoCaptureDeviceInfo>&)>&
+                        result_callback));
+
+  MOCK_METHOD1(
+      CreateDevice,
+      std::unique_ptr<media::VideoCaptureDevice>(const std::string& device_id));
+};
+
 class MediaStreamDispatcherHostTest : public testing::Test {
  public:
   MediaStreamDispatcherHostTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         old_browser_client_(NULL),
         origin_(GURL("https://test.com")) {
     audio_manager_.reset(
         new media::MockAudioManager(base::ThreadTaskRunnerHandle::Get()));
     audio_system_ = media::AudioSystemImpl::Create(audio_manager_.get());
     // Make sure we use fake devices to avoid long delays.
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeDeviceForMediaStream);
+    auto mock_video_capture_system = base::MakeUnique<MockVideoCaptureSystem>();
+    mock_video_capture_system_ = mock_video_capture_system.get();
     // Create our own MediaStreamManager.
     media_stream_manager_ =
-        base::MakeUnique<MediaStreamManager>(audio_system_.get());
-    video_capture_device_factory_ =
-        static_cast<media::FakeVideoCaptureDeviceFactory*>(
-            media_stream_manager_->video_capture_manager()
-            ->video_capture_device_factory());
-    DCHECK(video_capture_device_factory_);
-#if defined(OS_WIN)
-    // Override the Video Capture Thread that MediaStreamManager constructs.
-    media_stream_manager_->video_capture_manager()->set_device_task_runner(
-        base::ThreadTaskRunnerHandle::Get());
-#endif
+        MediaStreamManager::CreateWithCustomVideoCaptureSystem(
+            audio_system_.get(), std::move(mock_video_capture_system),
+            base::ThreadTaskRunnerHandle::Get());
 
     MockResourceContext* mock_resource_context =
         static_cast<MockResourceContext*>(
             browser_context_.GetResourceContext());
 
     host_ = new MockMediaStreamDispatcherHost(
         mock_resource_context->GetMediaDeviceIDSalt(),
         base::ThreadTaskRunnerHandle::Get(), media_stream_manager_.get());
 
     // Use the fake content client and browser.
     content_client_.reset(new TestContentClient());
     SetContentClient(content_client_.get());
     old_browser_client_ = SetBrowserClientForTesting(host_.get());
 
 #if defined(OS_CHROMEOS)
     chromeos::CrasAudioHandler::InitializeForTesting();
 #endif
   }
 
   ~MediaStreamDispatcherHostTest() override {
 #if defined(OS_CHROMEOS)
     chromeos::CrasAudioHandler::Shutdown();
 #endif
   }
 
   void SetUp() override {
-    video_capture_device_factory_->GetDeviceDescriptors(
-        &physical_video_devices_);
-    ASSERT_GT(physical_video_devices_.size(), 0u);
+    stub_video_device_ids_.emplace_back(kRegularVideoDeviceId);
+    stub_video_device_ids_.emplace_back(kDepthVideoDeviceId);
+    const media::VideoCaptureApi stub_capture_api =

[miu, 2017/04/03 21:31:23]

Seems that this constant defined here, then captured by the lambda, and only
used within the lambda. Could it just be used directly in the lambda? Meaning,
L309 would just be:

  info.descriptor.capture_api = media::VCApi::LINUX_V4L2_SINGLE_PLANE;

[chfremer, 2017/04/04 21:59:32]

Done.

+        media::VideoCaptureApi::LINUX_V4L2_SINGLE_PLANE;
+    ON_CALL(*mock_video_capture_system_, GetDeviceInfosAsync(_))
+        .WillByDefault(
+            Invoke([this, stub_capture_api](
+                       const base::Callback<void(
+                           const std::vector<media::VideoCaptureDeviceInfo>&)>&
+                           result_callback) {
+              std::vector<media::VideoCaptureDeviceInfo> result;
+              for (const auto& device_id : stub_video_device_ids_) {
+                media::VideoCaptureDeviceInfo info;
+                info.descriptor.device_id = device_id;
+                info.descriptor.capture_api = stub_capture_api;
+                if (device_id == kDepthVideoDeviceId) {
+                  info.descriptor.camera_calibration.emplace();
+                  info.descriptor.camera_calibration->focal_length_x = 135.0;
+                  info.descriptor.camera_calibration->focal_length_y = 135.6;
+                  info.descriptor.camera_calibration->depth_near = 0.0;
+                  info.descriptor.camera_calibration->depth_far = 65.535;
+                }
+                result.push_back(info);
+              }
+              result_callback.Run(result);
+            }));
 
     base::RunLoop run_loop;
     MediaDevicesManager::BoolDeviceTypes devices_to_enumerate;
     devices_to_enumerate[MEDIA_DEVICE_TYPE_AUDIO_INPUT] = true;
     media_stream_manager_->media_devices_manager()->EnumerateDevices(
         devices_to_enumerate,
         base::Bind(&AudioInputDevicesEnumerated, run_loop.QuitClosure(),
                    &physical_audio_devices_));
     run_loop.Run();
 
@@ skipping 12 matching lines @@
         std::unique_ptr<FakeMediaStreamUIProxy>(stream_ui_));
   }
 
   void GenerateStreamAndWaitForResult(int render_frame_id,
                                       int page_request_id,
                                       const StreamControls& controls) {
     base::RunLoop run_loop;
     int expected_audio_array_size =
         (controls.audio.requested && !physical_audio_devices_.empty()) ? 1 : 0;
     int expected_video_array_size =
-        (controls.video.requested && !physical_video_devices_.empty()) ? 1 : 0;
+        (controls.video.requested && !stub_video_device_ids_.empty()) ? 1 : 0;
     EXPECT_CALL(*host_.get(), OnStreamGenerated(render_frame_id,
                                                 page_request_id,
                                                 expected_audio_array_size,
                                                 expected_video_array_size));
     host_->OnGenerateStream(render_frame_id, page_request_id, controls, origin_,
                             run_loop.QuitClosure());
     run_loop.Run();
     EXPECT_FALSE(DoesContainRawIds(host_->audio_devices_));
     EXPECT_FALSE(DoesContainRawIds(host_->video_devices_));
     EXPECT_TRUE(DoesEveryDeviceMapToRawId(host_->audio_devices_, origin_));
@@ skipping 31 matching lines @@
     for (size_t i = 0; i < devices.size(); ++i) {
       if (devices[i].device.id !=
               media::AudioDeviceDescription::kDefaultDeviceId &&
           devices[i].device.id !=
               media::AudioDeviceDescription::kCommunicationsDeviceId) {
         for (const auto& audio_device : physical_audio_devices_) {
           if (audio_device.unique_id == devices[i].device.id)
             return true;
         }
       }
-      for (const auto& video_device : physical_video_devices_) {
-        if (video_device.device_id == devices[i].device.id)
+      for (const std::string& device_id : stub_video_device_ids_) {
+        if (device_id == devices[i].device.id)
           return true;
       }
     }
     return false;
   }
 
   bool DoesEveryDeviceMapToRawId(const StreamDeviceInfoArray& devices,
                                  const url::Origin& origin) {
     for (size_t i = 0; i < devices.size(); ++i) {
       bool found_match = false;
       media::AudioDeviceDescriptions::const_iterator audio_it =
           physical_audio_devices_.begin();
       for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
         if (content::DoesMediaDeviceIDMatchHMAC(
                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
                 origin,
                 devices[i].device.id,
                 audio_it->unique_id)) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
-      media::VideoCaptureDeviceDescriptors::const_iterator video_it =
-          physical_video_devices_.begin();
-      for (; video_it != physical_video_devices_.end(); ++video_it) {
+      for (const std::string& device_id : stub_video_device_ids_) {
         if (content::DoesMediaDeviceIDMatchHMAC(
                 browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
-                origin, devices[i].device.id, video_it->device_id)) {
+                origin, devices[i].device.id, device_id)) {
           EXPECT_FALSE(found_match);
           found_match = true;
         }
       }
       if (!found_match)
         return false;
     }
     return true;
   }
 
@@ skipping 18 matching lines @@
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   std::unique_ptr<MediaStreamManager> media_stream_manager_;
   content::TestBrowserThreadBundle thread_bundle_;
   std::unique_ptr<media::AudioManager, media::AudioManagerDeleter>
       audio_manager_;
   std::unique_ptr<media::AudioSystem> audio_system_;
   MockMediaStreamUIProxy* stream_ui_;
   ContentBrowserClient* old_browser_client_;
   std::unique_ptr<ContentClient> content_client_;
   content::TestBrowserContext browser_context_;
   media::AudioDeviceDescriptions physical_audio_devices_;

[miu, 2017/04/03 21:31:23]

s/physical_audio/stub_audio/ too, or are they really physical during the unit
tests?

[chfremer, 2017/04/04 21:59:32]

I had the same question, but since it is fairly non-obvious to figure out, I
decided to not touch this. I believe what is being used is "fake" audio devices.

Renaming to "audio_device_descriptions_". 

-  media::VideoCaptureDeviceDescriptors physical_video_devices_;
+  std::vector<std::string> stub_video_device_ids_;
   url::Origin origin_;
-  media::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
+  MockVideoCaptureSystem* mock_video_capture_system_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithVideoOnly) {
   StreamControls controls(false, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ skipping 23 matching lines @@
   StreamControls controls(true, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
 
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithDepthVideo) {
-  // Video device on index 1 is depth video capture device.  The number of fake
-  // devices is 2.
-  physical_video_devices_.clear();
-  video_capture_device_factory_->SetToDefaultDevicesConfig(2);
-  video_capture_device_factory_->GetDeviceDescriptors(&physical_video_devices_);
   // We specify to generate both audio and video stream.
   StreamControls controls(true, true);
   std::string source_id = content::GetHMACForMediaDeviceID(
       browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(), origin_,
-      physical_video_devices_[1].device_id);
-  // |source_id| is related to depth device (the device on index 1). As we can
-  // generate only one video stream using GenerateStreamAndWaitForResult, we
-  // use controls.video.source_id to specify that the stream is depth video.
+      kDepthVideoDeviceId);
+  // |source_id| corresponds to the depth device. As we can generate only one
+  // video stream using GenerateStreamAndWaitForResult, we use
+  // controls.video.source_id to specify that the stream is depth video.
   // See also MediaStreamManager::GenerateStream and other tests here.
   controls.video.device_id = source_id;
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
 
-  // There are two fake devices. We specified the generation and expect to get
+  // We specified the generation and expect to get
   // one audio and one depth video stream.
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
   // host_->video_devices_[0] contains the information about generated video
   // stream device (the depth device).
   const base::Optional<CameraCalibration> calibration =
       host_->video_devices_[0].device.camera_calibration;
   EXPECT_TRUE(calibration);
-  EXPECT_EQ(calibration->focal_length_x, 135.0);
-  EXPECT_EQ(calibration->focal_length_y, 135.6);
-  EXPECT_EQ(calibration->depth_near, 0.0);
-  EXPECT_EQ(calibration->depth_far, 65.535);
+  EXPECT_EQ(calibration->focal_length_x, kStubFocalLengthX);
+  EXPECT_EQ(calibration->focal_length_y, kStubFocalLengthY);
+  EXPECT_EQ(calibration->depth_near, kStubDepthNear);
+  EXPECT_EQ(calibration->depth_far, kStubDepthFar);
 }
 
 // This test generates two streams with video only using the same render frame
 // id. The same capture device with the same device and session id is expected
 // to be used.
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsFromSameRenderId) {
   StreamControls controls(false, true);
 
   // Generate first stream.
   SetupFakeUI(true);
@@ skipping 104 matching lines @@
                           run_loop2.QuitClosure());
 
   run_loop1.Run();
   run_loop2.Run();
 }
 
 // Test that we can generate streams where a sourceId is specified in
 // the request.
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithSourceId) {
   ASSERT_GE(physical_audio_devices_.size(), 1u);
-  ASSERT_GE(physical_video_devices_.size(), 1u);
+  ASSERT_GE(stub_video_device_ids_.size(), 1u);
 
   media::AudioDeviceDescriptions::const_iterator audio_it =
       physical_audio_devices_.begin();
   for (; audio_it != physical_audio_devices_.end(); ++audio_it) {
     std::string source_id = content::GetHMACForMediaDeviceID(
         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
         origin_,
         audio_it->unique_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.audio.device_id = source_id;
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->audio_devices_[0].device.id, source_id);
   }
 
-  media::VideoCaptureDeviceDescriptors::const_iterator video_it =
-      physical_video_devices_.begin();
-  for (; video_it != physical_video_devices_.end(); ++video_it) {
+  for (const std::string& device_id : stub_video_device_ids_) {
     std::string source_id = content::GetHMACForMediaDeviceID(
         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(), origin_,
-        video_it->device_id);
+        device_id);
     ASSERT_FALSE(source_id.empty());
     StreamControls controls(true, true);
     controls.video.device_id = source_id;
 
     SetupFakeUI(true);
     GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
     EXPECT_EQ(host_->video_devices_[0].device.id, source_id);
   }
 }
 
 // Test that generating a stream with an invalid video source id fail.
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithInvalidVideoSourceId) {
   StreamControls controls(true, true);
   controls.video.device_id = "invalid source id";
 
   GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
                                   MEDIA_DEVICE_NO_HARDWARE);
 }
 
 // Test that generating a stream with an invalid audio source id fail.
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsWithInvalidAudioSourceId) {
   StreamControls controls(true, true);
   controls.audio.device_id = "invalid source id";
 
   GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
                                   MEDIA_DEVICE_NO_HARDWARE);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsNoAvailableVideoDevice) {
-  physical_video_devices_.clear();
-  video_capture_device_factory_->SetToDefaultDevicesConfig(0);
-  video_capture_device_factory_->GetDeviceDescriptors(&physical_video_devices_);
+  stub_video_device_ids_.clear();
   StreamControls controls(true, true);
 
   SetupFakeUI(false);
   GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, controls,
                                   MEDIA_DEVICE_NO_HARDWARE);
 }
 
 // Test that if a OnStopStreamDevice message is received for a device that has
 // been opened in a MediaStream and by pepper, the device is only stopped for
 // the MediaStream.
@@ skipping 135 matching lines @@
 
 // Test that the dispatcher is notified if a video device that is in use is
 // being unplugged.
 TEST_F(MediaStreamDispatcherHostTest, VideoDeviceUnplugged) {
   StreamControls controls(true, true);
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, controls);
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 
-  video_capture_device_factory_->SetToDefaultDevicesConfig(0);
+  stub_video_device_ids_.clear();
 
   base::RunLoop run_loop;
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId))
       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   media_stream_manager_->media_devices_manager()->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   run_loop.Run();
 }
 
 };  // namespace content