Remove device enumeration, caching and monitoring from MediaStreamManager.

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"
 #include "base/metrics/histogram_macros.h"
 #include "build/build_config.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/media_stream_request.h"
 #include "media/audio/audio_input_ipc.h"
 #include "media/audio/audio_manager_base.h"
 #include "media/base/audio_parameters.h"
 #include "media/base/channel_layout.h"
+#include "media/base/media_switches.h"
 
 #if defined(OS_CHROMEOS)
 #include "chromeos/audio/cras_audio_handler.h"
 #endif
 
 namespace content {
 
 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_(NULL),
       next_capture_session_id_(kFirstSessionId),
-      use_fake_device_(false),
 #if defined(OS_CHROMEOS)
       keyboard_mic_streams_count_(0),
 #endif
       audio_manager_(audio_manager) {
 }
 
 AudioInputDeviceManager::~AudioInputDeviceManager() {
 }
 
 const StreamDeviceInfo* AudioInputDeviceManager::GetOpenedDeviceInfoById(
@@ skipping 14 matching lines @@
   DCHECK(!device_task_runner_.get());
   listener_ = listener;
   device_task_runner_ = device_task_runner;
 }
 
 void AudioInputDeviceManager::Unregister() {
   DCHECK(listener_);
   listener_ = NULL;
 }
 
-void AudioInputDeviceManager::EnumerateDevices(MediaStreamType stream_type) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  DCHECK(listener_);
-
-  device_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&AudioInputDeviceManager::EnumerateOnDeviceThread,
-                 this, stream_type));
-}
-
 int AudioInputDeviceManager::Open(const StreamDeviceInfo& 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;
@@ skipping 10 matching lines @@
     devices_.erase(device);
 
   // Post a callback through the listener on IO thread since
   // MediaStreamManager is expecting the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&AudioInputDeviceManager::ClosedOnIOThread,
                                      this, stream_type, session_id));
 }
 
-void AudioInputDeviceManager::UseFakeDevice() {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  use_fake_device_ = true;
-}
-
-bool AudioInputDeviceManager::ShouldUseFakeDevice() const {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  return use_fake_device_;
-}
-
 #if defined(OS_CHROMEOS)
 void AudioInputDeviceManager::RegisterKeyboardMicStream(
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ++keyboard_mic_streams_count_;
   if (keyboard_mic_streams_count_ == 1) {
     BrowserThread::PostTaskAndReply(
         BrowserThread::UI,
         FROM_HERE,
@@ skipping 17 matching lines @@
         BrowserThread::UI,
         FROM_HERE,
         base::Bind(
             &AudioInputDeviceManager::SetKeyboardMicStreamActiveOnUIThread,
             this,
             false));
   }
 }
 #endif
 
-void AudioInputDeviceManager::EnumerateOnDeviceThread(
-    MediaStreamType stream_type) {
-  SCOPED_UMA_HISTOGRAM_TIMER(
-      "Media.AudioInputDeviceManager.EnumerateOnDeviceThreadTime");
-  DCHECK(IsOnDeviceThread());
-  DCHECK_EQ(MEDIA_DEVICE_AUDIO_CAPTURE, stream_type);
-
-  media::AudioDeviceNames device_names;
-  if (use_fake_device_) {
-    // Use the fake devices.
-    GetFakeDeviceNames(&device_names);
-  } else {
-    // Enumerate the devices on the OS.
-    // AudioManager is guaranteed to outlive MediaStreamManager in
-    // BrowserMainloop.
-    audio_manager_->GetAudioInputDeviceNames(&device_names);
-  }
-
-  std::unique_ptr<StreamDeviceInfoArray> devices(new StreamDeviceInfoArray());
-  for (media::AudioDeviceNames::iterator it = device_names.begin();
-       it != device_names.end(); ++it) {
-    // Add device information to device vector.
-    devices->emplace_back(stream_type, it->device_name, it->unique_id,
-                          audio_manager_->GetGroupIDInput(it->unique_id));
-  }
-
-  // Return the device list through the listener by posting a task on
-  // IO thread since MediaStreamManager handles the callback asynchronously.
-  BrowserThread::PostTask(
-      BrowserThread::IO,
-      FROM_HERE,
-      base::Bind(&AudioInputDeviceManager::DevicesEnumeratedOnIOThread,
-                 this, stream_type, base::Passed(&devices)));
-}
-
 void AudioInputDeviceManager::OpenOnDeviceThread(
     int session_id, const StreamDeviceInfo& info) {
   SCOPED_UMA_HISTOGRAM_TIMER(
       "Media.AudioInputDeviceManager.OpenOnDeviceThreadTime");
   DCHECK(IsOnDeviceThread());
 
   StreamDeviceInfo out(info.device.type, info.device.name, info.device.id,
                        info.device.group_id, 0, 0, 0);
   out.session_id = session_id;
 
   MediaStreamDevice::AudioDeviceParameters& input_params = out.device.input;
 
-  if (use_fake_device_) {
+  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;
   } else {
     // Get the preferred sample rate and channel configuration for the
     // audio device.
     media::AudioParameters params =
         audio_manager_->GetInputStreamParameters(info.device.id);
     input_params.sample_rate = params.sample_rate();
     input_params.channel_layout = params.channel_layout();
@@ skipping 17 matching lines @@
   }
 
   // Return the |session_id| through the listener by posting a task on
   // IO thread since MediaStreamManager handles the callback asynchronously.
   BrowserThread::PostTask(BrowserThread::IO,
                           FROM_HERE,
                           base::Bind(&AudioInputDeviceManager::OpenedOnIOThread,
                                      this, session_id, out));
 }
 
-void AudioInputDeviceManager::DevicesEnumeratedOnIOThread(
-    MediaStreamType stream_type,
-    std::unique_ptr<StreamDeviceInfoArray> devices) {
-  DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  // Ensure that |devices| gets deleted on exit.
-  if (listener_)
-    listener_->DevicesEnumerated(stream_type, *devices);
-}
-
 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);
@@ skipping 14 matching lines @@
 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();
 }
 
-void AudioInputDeviceManager::GetFakeDeviceNames(
-    media::AudioDeviceNames* device_names) {
-  static const char kFakeDeviceName1[] = "Fake Audio 1";
-  static const char kFakeDeviceId1[] = "fake_audio_1";
-  static const char kFakeDeviceName2[] = "Fake Audio 2";
-  static const char kFakeDeviceId2[] = "fake_audio_2";
-  DCHECK(device_names->empty());
-  DCHECK(use_fake_device_);
-  device_names->push_back(media::AudioDeviceName(kFakeDeviceName1,
-                                                 kFakeDeviceId1));
-  device_names->push_back(media::AudioDeviceName(kFakeDeviceName2,
-                                                 kFakeDeviceId2));
-}
-
 #if defined(OS_CHROMEOS)
 void AudioInputDeviceManager::SetKeyboardMicStreamActiveOnUIThread(
     bool active) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   chromeos::CrasAudioHandler::Get()->SetKeyboardMicActive(active);
 }
 #endif
 
 
 }  // namespace content