[Mojo Video Capture] Create abstraction VideoCaptureProvider

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 219 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 {
+class MockVideoCaptureProvider : public VideoCaptureProvider {
  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));
+  MOCK_METHOD2(CreateBuildableDevice,
+               std::unique_ptr<BuildableVideoCaptureDevice>(
+                   const std::string& device_id,
+                   MediaStreamType stream_type));
 };
 
 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();
+    auto mock_video_capture_provider =
+        base::MakeUnique<MockVideoCaptureProvider>();
+    mock_video_capture_provider_ = mock_video_capture_provider.get();
     // Create our own MediaStreamManager.
     media_stream_manager_ = base::MakeUnique<MediaStreamManager>(
-        audio_system_.get(), std::move(mock_video_capture_system),
-        base::ThreadTaskRunnerHandle::Get());
+        audio_system_.get(), std::move(mock_video_capture_provider));
 
     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 {
     stub_video_device_ids_.emplace_back(kRegularVideoDeviceId);
     stub_video_device_ids_.emplace_back(kDepthVideoDeviceId);
-    ON_CALL(*mock_video_capture_system_, GetDeviceInfosAsync(_))
+    ON_CALL(*mock_video_capture_provider_, GetDeviceInfosAsync(_))
         .WillByDefault(Invoke(
             [this](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 = kStubCaptureApi;
                 if (device_id == kDepthVideoDeviceId) {
@@ skipping 157 matching lines @@
   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 audio_device_descriptions_;
   std::vector<std::string> stub_video_device_ids_;
   url::Origin origin_;
-  MockVideoCaptureSystem* mock_video_capture_system_;
+  MockVideoCaptureProvider* mock_video_capture_provider_;
 };
 
 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 393 matching lines @@
   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