content_browsertests will now use fake webrtc devices.

content/browser/renderer_host/media/media_stream_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/media_stream_manager.h"
 
 #include <list>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 116 matching lines @@
   StreamDeviceInfoArray video_devices;
 };
 
 MediaStreamManager::EnumerationCache::EnumerationCache()
     : valid(false) {
 }
 
 MediaStreamManager::EnumerationCache::~EnumerationCache() {
 }
 
+bool MediaStreamManager::always_use_fake_devices_ = false;
+
+// static
+void MediaStreamManager::AlwaysUseFakeDevice() {
+  always_use_fake_devices_ = true;
+}
+
 MediaStreamManager::MediaStreamManager(
     AudioInputDeviceManager* audio_input_device_manager,
     VideoCaptureManager* video_capture_manager)
     : ALLOW_THIS_IN_INITIALIZER_LIST(
           device_settings_(new MediaStreamDeviceSettings(this))),
       audio_input_device_manager_(audio_input_device_manager),
       video_capture_manager_(video_capture_manager),
       monitoring_started_(false),
       io_loop_(NULL) {
   memset(active_enumeration_ref_count_, 0,
@@ skipping 20 matching lines @@
   return audio_input_device_manager_;
 }
 
 void MediaStreamManager::GenerateStream(MediaStreamRequester* requester,
                                         int render_process_id,
                                         int render_view_id,
                                         const StreamOptions& options,
                                         const GURL& security_origin,
                                         std::string* label) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (always_use_fake_devices_)
+    UseFakeDevice();
 
   // Create a new request based on options.
   DeviceRequest new_request(requester, options,
                             render_process_id,
                             render_view_id,
                             security_origin);
   StartEnumeration(&new_request, label);
 
   // Get user confirmation to use capture devices.
   device_settings_->RequestCaptureDeviceUsage(*label,
@@ skipping 521 matching lines @@
 
   audio_input_device_manager_ = NULL;
   video_capture_manager_ = NULL;
   io_loop_ = NULL;
   device_settings_.reset();
 }
 
 void MediaStreamManager::NotifyObserverDevicesOpened(DeviceRequest* request) {
   content::MediaObserver* media_observer =
       content::GetContentClient()->browser()->GetMediaObserver();
+  if (media_observer == NULL)
+    return;
   content::MediaStreamDevices opened_devices;
   DevicesFromRequest(request, &opened_devices);
   DCHECK(!opened_devices.empty());
   media_observer->OnCaptureDevicesOpened(request->render_process_id,
                                          request->render_view_id,
                                          opened_devices);
 }
 
 void MediaStreamManager::NotifyObserverDevicesClosed(DeviceRequest* request) {
   content::MediaObserver* media_observer =
       content::GetContentClient()->browser()->GetMediaObserver();
+  if (media_observer == NULL)
+    return;
   content::MediaStreamDevices closed_devices;
   DevicesFromRequest(request, &closed_devices);
   if (closed_devices.empty())
     return;
   media_observer->OnCaptureDevicesClosed(request->render_process_id,
                                          request->render_view_id,
                                          closed_devices);
 }
 
 void MediaStreamManager::DevicesFromRequest(
@@ skipping 113 matching lines @@
        it != requests_.end(); ++it) {
     if (it->second.type == DeviceRequest::ENUMERATE_DEVICES &&
         Requested(it->second.options, stream_type)) {
       return true;
     }
   }
   return false;
 }
 
 }  // namespace media_stream