Reland 153623004: Remove the unified IO code on the browser

media/audio/audio_manager_base.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 "media/audio/audio_manager_base.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 19 matching lines @@
 
 static const int kMaxInputChannels = 2;
 
 const char AudioManagerBase::kDefaultDeviceName[] = "Default";
 const char AudioManagerBase::kDefaultDeviceId[] = "default";
 const char AudioManagerBase::kLoopbackInputDeviceId[] = "loopback";
 
 struct AudioManagerBase::DispatcherParams {
   DispatcherParams(const AudioParameters& input,
                    const AudioParameters& output,
-                   const std::string& output_device_id,
-                   const std::string& input_device_id)
+                   const std::string& output_device_id)
       : input_params(input),
-        output_params(output),
-        input_device_id(input_device_id),
-        output_device_id(output_device_id) {}
+        output_params(output) {}
   ~DispatcherParams() {}
 
   const AudioParameters input_params;
   const AudioParameters output_params;
-  const std::string input_device_id;
   const std::string output_device_id;
   scoped_refptr<AudioOutputDispatcher> dispatcher;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DispatcherParams);
 };
 
 class AudioManagerBase::CompareByParams {
  public:
   explicit CompareByParams(const DispatcherParams* dispatcher)
       : dispatcher_(dispatcher) {}
   bool operator()(DispatcherParams* dispatcher_in) const {
     // We will reuse the existing dispatcher when:
     // 1) Unified IO is not used, input_params and output_params of the
     //    existing dispatcher are the same as the requested dispatcher.
-    // 2) Unified IO is used, input_params, output_params and input_device_id
-    //    of the existing dispatcher are the same as the request dispatcher.
+    // 2) Unified IO is used, input_params and output_params of the existing
+    //    dispatcher are the same as the request dispatcher.
     return (dispatcher_->input_params == dispatcher_in->input_params &&
             dispatcher_->output_params == dispatcher_in->output_params &&
-            dispatcher_->output_device_id == dispatcher_in->output_device_id &&
-            (!dispatcher_->input_params.input_channels() ||
-             dispatcher_->input_device_id == dispatcher_in->input_device_id));
+            dispatcher_->output_device_id == dispatcher_in->output_device_id);
   }
 
  private:
   const DispatcherParams* dispatcher_;
 };
 
 AudioManagerBase::AudioManagerBase(AudioLogFactory* audio_log_factory)
     : max_num_output_streams_(kDefaultMaxOutputStreams),
       max_num_input_streams_(kDefaultMaxInputStreams),
       num_output_streams_(0),
@@ skipping 49 matching lines @@
 AudioManagerBase::GetWorkerTaskRunner() {
   // Lazily start the worker thread.
   if (!audio_thread_.IsRunning())
     CHECK(audio_thread_.Start());
 
   return audio_thread_.message_loop_proxy();
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStream(
     const AudioParameters& params,
-    const std::string& device_id,
-    const std::string& input_device_id) {
+    const std::string& device_id) {
   // TODO(miu): Fix ~50 call points across several unit test modules to call
   // this method on the audio thread, then uncomment the following:
   // DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!params.IsValid()) {
     DLOG(ERROR) << "Audio parameters are invalid";
     return NULL;
   }
 
   // Limit the number of audio streams opened. This is to prevent using
   // excessive resources for a large number of audio streams. More
   // importantly it prevents instability on certain systems.
   // See bug: http://crbug.com/30242.
   if (num_output_streams_ >= max_num_output_streams_) {
     DLOG(ERROR) << "Number of opened output audio streams "
                 << num_output_streams_
                 << " exceed the max allowed number "
                 << max_num_output_streams_;
     return NULL;
   }
 
   AudioOutputStream* stream;
   switch (params.format()) {
     case AudioParameters::AUDIO_PCM_LINEAR:
       DCHECK(device_id.empty())
           << "AUDIO_PCM_LINEAR supports only the default device.";
       stream = MakeLinearOutputStream(params);
       break;
     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
-      stream = MakeLowLatencyOutputStream(params, device_id, input_device_id);
+      stream = MakeLowLatencyOutputStream(params, device_id);
       break;
     case AudioParameters::AUDIO_FAKE:
       stream = FakeAudioOutputStream::MakeFakeStream(this, params);
       break;
     default:
       stream = NULL;
       break;
   }
 
   if (stream) {
@@ skipping 41 matching lines @@
 
   if (stream) {
     ++num_input_streams_;
   }
 
   return stream;
 }
 
 AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
     const AudioParameters& params,
-    const std::string& device_id,
-    const std::string& input_device_id) {
+    const std::string& device_id) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   // If the caller supplied an empty device id to select the default device,
   // we fetch the actual device id of the default device so that the lookup
   // will find the correct device regardless of whether it was opened as
   // "default" or via the specific id.
   // NOTE: Implementations that don't yet support opening non-default output
   // devices may return an empty string from GetDefaultOutputDeviceID().
   std::string output_device_id = device_id.empty() ?
       GetDefaultOutputDeviceID() : device_id;
@@ skipping 19 matching lines @@
 
       // Tell the AudioManager to create a fake output device.
       output_params = AudioParameters(
           AudioParameters::AUDIO_FAKE, params.channel_layout(),
           params.sample_rate(), params.bits_per_sample(),
           params.frames_per_buffer());
     }
   }
 
   DispatcherParams* dispatcher_params =
-      new DispatcherParams(params, output_params, output_device_id,
-          input_device_id);
+      new DispatcherParams(params, output_params, output_device_id);
 
   AudioOutputDispatchers::iterator it =
       std::find_if(output_dispatchers_.begin(), output_dispatchers_.end(),
                    CompareByParams(dispatcher_params));
   if (it != output_dispatchers_.end()) {
     delete dispatcher_params;
     return new AudioOutputProxy((*it)->dispatcher.get());
   }
 
   const base::TimeDelta kCloseDelay =
       base::TimeDelta::FromSeconds(kStreamCloseDelaySeconds);
   scoped_refptr<AudioOutputDispatcher> dispatcher;
   if (output_params.format() != AudioParameters::AUDIO_FAKE) {
     dispatcher = new AudioOutputResampler(this, params, output_params,
-                                          output_device_id, input_device_id,
+                                          output_device_id,
                                           kCloseDelay);
   } else {
     dispatcher = new AudioOutputDispatcherImpl(this, output_params,
                                                output_device_id,
-                                               input_device_id, kCloseDelay);
+                                               kCloseDelay);
   }
 
   dispatcher_params->dispatcher = dispatcher;
   output_dispatchers_.push_back(dispatcher_params);
   return new AudioOutputProxy(dispatcher.get());
 }
 
 void AudioManagerBase::ShowAudioInputSettings() {
 }
 
@@ skipping 137 matching lines @@
     (*it)->dispatcher->CloseStreamsForWedgeFix();
   }
   for (AudioOutputDispatchers::iterator it = output_dispatchers_.begin();
        it != output_dispatchers_.end(); ++it) {
     (*it)->dispatcher->RestartStreamsForWedgeFix();
   }
 #endif
 }
 
 }  // namespace media