Remove "high"-latency audio code path

media/audio/audio_output_controller.cc

Index: media/audio/audio_output_controller.cc
diff --git a/media/audio/audio_output_controller.cc b/media/audio/audio_output_controller.cc
index d087a70208a03623dbcd2a8783f51b461c1356c2..a205e18b3d8a203fb6533850acd025b32cacc2c2 100644
--- a/media/audio/audio_output_controller.cc
+++ b/media/audio/audio_output_controller.cc
@@ -25,15 +25,12 @@ const int AudioOutputController::kPollPauseInMilliseconds = 3;
 
 AudioOutputController::AudioOutputController(AudioManager* audio_manager,
                                              EventHandler* handler,
-                                             uint32 capacity,
                                              SyncReader* sync_reader)
     : audio_manager_(audio_manager),
       handler_(handler),
       stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
-      buffer_(0, capacity),
-      pending_request_(false),
       sync_reader_(sync_reader),
       message_loop_(NULL),
       number_polling_attempts_left_(0),
@@ -62,27 +59,6 @@ scoped_refptr<AudioOutputController> AudioOutputController::Create(
     AudioManager* audio_manager,
     EventHandler* event_handler,
     const AudioParameters& params,
-    uint32 buffer_capacity) {
-  DCHECK(audio_manager);
-  if (!params.IsValid() ||  !audio_manager)
-    return NULL;
-
-  // Starts the audio controller thread.
-  scoped_refptr<AudioOutputController> controller(new AudioOutputController(
-      audio_manager, event_handler, buffer_capacity, NULL));
-
-  controller->message_loop_ = audio_manager->GetMessageLoop();
-  controller->message_loop_->PostTask(FROM_HERE, base::Bind(
-      &AudioOutputController::DoCreate, base::Unretained(controller.get()),
-      params));
-  return controller;
-}
-
-// static
-scoped_refptr<AudioOutputController> AudioOutputController::CreateLowLatency(
-    AudioManager* audio_manager,
-    EventHandler* event_handler,
-    const AudioParameters& params,
     SyncReader* sync_reader) {
   DCHECK(audio_manager);
   DCHECK(sync_reader);
@@ -92,7 +68,7 @@ scoped_refptr<AudioOutputController> AudioOutputController::CreateLowLatency(
 
   // Starts the audio controller thread.
   scoped_refptr<AudioOutputController> controller(new AudioOutputController(
-      audio_manager, event_handler, 0, sync_reader));
+      audio_manager, event_handler, sync_reader));
 
   controller->message_loop_ = audio_manager->GetMessageLoop();
   controller->message_loop_->PostTask(FROM_HERE, base::Bind(
@@ -132,19 +108,6 @@ void AudioOutputController::SetVolume(double volume) {
       &AudioOutputController::DoSetVolume, base::Unretained(this), volume));
 }
 
-void AudioOutputController::EnqueueData(const uint8* data, uint32 size) {
-  // Write data to the push source and ask for more data if needed.
-  base::AutoLock auto_lock(lock_);
-  pending_request_ = false;
-  // If |size| is set to 0, it indicates that the audio source doesn't have
-  // more data right now, and so it doesn't make sense to send additional
-  // request.
-  if (size) {
-    buffer_.Append(data, size);
-    SubmitOnMoreData_Locked();
-  }
-}
-
 void AudioOutputController::DoCreate(const AudioParameters& params) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
@@ -177,12 +140,6 @@ void AudioOutputController::DoCreate(const AudioParameters& params) {
 
   // And then report we have been created.
   handler_->OnCreated(this);
-
-  // If in normal latency mode then start buffering.
-  if (!LowLatencyMode()) {
-    base::AutoLock auto_lock(lock_);
-    SubmitOnMoreData_Locked();
-  }
 }
 
 void AudioOutputController::DoPlay() {
@@ -192,23 +149,21 @@ void AudioOutputController::DoPlay() {
   if (state_ != kCreated && state_ != kPaused)
     return;
 
-  if (LowLatencyMode()) {
-    state_ = kStarting;
-
-    // Ask for first packet.
-    sync_reader_->UpdatePendingBytes(0);
-
-    // Cannot start stream immediately, should give renderer some time
-    // to deliver data.
-    number_polling_attempts_left_ = kPollNumAttempts;
-    message_loop_->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&AudioOutputController::PollAndStartIfDataReady,
-        weak_this_.GetWeakPtr()),
-        kPollPauseInMilliseconds);
-  } else {
-    StartStream();
-  }
+  state_ = kStarting;
+
+  // Ask for first packet.
+  sync_reader_->UpdatePendingBytes(0);
+
+  // Cannot start stream immediately, should give renderer some time
+  // to deliver data.
+  // TODO(vrk): The polling here and in WaitTillDataReady() is pretty clunky.

