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

media/audio/audio_output_controller.h

 // 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.
 
 #ifndef MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_
 #define MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_
 
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 85 matching lines @@
     // AudioOutputController not yet played. This is used by SyncReader to
     // prepare more data and perform synchronization.
     virtual void UpdatePendingBytes(uint32 bytes) = 0;
 
     // Read certain amount of data into |data|. This method returns if some
     // data is available.
     virtual uint32 Read(void* data, uint32 size) = 0;
 
     // Close this synchronous reader.
     virtual void Close() = 0;
+
+    // Poll if data is ready.
+    // Not reliable, as there is no guarantee that renderer is "new-style"
+    // renderer that writes metadata into buffer. After several unsuccessful
+    // attempts caller should assume the data is ready even if that function
+    // returns false.

[acolwell GONE FROM CHROMIUM, 2011/10/12 20:14:03]

Why don't all renderers write into the buffer? Shouldn't we fix things to this
can be reliable?

[enal1, 2011/10/13 00:39:22]

That is long and sad story. 3 months ago I tried to edit all code that writes
audio streams, and had to give up, because it is extremely hard to change glue
code that is in the plugin. We have pepper, native client, etc., and interfaces
for them are cut in the stone... After lot of attempts and code reverts I scaled
down my changes. As a result we cannot be sure that other side in the in the IPC
writes metadata...

[acolwell GONE FROM CHROMIUM, 2011/10/13 00:52:47]

Ok. Sorry to hear this.
On 2011/10/13 00:39:22, enal1 wrote:

+    virtual bool DataReady() = 0;
   };
 
   virtual ~AudioOutputController();
 
   // Factory method for creating an AudioOutputController.
   // If successful, an audio controller thread is created. The audio device
   // will be created on the audio controller thread and when that is done
   // event handler will receive a OnCreated() call.
   static scoped_refptr<AudioOutputController> Create(
       EventHandler* event_handler,
@@ skipping 40 matching lines @@
 
   bool LowLatencyMode() const { return sync_reader_ != NULL; }
 
   ///////////////////////////////////////////////////////////////////////////
   // AudioSourceCallback methods.
   virtual uint32 OnMoreData(AudioOutputStream* stream, uint8* dest,
                             uint32 max_size, AudioBuffersState buffers_state);
   virtual void OnError(AudioOutputStream* stream, int code);
 
  private:
+  // We are polling sync reader if data became available.
+  static const int kPollNumAttempts;
+  static const int kPollPauseInMilliseconds;

[acolwell GONE FROM CHROMIUM, 2011/10/12 20:14:03]

Why not just make these file static in the .cc?

[enal1, 2011/10/13 00:39:22]

Because previous time I tried that I was told to make constants part of class
interface :-(

Actually, here it even makes sense -- when looking at the header file you can
deduce there are knobs you can tune, and values themselves are hidden.

[acolwell GONE FROM CHROMIUM, 2011/10/13 00:52:47]

OK.

+
   AudioOutputController(EventHandler* handler,
                         uint32 capacity, SyncReader* sync_reader);
 
   // The following methods are executed on the audio controller thread.
   void DoCreate(const AudioParameters& params);
   void DoPlay();
+  void DoPollIfDataReady();
   void DoPause();
   void DoFlush();
   void DoClose(const base::Closure& closed_task);
   void DoSetVolume(double volume);
   void DoReportError(int code);
 
   // Helper method to submit a OnMoreData() call to the event handler.
   void SubmitOnMoreData_Locked();
 
+  // Helper method that starts physical stream.
+  void StartStream();
+
   // |handler_| may be called only if |state_| is not kClosed.
   EventHandler* handler_;
   AudioOutputStream* stream_;
 
   // The current volume of the audio stream.
   double volume_;
 
   // |state_| is written on the audio controller thread and is read on the
   // hardware audio thread. These operations need to be locked. But lock
   // is not required for reading on the audio controller thread.
   State state_;
 
   AudioBuffersState buffers_state_;
 
   // The |lock_| must be acquired whenever we access |buffer_|.
   base::Lock lock_;
 
   media::SeekableBuffer buffer_;
 
   bool pending_request_;
 
   // SyncReader is used only in low latency mode for synchronous reading.
   SyncReader* sync_reader_;
 
   // The message loop of audio thread that this object runs on.
   MessageLoop* message_loop_;
 
+  // When starting stream we wait for data to become available.
+  // Number of times left.
+  int number_polling_attempts_left_;
+
   DISALLOW_COPY_AND_ASSIGN(AudioOutputController);
 };
 
 }  // namespace media
 
 #endif  //  MEDIA_AUDIO_AUDIO_OUTPUT_CONTROLLER_H_