Modify the PPB_Audio_Shared code for NaCl.

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 "ppapi/shared_impl/ppapi_globals.h"
 
 using base::subtle::Atomic32;
 
 namespace ppapi {
 
+#if defined(OS_NACL)
+namespace {
+PP_ThreadFunctions thread_functions;

[dmichael (off chromium), 2012/07/24 20:55:21]

Later on, you're relying on it getting zero initialized because it has static
storage duration...  see C++98 3.6.2.1:
http://www-d0.fnal.gov/~dladams/cxx_standard.pdf
Is this worth a comment, or maybe using = {NULL, NULL} to make it clearer?

[bbudge, 2012/07/24 21:15:44]

I'll add a comment. Done.

+}
+#endif  // defined(OS_NACL)
+
 // FIXME: The following two functions (TotalSharedMemorySizeInBytes,
 // SetActualDataSizeInBytes) are copied from audio_util.cc.
 // Remove these functions once a minimal media library is provided for them.
 // code.google.com/p/chromium/issues/detail?id=123203
 
 uint32 TotalSharedMemorySizeInBytes(uint32 packet_size) {
   // Need to reserve extra 4 bytes for size of data.
   return packet_size + sizeof(Atomic32);
 }
 
 void SetActualDataSizeInBytes(base::SharedMemory* shared_memory,
                               uint32 shared_memory_size,
                               uint32 actual_data_size) {
   char* ptr = static_cast<char*>(shared_memory->memory()) + shared_memory_size;
   DCHECK_EQ(0u, reinterpret_cast<size_t>(ptr) & 3);
 
   // Set actual data size at the end of the buffer.
   base::subtle::Release_Store(reinterpret_cast<volatile Atomic32*>(ptr),
                               actual_data_size);
 }
 
 const int PPB_Audio_Shared::kPauseMark = -1;
 
 PPB_Audio_Shared::PPB_Audio_Shared()
     : playing_(false),
       shared_memory_size_(0),
+#if defined(OS_NACL)
+      thread_id_(),
+      thread_active_(false),
+#endif
       callback_(NULL),
       user_data_(NULL) {
 }
 
 PPB_Audio_Shared::~PPB_Audio_Shared() {
   StopThread();
 }
 
 void PPB_Audio_Shared::SetCallback(PPB_Audio_Callback callback,
                                    void* user_data) {
   callback_ = callback;
   user_data_ = user_data;
 }
 
 void PPB_Audio_Shared::SetStartPlaybackState() {
   DCHECK(!playing_);
+#if !defined(OS_NACL)
   DCHECK(!audio_thread_.get());
-
+#else
+  DCHECK(!thread_active_);
+#endif
   // If the socket doesn't exist, that means that the plugin has started before
   // the browser has had a chance to create all the shared memory info and
   // notify us. This is a common case. In this case, we just set the playing_
   // flag and the playback will automatically start when that data is available
   // in SetStreamInfo.
   playing_ = true;
   StartThread();
 }
 
 void PPB_Audio_Shared::SetStopPlaybackState() {
@@ skipping 16 matching lines @@
       "Failed to map shared memory for PPB_Audio_Shared.");
   }
 
   StartThread();
 }
 
 void PPB_Audio_Shared::StartThread() {
   // Don't start the thread unless all our state is set up correctly.
   if (!playing_ || !callback_ || !socket_.get() || !shared_memory_->memory())
     return;
+#if !defined(OS_NACL)
   DCHECK(!audio_thread_.get());
   audio_thread_.reset(new base::DelegateSimpleThread(
       this, "plugin_audio_thread"));
   audio_thread_->Start();
+#else
+  // Clear contents of shm buffer before starting audio thread.
+  memset(shared_memory_->memory(), 0, shared_memory_size_);

[dmichael (off chromium), 2012/07/24 20:55:21]

I'd rather the comment said why we're doing this. Do we need to do this at all?
If you're trying to avoid leaking data, the clearing should really happen in
trusted code.

[bbudge, 2012/07/24 21:15:44]

I copied this from the SRPC proxy code. I agree, it's not sufficient to do this
here. Removed.

+  // Use NaCl's special API for IRT code that creates threads that call back
+  // into user code.
+  if (NULL == thread_functions.thread_create ||
+      NULL == thread_functions.thread_join)
+    return;
+
+  int result = thread_functions.thread_create(&thread_id_, CallRun, this);
+  DCHECK(result == 0);
+  thread_active_ = true;
+#endif
 }
 
 void PPB_Audio_Shared::StopThread() {
   // Shut down the socket to escape any hanging |Receive|s.
   if (socket_.get())
     socket_->Shutdown();
+  #if !defined(OS_NACL)
   if (audio_thread_.get()) {
     audio_thread_->Join();
     audio_thread_.reset();
   }
+#else
+  if (thread_active_) {
+    int result = thread_functions.thread_join(thread_id_);
+    DCHECK(0 == result);
+    thread_active_ = false;
+  }
+#endif
 }
 
+#if defined(OS_NACL)
+// static
+void PPB_Audio_Shared::SetThreadFunctions(
+    const struct PP_ThreadFunctions* functions) {
+  DCHECK(thread_functions.thread_create == NULL);
+  DCHECK(thread_functions.thread_join == NULL);
+  thread_functions = *functions;
+}
+
+// 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;
   void* buffer = shared_memory_->memory();
 
   while (sizeof(pending_data) ==
       socket_->Receive(&pending_data, sizeof(pending_data)) &&
       pending_data != kPauseMark) {
     callback_(buffer, shared_memory_size_, user_data_);
 
     // Let the host know we are done.
     SetActualDataSizeInBytes(shared_memory_.get(), shared_memory_size_,
         shared_memory_size_);
   }
 }
 
 }  // namespace ppapi