Fix problem when we did not play beginning of HTML5 audio stream in low latency mode.

media/audio/audio_output_controller.cc

 // Copyright (c) 2011 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_output_controller.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 
 namespace media {
 
 // Signal a pause in low-latency mode.
 const int AudioOutputController::kPauseMark = -1;
 
+// Polling-related constants.
+const int AudioOutputController::kPollNumAttempts = 3;
+const int AudioOutputController::kPollPauseInMilliseconds = 3;
+
 AudioOutputController::AudioOutputController(EventHandler* handler,
                                              uint32 capacity,
                                              SyncReader* sync_reader)
     : handler_(handler),
       stream_(NULL),
       volume_(1.0),
       state_(kEmpty),
       buffer_(0, capacity),
       pending_request_(false),
       sync_reader_(sync_reader),
-      message_loop_(NULL) {
+      message_loop_(NULL),
+      number_polling_attempts_left_(0) {
 }
 
 AudioOutputController::~AudioOutputController() {
   DCHECK_EQ(kClosed, state_);
 }
 
 // static
 scoped_refptr<AudioOutputController> AudioOutputController::Create(
     EventHandler* event_handler,
     const AudioParameters& params,
@@ skipping 129 matching lines @@
 }
 
 void AudioOutputController::DoPlay() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   // We can start from created or paused state.
   if (state_ != kCreated && state_ != kPaused)
     return;
   state_ = kPlaying;
 
+  if (LowLatencyMode()) {
+    // 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, this),
+        kPollPauseInMilliseconds);
+  } else {
+    StartStream();
+  }
+}
+
+void AudioOutputController::PollAndStartIfDataReady() {
+  DCHECK_EQ(message_loop_, MessageLoop::current());
+
+  // Being paranoic: do nothing if we were stopped/paused
+  // after DoPlay() but before DoStartStream().
+  if (state_ != kPlaying)
+    return;
+
+  if (--number_polling_attempts_left_ == 0 || sync_reader_->DataReady()) {
+    StartStream();
+  } else {
+    message_loop_->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&AudioOutputController::PollAndStartIfDataReady, this),
+        kPollPauseInMilliseconds);
+  }
+}
+
+void AudioOutputController::StartStream() {
+  DCHECK_EQ(message_loop_, MessageLoop::current());
+
   // We start the AudioOutputStream lazily.
   stream_->Start(this);
 
   // Tell the event handler that we are now playing.
   handler_->OnPlaying(this);
 }
 
 void AudioOutputController::DoPause() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
@@ skipping 120 matching lines @@
   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);
 }
 
 }  // namespace media