Reland 153623004: Remove the unified IO code on the browser

Remove the unified IO code on the browser.

Unified IO is not used any more and it should be removed.

TBR=dalecurtis@chromium.org
BUG=337096
TEST=bots, and nothing breaks.

Review URL: https://codereview.chromium.org/163343002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@251018 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/media/media_internals.cc

@@ -39,8 +39,7 @@ class AudioLogImpl : public media::AudioLog {
 
   virtual void OnCreated(int component_id,
                          const media::AudioParameters& params,
-                         const std::string& input_device_id,
-                         const std::string& output_device_id) OVERRIDE;
+                         const std::string& device_id) OVERRIDE;
   virtual void OnStarted(int component_id) OVERRIDE;
   virtual void OnStopped(int component_id) OVERRIDE;
   virtual void OnClosed(int component_id) OVERRIDE;
@@ -72,17 +71,15 @@ AudioLogImpl::~AudioLogImpl() {}
 
 void AudioLogImpl::OnCreated(int component_id,
                              const media::AudioParameters& params,
-                             const std::string& input_device_id,
-                             const std::string& output_device_id) {
+                             const std::string& device_id) {
   base::DictionaryValue dict;
   StoreComponentMetadata(component_id, &dict);
 
   dict.SetString(kAudioLogStatusKey, "created");
-  dict.SetString("input_device_id", input_device_id);
+  dict.SetString("device_id", device_id);
   dict.SetInteger("input_channels", params.input_channels());
   dict.SetInteger("frames_per_buffer", params.frames_per_buffer());
   dict.SetInteger("sample_rate", params.sample_rate());
-  dict.SetString("output_device_id", output_device_id);
   dict.SetInteger("channels", params.channels());
   dict.SetString("channel_layout",
                  ChannelLayoutToString(params.channel_layout()));

content/browser/media/media_internals_unittest.cc

@@ -16,8 +16,7 @@
 
 namespace {
 const int kTestComponentID = 0;
-const char kTestInputDeviceID[] = "test-input-id";
-const char kTestOutputDeviceID[] = "test-output-id";
+const char kTestDeviceID[] = "test-device-id";
 }  // namespace
 
 namespace content {
@@ -87,7 +86,7 @@ class MediaInternalsTest
 
 TEST_P(MediaInternalsTest, AudioLogCreateStartStopErrorClose) {
   audio_log_->OnCreated(
-      kTestComponentID, test_params_, kTestInputDeviceID, kTestOutputDeviceID);
+      kTestComponentID, test_params_, kTestDeviceID);
   base::RunLoop().RunUntilIdle();
 
   ExpectString("channel_layout",
@@ -96,8 +95,7 @@ TEST_P(MediaInternalsTest, AudioLogCreateStartStopErrorClose) {
   ExpectInt("frames_per_buffer", test_params_.frames_per_buffer());
   ExpectInt("channels", test_params_.channels());
   ExpectInt("input_channels", test_params_.input_channels());
-  ExpectString("output_device_id", kTestOutputDeviceID);
-  ExpectString("input_device_id", kTestInputDeviceID);
+  ExpectString("device_id", kTestDeviceID);
   ExpectInt("component_id", kTestComponentID);
   ExpectInt("component_type", test_component_);
   ExpectStatus("created");
@@ -128,7 +126,7 @@ TEST_P(MediaInternalsTest, AudioLogCreateStartStopErrorClose) {
 
 TEST_P(MediaInternalsTest, AudioLogCreateClose) {
   audio_log_->OnCreated(
-      kTestComponentID, test_params_, kTestInputDeviceID, kTestOutputDeviceID);
+      kTestComponentID, test_params_, kTestDeviceID);
   base::RunLoop().RunUntilIdle();
   ExpectStatus("created");
 

content/browser/renderer_host/media/audio_input_renderer_host.cc

@@ -314,7 +314,7 @@ void AudioInputRendererHost::OnCreateStream(
 
   MediaStreamManager::SendMessageToNativeLog(
       "Audio input stream created successfully.");
-  audio_log_->OnCreated(stream_id, audio_params, device_id, std::string());
+  audio_log_->OnCreated(stream_id, audio_params, device_id);
 }
 
 void AudioInputRendererHost::OnRecordStream(int stream_id) {

content/browser/renderer_host/media/audio_renderer_host.cc

@@ -36,7 +36,6 @@ class AudioRendererHost::AudioEntry
              int render_view_id,
              const media::AudioParameters& params,
              const std::string& output_device_id,
-             const std::string& input_device_id,
              scoped_ptr<base::SharedMemory> shared_memory,
              scoped_ptr<media::AudioOutputController::SyncReader> reader);
   virtual ~AudioEntry();
@@ -89,15 +88,13 @@ AudioRendererHost::AudioEntry::AudioEntry(
     AudioRendererHost* host, int stream_id, int render_view_id,
     const media::AudioParameters& params,
     const std::string& output_device_id,
-    const std::string& input_device_id,
     scoped_ptr<base::SharedMemory> shared_memory,
     scoped_ptr<media::AudioOutputController::SyncReader> reader)
     : host_(host),
       stream_id_(stream_id),
       render_view_id_(render_view_id),
       controller_(media::AudioOutputController::Create(
-          host->audio_manager_, this, params, output_device_id,
-          input_device_id, reader.get())),
+          host->audio_manager_, this, params, output_device_id, reader.get())),
       shared_memory_(shared_memory.Pass()),
       reader_(reader.Pass()) {
   DCHECK(controller_.get());
@@ -314,53 +311,32 @@ void AudioRendererHost::OnCreateStream(
   DCHECK_GT(render_view_id, 0);
 
   // media::AudioParameters is validated in the deserializer.
-  int input_channels = params.input_channels();
-  if (input_channels < 0 ||
-      input_channels > media::limits::kMaxChannels ||
-      LookupById(stream_id) != NULL) {
+  if (LookupById(stream_id) != NULL) {
     SendErrorMessage(stream_id);
     return;
   }
 
-  // When the |input_channels| is valid, clients are trying to create a unified
-  // IO stream which opens an input device mapping to the |session_id|.
   // Initialize the |output_device_id| to an empty string which indicates that
   // the default device should be used. If a StreamDeviceInfo instance was found
   // though, then we use the matched output device.
-  std::string input_device_id, output_device_id;
+  std::string output_device_id;
   const StreamDeviceInfo* info = media_stream_manager_->
       audio_input_device_manager()->GetOpenedDeviceInfoById(session_id);
   if (info)
     output_device_id = info->device.matched_output_device_id;
 
-  if (input_channels > 0) {
-    if (!info) {
-      SendErrorMessage(stream_id);
-      DLOG(WARNING) << "No permission has been granted to input stream with "
-                    << "session_id=" << session_id;
-      return;
-    }
-
-    input_device_id = info->device.id;
-  }
-
-  // Calculate output and input memory size.
-  int output_memory_size = AudioBus::CalculateMemorySize(params);
-  int frames = params.frames_per_buffer();
-  int input_memory_size = AudioBus::CalculateMemorySize(input_channels, frames);
-
   // Create the shared memory and share with the renderer process.
   // For synchronized I/O (if input_channels > 0) then we allocate
   // extra memory after the output data for the input data.
-  uint32 shared_memory_size = output_memory_size + input_memory_size;
+  uint32 shared_memory_size = AudioBus::CalculateMemorySize(params);;
   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
   if (!shared_memory->CreateAndMapAnonymous(shared_memory_size)) {
     SendErrorMessage(stream_id);
     return;
   }
 
   scoped_ptr<AudioSyncReader> reader(
-      new AudioSyncReader(shared_memory.get(), params, input_channels));
+      new AudioSyncReader(shared_memory.get(), params));
   if (!reader->Init()) {
     SendErrorMessage(stream_id);
     return;
@@ -373,14 +349,14 @@ void AudioRendererHost::OnCreateStream(
 
   scoped_ptr<AudioEntry> entry(new AudioEntry(
       this, stream_id, render_view_id, params, output_device_id,
-      input_device_id, shared_memory.Pass(),
+      shared_memory.Pass(),
       reader.PassAs<media::AudioOutputController::SyncReader>()));
   if (mirroring_manager_) {
     mirroring_manager_->AddDiverter(
         render_process_id_, entry->render_view_id(), entry->controller());
   }
   audio_entries_.insert(std::make_pair(stream_id, entry.release()));
-  audio_log_->OnCreated(stream_id, params, input_device_id, output_device_id);
+  audio_log_->OnCreated(stream_id, params, output_device_id);
 }
 
 void AudioRendererHost::OnPlayStream(int stream_id) {

content/browser/renderer_host/media/audio_sync_reader.cc

@@ -18,10 +18,8 @@ using media::AudioBus;
 namespace content {
 
 AudioSyncReader::AudioSyncReader(base::SharedMemory* shared_memory,
-                                 const media::AudioParameters& params,
-                                 int input_channels)
+                                 const media::AudioParameters& params)
     : shared_memory_(shared_memory),
-      input_channels_(input_channels),
       mute_audio_(CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMuteAudio)),
       packet_size_(shared_memory_->requested_size()),
@@ -34,18 +32,7 @@ AudioSyncReader::AudioSyncReader(base::SharedMemory* shared_memory,
       maximum_wait_time_(base::TimeDelta::FromMilliseconds(20)),
 #endif
       buffer_index_(0) {
-  int input_memory_size = 0;
-  int output_memory_size = AudioBus::CalculateMemorySize(params);
-  if (input_channels_ > 0) {
-    // The input storage is after the output storage.
-    int frames = params.frames_per_buffer();
-    input_memory_size = AudioBus::CalculateMemorySize(input_channels_, frames);
-    char* input_data =
-        static_cast<char*>(shared_memory_->memory()) + output_memory_size;
-    input_bus_ = AudioBus::WrapMemory(input_channels_, frames, input_data);
-    input_bus_->Zero();
-  }
-  DCHECK_EQ(packet_size_, output_memory_size + input_memory_size);
+  DCHECK_EQ(packet_size_, AudioBus::CalculateMemorySize(params));
   output_bus_ = AudioBus::WrapMemory(params, shared_memory->memory());
   output_bus_->Zero();
 }
@@ -79,15 +66,6 @@ void AudioSyncReader::Read(const AudioBus* source, AudioBus* dest) {
     return;
   }
 
-  // Copy optional synchronized live audio input for consumption by renderer
-  // process.
-  if (input_bus_) {
-    if (source)
-      source->CopyTo(input_bus_.get());
-    else
-      input_bus_->Zero();
-  }
-
   if (mute_audio_)
     dest->Zero();
   else

content/browser/renderer_host/media/audio_sync_reader.h

@@ -26,8 +26,7 @@ namespace content {
 class AudioSyncReader : public media::AudioOutputController::SyncReader {
  public:
   AudioSyncReader(base::SharedMemory* shared_memory,
-                  const media::AudioParameters& params,
-                  int input_channels);
+                  const media::AudioParameters& params);
 
   virtual ~AudioSyncReader();
 
@@ -52,9 +51,6 @@ class AudioSyncReader : public media::AudioOutputController::SyncReader {
 
   const base::SharedMemory* const shared_memory_;
 
-  // Number of input channels for synchronized I/O.
-  const int input_channels_;
-
   // Mutes all incoming samples. This is used to prevent audible sound
   // during automated testing.
   const bool mute_audio_;
@@ -69,9 +65,6 @@ class AudioSyncReader : public media::AudioOutputController::SyncReader {
   // Shared memory wrapper used for transferring audio data to Read() callers.
   scoped_ptr<media::AudioBus> output_bus_;
 
-  // Shared memory wrapper used for transferring audio data from Read() callers.
-  scoped_ptr<media::AudioBus> input_bus_;
-
   // Maximum amount of audio data which can be transferred in one Read() call.
   const int packet_size_;
 

media/audio/alsa/alsa_output_unittest.cc

@@ -75,10 +75,9 @@ class MockAudioManagerAlsa : public AudioManagerAlsa {
   MOCK_METHOD0(HasAudioInputDevices, bool());
   MOCK_METHOD1(MakeLinearOutputStream, AudioOutputStream*(
       const AudioParameters& params));
-  MOCK_METHOD3(MakeLowLatencyOutputStream, AudioOutputStream*(
+  MOCK_METHOD2(MakeLowLatencyOutputStream, AudioOutputStream*(
       const AudioParameters& params,
-      const std::string& device_id,
-      const std::string& input_device_id));
+      const std::string& device_id));
   MOCK_METHOD2(MakeLowLatencyInputStream, AudioInputStream*(
       const AudioParameters& params, const std::string& device_id));
 

media/audio/alsa/audio_manager_alsa.cc

@@ -283,11 +283,9 @@ AudioOutputStream* AudioManagerAlsa::MakeLinearOutputStream(
 
 AudioOutputStream* AudioManagerAlsa::MakeLowLatencyOutputStream(
     const AudioParameters& params,
-    const std::string& device_id,
-    const std::string& input_device_id) {
+    const std::string& device_id) {
   DLOG_IF(ERROR, !device_id.empty()) << "Not implemented!";
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
-  // TODO(xians): Use input_device_id for unified IO.
   return MakeOutputStream(params);
 }
 

media/audio/alsa/audio_manager_alsa.h

@@ -37,8 +37,7 @@ class MEDIA_EXPORT AudioManagerAlsa : public AudioManagerBase {
       const AudioParameters& params) OVERRIDE;
   virtual AudioOutputStream* MakeLowLatencyOutputStream(
       const AudioParameters& params,
-      const std::string& device_id,
-      const std::string& input_device_id) OVERRIDE;
+      const std::string& device_id) OVERRIDE;
   virtual AudioInputStream* MakeLinearInputStream(
       const AudioParameters& params, const std::string& device_id) OVERRIDE;
   virtual AudioInputStream* MakeLowLatencyInputStream(

media/audio/android/audio_android_unittest.cc

@@ -438,7 +438,7 @@ class AudioAndroidOutputTest : public testing::Test {
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
     AudioOutputStream* stream = audio_manager()->MakeAudioOutputStream(
-        params, std::string(), std::string());
+        params, std::string());
     EXPECT_TRUE(stream);
 
     int count = 0;
@@ -621,7 +621,7 @@ TEST_P(AudioAndroidInputTest, CreateAndCloseInputStream) {
 TEST_F(AudioAndroidOutputTest, CreateAndCloseOutputStream) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string(), std::string());
+      params, std::string());
   EXPECT_TRUE(aos);
   aos->Close();
 }
@@ -640,7 +640,7 @@ TEST_P(AudioAndroidInputTest, OpenAndCloseInputStream) {
 TEST_F(AudioAndroidOutputTest, OpenAndCloseOutputStream) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string(), std::string());
+      params, std::string());
   EXPECT_TRUE(aos);
   EXPECT_TRUE(aos->Open());
   aos->Close();
@@ -701,7 +701,7 @@ TEST_F(AudioAndroidOutputTest, DISABLED_RunOutputStreamWithFileAsSource) {
   AudioParameters params = GetDefaultOutputStreamParameters();
   VLOG(1) << params;
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      params, std::string(), std::string());
+      params, std::string());
   EXPECT_TRUE(aos);
 
   std::string file_name;
@@ -770,7 +770,7 @@ TEST_P(AudioAndroidInputTest, DISABLED_RunDuplexInputStreamWithFileAsSink) {
   AudioParameters out_params =
       audio_manager()->GetDefaultOutputStreamParameters();
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      out_params, std::string(), std::string());
+      out_params, std::string());
   EXPECT_TRUE(aos);
 
   std::string file_name = base::StringPrintf("out_duplex_%d_%d_%d.pcm",
@@ -829,7 +829,7 @@ TEST_P(AudioAndroidInputTest,
       io_params, AudioManagerBase::kDefaultDeviceId);
   EXPECT_TRUE(ais);
   AudioOutputStream* aos = audio_manager()->MakeAudioOutputStream(
-      io_params, std::string(), std::string());
+      io_params, std::string());
   EXPECT_TRUE(aos);
 
   FullDuplexAudioSinkSource full_duplex(io_params);

media/audio/android/audio_manager_android.cc

@@ -122,12 +122,10 @@ AudioParameters AudioManagerAndroid::GetInputStreamParameters(
 
 AudioOutputStream* AudioManagerAndroid::MakeAudioOutputStream(
     const AudioParameters& params,
-    const std::string& device_id,
-    const std::string& input_device_id) {
+    const std::string& device_id) {
   bool had_no_streams = HadNoAudioStreams();
   AudioOutputStream* stream =
-      AudioManagerBase::MakeAudioOutputStream(params, std::string(),
-          std::string());
+      AudioManagerBase::MakeAudioOutputStream(params, std::string());
 
   // The audio manager for Android creates streams intended for real-time
   // VoIP sessions and therefore sets the audio mode to MODE_IN_COMMUNICATION.
@@ -187,8 +185,7 @@ AudioOutputStream* AudioManagerAndroid::MakeLinearOutputStream(
 
 AudioOutputStream* AudioManagerAndroid::MakeLowLatencyOutputStream(
     const AudioParameters& params,
-    const std::string& device_id,
-    const std::string& input_device_id) {
+    const std::string& device_id) {
   DLOG_IF(ERROR, !device_id.empty()) << "Not implemented!";
   DCHECK_EQ(AudioParameters::AUDIO_PCM_LOW_LATENCY, params.format());
   return new OpenSLESOutputStream(this, params);

media/audio/android/audio_manager_android.h

@@ -33,8 +33,7 @@ class MEDIA_EXPORT AudioManagerAndroid : public AudioManagerBase {
 
   virtual AudioOutputStream* MakeAudioOutputStream(
       const AudioParameters& params,
-      const std::string& device_id,
-      const std::string& input_device_id) OVERRIDE;
+      const std::string& device_id) OVERRIDE;
   virtual AudioInputStream* MakeAudioInputStream(
       const AudioParameters& params,
       const std::string& device_id) OVERRIDE;
@@ -46,8 +45,7 @@ class MEDIA_EXPORT AudioManagerAndroid : public AudioManagerBase {
       const AudioParameters& params) OVERRIDE;
   virtual AudioOutputStream* MakeLowLatencyOutputStream(
       const AudioParameters& params,
-      const std::string& device_id,
-      const std::string& input_device_id) OVERRIDE;
+      const std::string& device_id) OVERRIDE;
   virtual AudioInputStream* MakeLinearInputStream(
       const AudioParameters& params,
       const std::string& device_id) OVERRIDE;