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

content/browser/renderer_host/media/video_capture_manager.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/video_capture_manager.h"
 
 #include <set>
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/stl_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "content/browser/media/capture/web_contents_video_capture_device.h"
 #include "content/browser/renderer_host/media/video_capture_controller.h"
 #include "content/browser/renderer_host/media/video_capture_controller_event_handler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/desktop_media_id.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/media_stream_request.h"
-#include "media/base/media_switches.h"
 #include "media/base/scoped_histogram_timer.h"
-#include "media/video/capture/fake_video_capture_device.h"
-#include "media/video/capture/file_video_capture_device.h"
+#include "media/video/capture/fake_video_capture_device_factory.h"

[perkj_chrome, 2014/04/15 09:34:01]

You should not need these includes here.

[mcasas, 2014/04/15 13:47:09]

Done.

+#include "media/video/capture/file_video_capture_device_factory.h"
 #include "media/video/capture/video_capture_device.h"
 
 #if defined(ENABLE_SCREEN_CAPTURE)
 #include "content/browser/media/capture/desktop_capture_device.h"
 #if defined(USE_AURA)
 #include "content/browser/media/capture/desktop_capture_device_aura.h"
 #endif
 #endif
 
 namespace {
@@ skipping 54 matching lines @@
     const media::VideoCaptureDevice::Name& name,
     const media::VideoCaptureFormats& supported_formats)
     : name(name),
       supported_formats(supported_formats) {}
 
 VideoCaptureManager::DeviceInfo::~DeviceInfo() {}
 
 VideoCaptureManager::VideoCaptureManager()
     : listener_(NULL),
       new_capture_session_id_(1),
-      artificial_device_source_for_testing_(DISABLED) {
+      use_testing_device_source_(false) {
 }
 
 VideoCaptureManager::~VideoCaptureManager() {
   DCHECK(devices_.empty());
 }
 
 void VideoCaptureManager::Register(
     MediaStreamProviderListener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& device_task_runner) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 67 matching lines @@
     DestroyDeviceEntryIfNoClients(existing_device);
   }
 
   // Notify listeners asynchronously, and forget the session.
   base::MessageLoop::current()->PostTask(FROM_HERE,
       base::Bind(&VideoCaptureManager::OnClosed, this, session_it->second.type,
                  capture_session_id));
   sessions_.erase(session_it);
 }
 
