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

ppapi/shared_impl/ppb_audio_shared.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 "ppapi/shared_impl/ppb_audio_shared.h"
 
 #include "base/logging.h"
-#include "media/audio/shared_memory_util.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/ppb_audio_config_shared.h"
 #include "ppapi/shared_impl/proxy_lock.h"
 
 namespace ppapi {
 
 #if defined(OS_NACL)
 namespace {
 // Because this is static, the function pointers will be NULL initially.
 PP_ThreadFunctions thread_functions;
@@ skipping 88 matching lines @@
     size_t shared_memory_size,
     base::SyncSocket::Handle socket_handle,
     PP_AudioSampleRate sample_rate,
     int sample_frame_count) {
   socket_.reset(new base::CancelableSyncSocket(socket_handle));
   shared_memory_.reset(new base::SharedMemory(shared_memory_handle, false));
   shared_memory_size_ = shared_memory_size;
   bytes_per_second_ = kAudioOutputChannels * (kBitsPerAudioOutputSample / 8) *
                       sample_rate;
 
-  if (!shared_memory_->Map(
-          media::TotalSharedMemorySizeInBytes(shared_memory_size_))) {
+  if (!shared_memory_->Map(shared_memory_size_)) {
     PpapiGlobals::Get()->LogWithSource(
         instance,
         PP_LOGLEVEL_WARNING,
         std::string(),
         "Failed to map shared memory for PPB_Audio_Shared.");
   } else {
     audio_bus_ = media::AudioBus::WrapMemory(
         kAudioOutputChannels, sample_frame_count, shared_memory_->memory());
     // Setup integer audio buffer for user audio data.
     client_buffer_size_bytes_ =
@@ skipping 67 matching lines @@
 }
 
 // static
 void PPB_Audio_Shared::CallRun(void* self) {
   PPB_Audio_Shared* audio = static_cast<PPB_Audio_Shared*>(self);
   audio->Run();
 }
 #endif
 
 void PPB_Audio_Shared::Run() {
-  int pending_data;
-  const int bytes_per_frame =
-      sizeof(*audio_bus_->channel(0)) * audio_bus_->channels();
-
+  int pending_data = 0;
+  uint32_t buffer_index = 0;
   while (sizeof(pending_data) ==
       socket_->Receive(&pending_data, sizeof(pending_data)) &&
-      pending_data != media::kPauseMark) {
+      pending_data >= 0) {
     PP_TimeDelta latency =
         static_cast<double>(pending_data) / bytes_per_second_;
     callback_.Run(client_buffer_.get(), client_buffer_size_bytes_, latency,
                   user_data_);
 
     // Deinterleave the audio data into the shared memory as float.
     audio_bus_->FromInterleaved(
         client_buffer_.get(), audio_bus_->frames(),
         kBitsPerAudioOutputSample / 8);
 
-    // Let the host know we are done.
-    // TODO(dalecurtis): Technically this is not the exact size.  Due to channel
-    // padding for alignment, there may be more data available than this.  We're
-    // relying on AudioSyncReader::Read() to parse this with that in mind.
-    // Rename these methods to Set/GetActualFrameCount().
-    media::SetActualDataSizeInBytes(
-        shared_memory_.get(), shared_memory_size_,
-        audio_bus_->frames() * bytes_per_frame);
+    ++buffer_index;
+    size_t bytes_sent = socket_->Send(&buffer_index, sizeof(buffer_index));
+    if (bytes_sent != sizeof(buffer_index))
+      break;
   }
 }
 
 }  // namespace ppapi