[Mojo Video Capture] Add content_browsertest for exercising video capture

content/browser/renderer_host/media/audio_input_device_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/audio_input_device_manager.h"
 
 #include <memory>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 15 matching lines @@
 
 const int AudioInputDeviceManager::kFakeOpenSessionId = 1;
 
 namespace {
 // Starting id for the first capture session.
 const int kFirstSessionId = AudioInputDeviceManager::kFakeOpenSessionId + 1;
 }
 
 AudioInputDeviceManager::AudioInputDeviceManager(
     media::AudioManager* audio_manager)
-    : listener_(nullptr),
-      next_capture_session_id_(kFirstSessionId),
+    : next_capture_session_id_(kFirstSessionId),
 #if defined(OS_CHROMEOS)
       keyboard_mic_streams_count_(0),
 #endif
       audio_manager_(audio_manager),
       device_task_runner_(audio_manager_->GetTaskRunner()) {
 }
 
 AudioInputDeviceManager::~AudioInputDeviceManager() {
 }
 
 const StreamDeviceInfo* AudioInputDeviceManager::GetOpenedDeviceInfoById(
     int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   StreamDeviceList::iterator device = GetDevice(session_id);
   if (device == devices_.end())
     return nullptr;
 
   return &(*device);
 }
 
 void AudioInputDeviceManager::RegisterListener(
     MediaStreamProviderListener* listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(!listener_);
+  DCHECK(listener);
   DCHECK(device_task_runner_);
-  listener_ = listener;
+  listeners_.AddObserver(listener);
 }
 
-void AudioInputDeviceManager::UnregisterListener() {
+void AudioInputDeviceManager::UnregisterListener(
+    MediaStreamProviderListener* listener) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(listener_);
-  listener_ = nullptr;
+  DCHECK(listener);
+  listeners_.RemoveObserver(listener);
 }
 
-int AudioInputDeviceManager::Open(const StreamDeviceInfo& device) {
+int AudioInputDeviceManager::Open(const MediaStreamDevice& device) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Generate a new id for this device.
   int session_id = next_capture_session_id_++;
   device_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&AudioInputDeviceManager::OpenOnDeviceThread,
                  this, session_id, device));
 
   return session_id;
 }
 
 void AudioInputDeviceManager::Close(int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(listener_);
+  DCHECK(listeners_.might_have_observers());

[miu, 2017/03/06 21:54:10]

This is weird. Why would a Close() operation require observers be present? Is
the DCHECK() just stating "what would normally be" instead of actually checking
an assumption that would break the impl? If so, it's probably too pedantic and
can be removed. If not, can you add a comment to make it clear what the
assumption is here?

[chfremer, 2017/03/06 23:39:38]

removed

   StreamDeviceList::iterator device = GetDevice(session_id);
   if (device == devices_.end())
     return;
   const MediaStreamType stream_type = device->device.type;
   if (session_id != kFakeOpenSessionId)
     devices_.erase(device);
 
   // Post a callback through the listener on IO thread since
   // MediaStreamManager is expecting the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
@@ skipping 33 matching lines @@
         FROM_HERE,
         base::Bind(
             &AudioInputDeviceManager::SetKeyboardMicStreamActiveOnUIThread,
             this,
             false));
   }
 }
 #endif
 
 void AudioInputDeviceManager::OpenOnDeviceThread(
-    int session_id, const StreamDeviceInfo& info) {
+    int session_id,
+    const MediaStreamDevice& device) {
   SCOPED_UMA_HISTOGRAM_TIMER(
       "Media.AudioInputDeviceManager.OpenOnDeviceThreadTime");
   DCHECK(IsOnDeviceThread());
 
-  StreamDeviceInfo out(info.device.type, info.device.name, info.device.id, 0, 0,
-                       0);
+  StreamDeviceInfo out(device.type, device.name, device.id, 0, 0, 0);
   out.session_id = session_id;
 
   MediaStreamDevice::AudioDeviceParameters& input_params = out.device.input;
 
   // Add preferred output device information if a matching output device
   // exists.
   out.device.matched_output_device_id =
-      audio_manager_->GetAssociatedOutputDeviceID(info.device.id);
+      audio_manager_->GetAssociatedOutputDeviceID(device.id);
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kUseFakeDeviceForMediaStream)) {
     // Don't need to query the hardware information if using fake device.
     input_params.sample_rate = 44100;
     input_params.channel_layout = media::CHANNEL_LAYOUT_STEREO;
     if (!out.device.matched_output_device_id.empty()) {
       out.device.matched_output.sample_rate = 44100;
       out.device.matched_output.channel_layout = media::CHANNEL_LAYOUT_STEREO;
     }
   } else {
     // TODO(tommi): As is, we hit this code path when device.type is
     // MEDIA_TAB_AUDIO_CAPTURE and the device id is not a device that
     // the AudioManager can know about. This currently does not fail because
     // the implementation of GetInputStreamParameters returns valid parameters
     // by default for invalid devices. That behavior is problematic because it
     // causes other parts of the code to attempt to open truly invalid or
     // missing devices and falling back on alternate devices (and likely fail
     // twice in a row). Tab audio capture should not pass through here and
     // GetInputStreamParameters should return invalid parameters for invalid
     // devices.
 
     // Get the preferred sample rate and channel configuration for the
     // audio device.
     media::AudioParameters params =
-        audio_manager_->GetInputStreamParameters(info.device.id);
+        audio_manager_->GetInputStreamParameters(device.id);
     input_params.sample_rate = params.sample_rate();
     input_params.channel_layout = params.channel_layout();
     input_params.frames_per_buffer = params.frames_per_buffer();
     input_params.effects = params.effects();
     input_params.mic_positions = params.mic_positions();
     if (!out.device.matched_output_device_id.empty()) {
       params = audio_manager_->GetOutputStreamParameters(
           out.device.matched_output_device_id);
       MediaStreamDevice::AudioDeviceParameters& matched_output_params =
           out.device.matched_output;
@@ skipping 12 matching lines @@
 }
 
 void AudioInputDeviceManager::OpenedOnIOThread(int session_id,
                                                const StreamDeviceInfo& info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK_EQ(session_id, info.session_id);
   DCHECK(GetDevice(session_id) == devices_.end());
 
   devices_.push_back(info);
 
-  if (listener_)
-    listener_->Opened(info.device.type, session_id);
+  for (auto& listener : listeners_)
+    listener.Opened(info.device.type, session_id);
 }
 
 void AudioInputDeviceManager::ClosedOnIOThread(MediaStreamType stream_type,
                                                int session_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (listener_)
-    listener_->Closed(stream_type, session_id);
+  for (auto& listener : listeners_)
+    listener.Closed(stream_type, session_id);
 }
 
 bool AudioInputDeviceManager::IsOnDeviceThread() const {
   return device_task_runner_->BelongsToCurrentThread();
 }
 
 AudioInputDeviceManager::StreamDeviceList::iterator
 AudioInputDeviceManager::GetDevice(int session_id) {
   for (StreamDeviceList::iterator i(devices_.begin()); i != devices_.end();
        ++i) {
     if (i->session_id == session_id)
       return i;
   }
 
   return devices_.end();
 }
 
 #if defined(OS_CHROMEOS)
 void AudioInputDeviceManager::SetKeyboardMicStreamActiveOnUIThread(
     bool active) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   chromeos::CrasAudioHandler::Get()->SetKeyboardMicActive(active);
 }
 #endif
 
 
 }  // namespace content