Switch audio synchronization from sleep() based to select() based.

media/audio/audio_device_thread.cc

Index: media/audio/audio_device_thread.cc
diff --git a/media/audio/audio_device_thread.cc b/media/audio/audio_device_thread.cc
index d5c1bbcebdc652b8d0cf1fd7ac222a1458af2ba7..edd7c9ffe69a8bb2a00e803b212be6cb9a94e757 100644
--- a/media/audio/audio_device_thread.cc
+++ b/media/audio/audio_device_thread.cc
@@ -29,7 +29,8 @@ class AudioDeviceThread::Thread
  public:
   Thread(AudioDeviceThread::Callback* callback,
          base::SyncSocket::Handle socket,
-         const char* thread_name);
+         const char* thread_name,
+         bool synchronized_buffers);
 
   void Start();
 
@@ -55,6 +56,7 @@ class AudioDeviceThread::Thread
   base::CancelableSyncSocket socket_;
   base::Lock callback_lock_;
   const char* thread_name_;
+  const bool synchronized_buffers_;
 
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
@@ -68,10 +70,12 @@ AudioDeviceThread::~AudioDeviceThread() { DCHECK(!thread_.get()); }
 
 void AudioDeviceThread::Start(AudioDeviceThread::Callback* callback,
                               base::SyncSocket::Handle socket,
-                              const char* thread_name) {
+                              const char* thread_name,
+                              bool synchronized_buffers) {
   base::AutoLock auto_lock(thread_lock_);
-  CHECK(thread_.get() == NULL);
-  thread_ = new AudioDeviceThread::Thread(callback, socket, thread_name);
+  CHECK(!thread_);
+  thread_ = new AudioDeviceThread::Thread(
+      callback, socket, thread_name, synchronized_buffers);
   thread_->Start();
 }
 
@@ -85,17 +89,19 @@ void AudioDeviceThread::Stop(base::MessageLoop* loop_for_join) {
 
 bool AudioDeviceThread::IsStopped() {
   base::AutoLock auto_lock(thread_lock_);
-  return thread_.get() == NULL;
+  return !thread_;
 }
 
 // AudioDeviceThread::Thread implementation
 AudioDeviceThread::Thread::Thread(AudioDeviceThread::Callback* callback,
                                   base::SyncSocket::Handle socket,
-                                  const char* thread_name)
+                                  const char* thread_name,
+                                  bool synchronized_buffers)
     : thread_(),
       callback_(callback),
       socket_(socket),
-      thread_name_(thread_name) {
+      thread_name_(thread_name),
+      synchronized_buffers_(synchronized_buffers) {
 }
 
 AudioDeviceThread::Thread::~Thread() {
@@ -157,6 +163,7 @@ void AudioDeviceThread::Thread::ThreadMain() {
 }
 
 void AudioDeviceThread::Thread::Run() {
+  uint32 buffer_index = 0;
   while (true) {
     int pending_data = 0;
     size_t bytes_read = socket_.Receive(&pending_data, sizeof(pending_data));
@@ -165,9 +172,19 @@ void AudioDeviceThread::Thread::Run() {
       break;
     }
 
-    base::AutoLock auto_lock(callback_lock_);
-    if (callback_)
-      callback_->Process(pending_data);
+    {
+      base::AutoLock auto_lock(callback_lock_);
+      if (callback_)
+        callback_->Process(pending_data);
+    }
+
+    // Let the other end know which buffer we just filled.

[henrika (OOO until Aug 14), 2013/09/13 10:25:44]

Can you add a line about how the renderer and browser "communicates" using this
buffer index.

[DaleCurtis, 2013/10/22 23:13:49]

Done.

+    if (synchronized_buffers_) {
+      ++buffer_index;
+      size_t bytes_sent = socket_.Send(&buffer_index, sizeof(buffer_index));
+      if (bytes_sent != sizeof(buffer_index))
+        break;
+    }
   }
 }