Extract VideoCaptureDeviceFactory out of VideoCaptureDevice and use for File and FakeVCD.

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 <string>
 #include <queue>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
+#include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/media/media_stream_dispatcher_host.h"
 #include "content/browser/renderer_host/media/media_stream_manager.h"
 #include "content/browser/renderer_host/media/media_stream_ui_proxy.h"
+#include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/common/media/media_stream_options.h"
 #include "content/public/browser/media_device_id.h"
+#include "content/public/common/content_switches.h"
 #include "content/public/test/mock_resource_context.h"
 #include "content/public/test/test_browser_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "ipc/ipc_message_macros.h"
 #include "media/audio/mock_audio_manager.h"
-#include "media/video/capture/fake_video_capture_device.h"
+#include "media/video/capture/fake_video_capture_device_factory.h"
 #include "net/url_request/url_request_context.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::DoAll;
 using ::testing::Return;
 using ::testing::SaveArg;
 
@@ skipping 172 matching lines @@
 };
 
 class MediaStreamDispatcherHostTest : public testing::Test {
  public:
   MediaStreamDispatcherHostTest()
       : old_browser_client_(NULL),
         thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         origin_("https://test.com") {
     audio_manager_.reset(
         new media::MockAudioManager(base::MessageLoopProxy::current()));
+    // Make sure we use fake devices to avoid long delays.
+    CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kUseFakeDeviceForMediaStream);
     // Create our own MediaStreamManager.
     media_stream_manager_.reset(new MediaStreamManager(audio_manager_.get()));
-    // Make sure we use fake devices to avoid long delays.
-    media_stream_manager_->UseFakeDevice();
+    video_capture_device_factory_ =
+        static_cast<media::FakeVideoCaptureDeviceFactory*>(
+            media_stream_manager_->video_capture_manager()
+            ->video_capture_device_factory());
+    DCHECK(video_capture_device_factory_);
 
     host_ = new MockMediaStreamDispatcherHost(
         browser_context_.GetResourceContext()->GetMediaDeviceIDSalt(),
         base::MessageLoopProxy::current(),
         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());
   }
 
   virtual ~MediaStreamDispatcherHostTest() {
   }
 
   virtual void SetUp() OVERRIDE {
-    media::FakeVideoCaptureDevice::GetDeviceNames(&physical_video_devices_);
+    video_capture_device_factory_->GetDeviceNames(&physical_video_devices_);
     ASSERT_GT(physical_video_devices_.size(), 0u);
 
     audio_manager_->GetAudioInputDeviceNames(&physical_audio_devices_);
     ASSERT_GT(physical_audio_devices_.size(), 0u);
   }
 
   virtual void TearDown() OVERRIDE {
     host_->OnChannelClosing();
   }
 
@@ skipping 129 matching lines @@
   scoped_refptr<MockMediaStreamDispatcherHost> host_;
   scoped_ptr<media::AudioManager> audio_manager_;
   scoped_ptr<MediaStreamManager> media_stream_manager_;
   ContentBrowserClient* old_browser_client_;
   scoped_ptr<ContentClient> content_client_;
   content::TestBrowserThreadBundle thread_bundle_;
   content::TestBrowserContext browser_context_;
   media::AudioDeviceNames physical_audio_devices_;
   media::VideoCaptureDevice::Names physical_video_devices_;
   GURL origin_;
+  media::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
 };
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamWithVideoOnly) {
   StreamOptions options(false, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 
   EXPECT_EQ(host_->audio_devices_.size(), 0u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
@@ skipping 264 matching lines @@
 TEST_F(MediaStreamDispatcherHostTest,
        GenerateStreamsWithInvalidOptionalAudioSourceId) {
   StreamOptions options(true, true);
   AddSourceIdConstraint("invalid source id", &options.optional_audio);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, GenerateStreamsNoAvailableVideoDevice) {
-  size_t number_of_fake_devices = physical_video_devices_.size();
-  media::FakeVideoCaptureDevice::SetNumberOfFakeDevices(0);
-  media::FakeVideoCaptureDevice::GetDeviceNames(&physical_video_devices_);
+  physical_video_devices_.clear();
+  video_capture_device_factory_->set_number_of_devices(0);
+  video_capture_device_factory_->GetDeviceNames(&physical_video_devices_);
   StreamOptions options(true, true);
 
   SetupFakeUI(false);
   GenerateStreamAndWaitForFailure(kRenderId, kPageRequestId, options,
                                   MEDIA_DEVICE_NO_HARDWARE);
-
-  // Reset the number of fake devices for next test.
-  media::FakeVideoCaptureDevice::SetNumberOfFakeDevices(number_of_fake_devices);
 }
 
 // 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.
 TEST_F(MediaStreamDispatcherHostTest, StopDeviceInStream) {
   StreamOptions options(false, true);
 
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
@@ skipping 123 matching lines @@
 
   ASSERT_FALSE(close_callback.is_null());
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId));
   close_callback.Run();
   base::RunLoop().RunUntilIdle();
 }
 
 // Test that the dispatcher is notified if a video device that is in use is
 // being unplugged.
 TEST_F(MediaStreamDispatcherHostTest, VideoDeviceUnplugged) {
-  size_t number_of_fake_devices = physical_video_devices_.size();
   StreamOptions options(true, true);
   SetupFakeUI(true);
   GenerateStreamAndWaitForResult(kRenderId, kPageRequestId, options);
   EXPECT_EQ(host_->audio_devices_.size(), 1u);
   EXPECT_EQ(host_->video_devices_.size(), 1u);
 
-  media::FakeVideoCaptureDevice::SetNumberOfFakeDevices(0);
+  video_capture_device_factory_->set_number_of_devices(0);
 
   base::RunLoop run_loop;
   EXPECT_CALL(*host_.get(), OnDeviceStopped(kRenderId))
       .WillOnce(testing::InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
   media_stream_manager_->OnDevicesChanged(
       base::SystemMonitor::DEVTYPE_VIDEO_CAPTURE);
 
   run_loop.Run();
-
-  media::FakeVideoCaptureDevice::SetNumberOfFakeDevices(number_of_fake_devices);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateAudioDevices) {
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_AUDIO_CAPTURE);
 }
 
 TEST_F(MediaStreamDispatcherHostTest, EnumerateVideoDevices) {
   EnumerateDevicesAndWaitForResult(kRenderId, kPageRequestId,
                                    MEDIA_DEVICE_VIDEO_CAPTURE);
 }
 
 };  // namespace content