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

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 <string>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.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_provider.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
 #include "content/common/media/media_stream_options.h"
-#include "media/video/capture/fake_video_capture_device.h"
-#include "media/video/capture/video_capture_device.h"
+#include "media/video/capture/fake_video_capture_device_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::SaveArg;
 
 namespace content {
@@ skipping 41 matching lines @@
  public:
   VideoCaptureManagerTest() : next_client_id_(1) {}
   virtual ~VideoCaptureManagerTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     listener_.reset(new MockMediaStreamProviderListener());
     message_loop_.reset(new base::MessageLoopForIO);
     io_thread_.reset(new BrowserThreadImpl(BrowserThread::IO,
                                            message_loop_.get()));
-    vcm_ = new VideoCaptureManager();
-    vcm_->UseFakeDevice();
+    vcm_ = new VideoCaptureManager(scoped_ptr<media::VideoCaptureDeviceFactory>(
+        new media::FakeVideoCaptureDeviceFactory()));
+    video_capture_device_factory_ =
+      static_cast<media::FakeVideoCaptureDeviceFactory*>(
+          vcm_->video_capture_device_factory());
     vcm_->Register(listener_.get(), message_loop_->message_loop_proxy().get());
     frame_observer_.reset(new MockFrameObserver());
   }
 
   virtual void TearDown() OVERRIDE {}
 
   void OnGotControllerCallback(
       VideoCaptureControllerID id,
       base::Closure quit_closure,
       bool expect_success,
@@ skipping 37 matching lines @@
     controllers_.erase(client_id);
   }
 
   int next_client_id_;
   std::map<VideoCaptureControllerID, VideoCaptureController*> controllers_;
   scoped_refptr<VideoCaptureManager> vcm_;
   scoped_ptr<MockMediaStreamProviderListener> listener_;
   scoped_ptr<base::MessageLoop> message_loop_;
   scoped_ptr<BrowserThreadImpl> io_thread_;
   scoped_ptr<MockFrameObserver> frame_observer_;
+  media::FakeVideoCaptureDeviceFactory* video_capture_device_factory_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureManagerTest);
 };
 
 // Test cases
 
 // Try to open, start, stop and close a device.
 TEST_F(VideoCaptureManagerTest, CreateAndClose) {
   StreamDeviceInfoArray devices;
@@ skipping 47 matching lines @@
 
   // Wait to check callbacks before removing the listener.
   message_loop_->RunUntilIdle();
   vcm_->Unregister();
 }
 
 // Connect and disconnect devices.
 TEST_F(VideoCaptureManagerTest, ConnectAndDisconnectDevices) {
   StreamDeviceInfoArray devices;
   int number_of_devices_keep =
-      media::FakeVideoCaptureDevice::NumberOfFakeDevices();
+    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);
   message_loop_->RunUntilIdle();
   ASSERT_EQ(devices.size(), 2u);
 
   // Simulate we remove 1 fake device.
-  media::FakeVideoCaptureDevice::SetNumberOfFakeDevices(1);
+  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);
   message_loop_->RunUntilIdle();
   ASSERT_EQ(devices.size(), 1u);
 
   // Simulate we add 2 fake devices.
-  media::FakeVideoCaptureDevice::SetNumberOfFakeDevices(3);
+  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);
   message_loop_->RunUntilIdle();
   ASSERT_EQ(devices.size(), 3u);
 
   vcm_->Unregister();
-  media::FakeVideoCaptureDevice::SetNumberOfFakeDevices(number_of_devices_keep);
+  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;
@@ skipping 204 matching lines @@
 
   // Wait to check callbacks before removing the listener
   message_loop_->RunUntilIdle();
   vcm_->Unregister();
 }
 
 // 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