Remove "high"-latency audio code path

content/renderer/media/audio_device.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/renderer/media/audio_device.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "content/common/child_process.h"
 #include "content/common/media/audio_messages.h"
 #include "content/common/view_messages.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/audio/audio_output_controller.h"
 #include "media/audio/audio_util.h"
 
 AudioDevice::AudioDevice()
     : buffer_size_(0),
       channels_(0),
       bits_per_sample_(16),
       sample_rate_(0),
       latency_format_(AudioParameters::AUDIO_PCM_LOW_LATENCY),

[scherkus (not reviewing), 2012/02/01 22:56:12]

does this also need to get updated?

is this always LOW_LATENCY or do people override it in Initialize()?

[vrk (LEFT CHROMIUM), 2012/02/02 21:05:41]

Ooh, I didn't even notice this! Looked into this and turns out this is referring
to a different sort of low latency, see crbug.com/103627.

As the bug describes, AudioRendererImpl is using AUDIO_PCM_LINEAR when it's
initialized, so can't get rid of the option yet.

       callback_(0),
       is_initialized_(false),
       audio_delay_milliseconds_(0),
       volume_(1.0),
       stream_id_(0),
       play_on_start_(true),
       is_started_(false),
       shared_memory_handle_(base::SharedMemory::NULLHandle()),
       memory_length_(0) {
   filter_ = RenderThreadImpl::current()->audio_message_filter();
@@ skipping 116 matching lines @@
 }
 
 void AudioDevice::InitializeOnIOThread(const AudioParameters& params) {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   // Make sure we don't create the stream more than once.
   DCHECK_EQ(0, stream_id_);
   if (stream_id_)
     return;
 
   stream_id_ = filter_->AddDelegate(this);
-  Send(new AudioHostMsg_CreateStream(stream_id_, params, true));
+  Send(new AudioHostMsg_CreateStream(stream_id_, params));
 }
 
 void AudioDevice::PlayOnIOThread() {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   if (stream_id_ && is_started_)
     Send(new AudioHostMsg_PlayStream(stream_id_));
   else
     play_on_start_ = true;
 }
 
@@ skipping 26 matching lines @@
 
   signal->Signal();
 }
 
 void AudioDevice::SetVolumeOnIOThread(double volume) {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   if (stream_id_)
     Send(new AudioHostMsg_SetVolume(stream_id_, volume));
 }
 
-void AudioDevice::OnRequestPacket(AudioBuffersState buffers_state) {
-  // This method does not apply to the low-latency system.
-}
-
 void AudioDevice::OnStateChanged(AudioStreamState state) {
   if (state == kAudioStreamError) {
     DLOG(WARNING) << "AudioDevice::OnStateChanged(kError)";
     callback_->OnError();
   }
 }
 
-void AudioDevice::OnCreated(
-    base::SharedMemoryHandle handle, uint32 length) {
-  // Not needed in this simple implementation.
-}
-
-void AudioDevice::OnLowLatencyCreated(
+void AudioDevice::OnStreamCreated(
     base::SharedMemoryHandle handle,
     base::SyncSocket::Handle socket_handle,
     uint32 length) {
   DCHECK_EQ(MessageLoop::current(), ChildProcess::current()->io_message_loop());
   DCHECK_GE(length, buffer_size_ * sizeof(int16) * channels_);
 #if defined(OS_WIN)
   DCHECK(handle);
   DCHECK(socket_handle);
 #else
   DCHECK_GE(handle.fd, 0);
   DCHECK_GE(socket_handle, 0);
 #endif
 
-  // Takes care of the case when Stop() is called before OnLowLatencyCreated().
+  // Takes care of the case when Stop() is called before OnStreamCreated().
   if (!stream_id_) {
     base::SharedMemory::CloseHandle(handle);
     // Close the socket handler.
     base::SyncSocket socket(socket_handle);
     return;
   }
 
   shared_memory_handle_ = handle;
   memory_length_ = length;
   audio_socket_.reset(new base::CancelableSyncSocket(socket_handle));
 
   audio_thread_.reset(
       new base::DelegateSimpleThread(this, "renderer_audio_thread"));
   audio_thread_->Start();
 
   // We handle the case where Play() and/or Pause() may have been called
-  // multiple times before OnLowLatencyCreated() gets called.
+  // multiple times before OnStreamCreated() gets called.
   is_started_ = true;
   if (play_on_start_)
     PlayOnIOThread();
 }
 
-void AudioDevice::OnVolume(double volume) {
-  NOTIMPLEMENTED();
-}
-
 void AudioDevice::Send(IPC::Message* message) {
   filter_->Send(message);
 }
 
 // Our audio thread runs here.
 void AudioDevice::Run() {
   audio_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 
   base::SharedMemory shared_memory(shared_memory_handle_, false);
   shared_memory.Map(media::TotalSharedMemorySizeInBytes(memory_length_));
@@ skipping 59 matching lines @@
     // Close the socket to terminate the main thread function in the
     // audio thread.
     audio_socket_->Shutdown();  // Stops blocking Receive calls.
     // TODO(tommi): We must not do this from the IO thread.  Fix.
     base::ThreadRestrictions::ScopedAllowIO allow_wait;
     audio_thread_->Join();
     audio_thread_.reset(NULL);
     audio_socket_.reset();
   }
 }