-void VideoCaptureManager::UseFakeDevice() {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUseFileForFakeVideoCapture)) {
-    artificial_device_source_for_testing_ = Y4M_FILE;
-  } else {
-    artificial_device_source_for_testing_ = TEST_PATTERN;
-  }
+void VideoCaptureManager::UseFakeDevice(
+    scoped_ptr<media::VideoCaptureDeviceFactory> factory) {
+  use_testing_device_source_ = true;
+  video_capture_device_factory_ = factory.Pass();
 }
 
 void VideoCaptureManager::DoStartDeviceOnDeviceThread(
     media::VideoCaptureSessionId session_id,
     DeviceEntry* entry,
     const media::VideoCaptureParams& params,
     scoped_ptr<media::VideoCaptureDevice::Client> device_client) {
   SCOPED_UMA_HISTOGRAM_TIMER("Media.VideoCaptureManager.StartDeviceTime");
   DCHECK(IsOnDeviceThread());

[perkj_chrome, 2014/04/15 09:34:01]

This is not the IO thread right?

[mcasas, 2014/04/15 13:47:09]

No, is a different one, Device thread, also known as
Audio Thread (where Audio Manager lives).

 
   scoped_ptr<media::VideoCaptureDevice> video_capture_device;
   switch (entry->stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE: {
       // We look up the device id from the renderer in our local enumeration
       // since the renderer does not have all the information that might be
       // held in the browser-side VideoCaptureDevice::Name structure.
       DeviceInfo* found = FindDeviceInfoById(entry->id, devices_info_cache_);
       if (found) {
-        switch (artificial_device_source_for_testing_) {
-          case DISABLED:
-            video_capture_device.reset(
-                media::VideoCaptureDevice::Create(found->name));
-            break;
-          case TEST_PATTERN:
-            video_capture_device.reset(
-                media::FakeVideoCaptureDevice::Create(found->name));
-            break;
-          case Y4M_FILE:
-            video_capture_device.reset(
-                media::FileVideoCaptureDevice::Create(found->name));
-            break;
+        if (!use_testing_device_source_) {

[perkj_chrome, 2014/04/15 09:34:01]

This is ugly. Always use a device factory but have different implementations.

[mcasas, 2014/04/15 13:47:09]

Done.

+          video_capture_device.reset(
+              media::VideoCaptureDevice::Create(found->name));
+        } else {
+          video_capture_device.reset(
+              video_capture_device_factory_->Create(found->name));
         }
       }
       break;
     }
     case MEDIA_TAB_VIDEO_CAPTURE: {
       video_capture_device.reset(
           WebContentsVideoCaptureDevice::Create(entry->id));
       break;
     }
     case MEDIA_DESKTOP_VIDEO_CAPTURE: {
@@ skipping 239 matching lines @@
     const DeviceInfos& old_device_info_cache) {
   SCOPED_UMA_HISTOGRAM_TIMER(
       "Media.VideoCaptureManager.GetAvailableDevicesInfoOnDeviceThreadTime");
   DCHECK(IsOnDeviceThread());
   media::VideoCaptureDevice::Names names_snapshot;
   switch (stream_type) {
     case MEDIA_DEVICE_VIDEO_CAPTURE:
       // Cache the latest enumeration of video capture devices.
       // We'll refer to this list again in OnOpen to avoid having to
       // enumerate the devices again.
-      switch (artificial_device_source_for_testing_) {
-        case DISABLED:
-          media::VideoCaptureDevice::GetDeviceNames(&names_snapshot);
-          break;
-        case TEST_PATTERN:
-          media::FakeVideoCaptureDevice::GetDeviceNames(&names_snapshot);
-          break;
-        case Y4M_FILE:
-          media::FileVideoCaptureDevice::GetDeviceNames(&names_snapshot);
-          break;
-      }
+      if (!use_testing_device_source_)

[perkj_chrome, 2014/04/15 09:34:01]

dito

[mcasas, 2014/04/15 13:47:09]

Done.

+        media::VideoCaptureDevice::GetDeviceNames(&names_snapshot);
+      else
+        video_capture_device_factory_->GetDeviceNames(&names_snapshot);
       break;
 
     case MEDIA_DESKTOP_VIDEO_CAPTURE:
       // Do nothing.
       break;
 
     default:
       NOTREACHED();
       break;
   }
@@ skipping 15 matching lines @@
       }
     }
   }
 
   // Get the supported capture formats for the new devices in |names_snapshot|.
   for (media::VideoCaptureDevice::Names::const_iterator it =
            names_snapshot.begin();
        it != names_snapshot.end(); ++it) {
     media::VideoCaptureFormats supported_formats;
     DeviceInfo device_info(*it, media::VideoCaptureFormats());
-    switch (artificial_device_source_for_testing_) {
-      case DISABLED:
-        media::VideoCaptureDevice::GetDeviceSupportedFormats(
-            *it, &(device_info.supported_formats));
-        break;
-      case TEST_PATTERN:
-        media::FakeVideoCaptureDevice::GetDeviceSupportedFormats(
-            *it, &(device_info.supported_formats));
-        break;
-      case Y4M_FILE:
-        media::FileVideoCaptureDevice::GetDeviceSupportedFormats(
-            *it, &(device_info.supported_formats));
-        break;
+
+    if (!use_testing_device_source_) {
+      media::VideoCaptureDevice::GetDeviceSupportedFormats(
+          *it, &(device_info.supported_formats));
+    } else {
+      video_capture_device_factory_->GetDeviceSupportedFormats(
+          *it, &(device_info.supported_formats));
     }
     ConsolidateCaptureFormats(&device_info.supported_formats);
     new_devices_info_cache.push_back(device_info);
   }
   return new_devices_info_cache;
 }
 
 VideoCaptureManager::DeviceEntry*
 VideoCaptureManager::GetDeviceEntryForMediaStreamDevice(
     const MediaStreamDevice& device_info) {
@@ skipping 98 matching lines @@
 void VideoCaptureManager::SaveDesktopCaptureWindowIdOnDeviceThread(
     media::VideoCaptureSessionId session_id,
     gfx::NativeViewId window_id) {
   DCHECK(IsOnDeviceThread());
   DCHECK(notification_window_ids_.find(session_id) ==
          notification_window_ids_.end());
   notification_window_ids_[session_id] = window_id;
 }
 
 }  // namespace content