[henrika (OOO until Aug 14), 2012/02/01 13:11:29]

Thanks. This part is magic to me as well.

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

:)

+  // Refine the API such that polling is no longer needed. (crbug.com/112196)
+  number_polling_attempts_left_ = kPollNumAttempts;
+  message_loop_->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&AudioOutputController::PollAndStartIfDataReady,
+      weak_this_.GetWeakPtr()),
+      kPollPauseInMilliseconds);
 }
 
 void AudioOutputController::PollAndStartIfDataReady() {
@@ -270,10 +225,8 @@ void AudioOutputController::DoPause() {
       // TODO(hclam): Actually pause the audio device.
       stream_->Stop();
 
-      if (LowLatencyMode()) {
-        // Send a special pause mark to the low-latency audio thread.
-        sync_reader_->UpdatePendingBytes(kPauseMark);
-      }
+      // Send a special pause mark to the low-latency audio thread.
+      sync_reader_->UpdatePendingBytes(kPauseMark);
 
       handler_->OnPaused(this);
       break;
@@ -286,14 +239,6 @@ void AudioOutputController::DoFlush() {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   // TODO(hclam): Actually flush the audio device.
-
-  // If we are in the regular latency mode then flush the push source.
-  if (!sync_reader_) {
-    if (state_ != kPaused)
-      return;
-    base::AutoLock auto_lock(lock_);
-    buffer_.Clear();
-  }
 }
 
 void AudioOutputController::DoClose(const base::Closure& closed_task) {
@@ -301,11 +246,7 @@ void AudioOutputController::DoClose(const base::Closure& closed_task) {
 
   if (state_ != kClosed) {
     DoStopCloseAndClearStream(NULL);
-
-    if (LowLatencyMode()) {
-      sync_reader_->Close();
-    }
-
+    sync_reader_->Close();
     state_ = kClosed;
   }
 
@@ -343,25 +284,6 @@ uint32 AudioOutputController::OnMoreData(
     uint32 max_size, AudioBuffersState buffers_state) {
   TRACE_EVENT0("audio", "AudioOutputController::OnMoreData");
 
-  // If regular latency mode is used.
-  if (!sync_reader_) {
-    base::AutoLock auto_lock(lock_);
-
-    // Save current buffers state.
-    buffers_state_ = buffers_state;
-
-    if (state_ != kPlaying) {
-      // Don't read anything. Save the number of bytes in the hardware buffer.
-      return 0;
-    }
-
-    uint32 size = buffer_.Read(dest, max_size);
-    buffers_state_.pending_bytes += size;
-    SubmitOnMoreData_Locked();
-    return size;
-  }
-
-  // Low latency mode.
   {
     // Check state and do nothing if we are not playing.
     // We are on the hardware audio thread, so lock is needed.
@@ -370,13 +292,13 @@ uint32 AudioOutputController::OnMoreData(
       return 0;
     }
   }
-  uint32 size =  sync_reader_->Read(dest, max_size);
+  uint32 size = sync_reader_->Read(dest, max_size);
   sync_reader_->UpdatePendingBytes(buffers_state.total_bytes() + size);
   return size;
 }
 
 void AudioOutputController::WaitTillDataReady() {
-  if (LowLatencyMode() && !sync_reader_->DataReady()) {
+  if (!sync_reader_->DataReady()) {
     // In the different place we use different mechanism to poll, get max
     // polling delay from constants used there.
     const base::TimeDelta kMaxPollingDelay = base::TimeDelta::FromMilliseconds(
@@ -395,26 +317,6 @@ void AudioOutputController::OnError(AudioOutputStream* stream, int code) {
       &AudioOutputController::DoReportError, base::Unretained(this), code));
 }
 
-void AudioOutputController::SubmitOnMoreData_Locked() {
-  lock_.AssertAcquired();
-
-  if (buffer_.forward_bytes() > buffer_.forward_capacity())
-    return;
-
-  if (pending_request_)
-    return;
-  pending_request_ = true;
-
-  AudioBuffersState buffers_state = buffers_state_;
-  buffers_state.pending_bytes += buffer_.forward_bytes();
-
-  // If we need more data then call the event handler to ask for more data.
-  // It is okay that we don't lock in this block because the parameters are
-  // correct and in the worst case we are just asking more data than needed.
-  base::AutoUnlock auto_unlock(lock_);
-  handler_->OnMoreData(this, buffers_state);
-}
-
 void AudioOutputController::DoStopCloseAndClearStream(WaitableEvent *done) {
   DCHECK(message_loop_->BelongsToCurrentThread());