Add test to make sure if PPB_Audio_Shared::StartThread() works.

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"
 #include "ppapi/shared_impl/ppb_audio_config_shared.h"
 #include "ppapi/shared_impl/proxy_lock.h"
@@ skipping 55 matching lines @@
     socket_->Shutdown();
   StopThread();
 }
 
 void PPB_Audio_Shared::SetCallback(const AudioCallbackCombined& callback,
                                    void* user_data) {
   callback_ = callback;
   user_data_ = user_data;
 }
 
-void PPB_Audio_Shared::SetStartPlaybackState() {
+bool 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();
+  if (!StartThread())
+    playing_ = false;

[bbudge, 2014/04/17 21:44:27]

This makes the comment above false. It seems like setting playing_ false here
will cause audio to not start in this case.

[hidehiko, 2014/04/17 23:03:37]

The comment above is true. StartThread() returns false only if thread creator
is not yet set. Added comment.

[bbudge, 2014/04/18 13:27:25]

Ah, I see now.

+  return playing_;
 }
 
 void PPB_Audio_Shared::SetStopPlaybackState() {
   DCHECK(playing_);
   StopThread();
   playing_ = false;
 }
 
 void PPB_Audio_Shared::SetStreamInfo(
     PP_Instance instance,
@@ skipping 20 matching lines @@
         kAudioOutputChannels, sample_frame_count, shared_memory_->memory());
     // Setup integer audio buffer for user audio data.
     client_buffer_size_bytes_ = audio_bus_->frames() * audio_bus_->channels() *
                                 kBitsPerAudioOutputSample / 8;
     client_buffer_.reset(new uint8_t[client_buffer_size_bytes_]);
   }
 
   StartThread();
 }
 
-void PPB_Audio_Shared::StartThread() {
+bool PPB_Audio_Shared::StartThread() {
+#if defined(OS_NACL)
+  // 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 false;
+#endif
+
   // Don't start the thread unless all our state is set up correctly.
   if (!playing_ || !callback_.IsValid() || !socket_.get() ||
       !shared_memory_->memory() || !audio_bus_.get() || !client_buffer_.get() ||
       bytes_per_second_ == 0)
-    return;
+    return true;
+
   // Clear contents of shm buffer before starting audio thread. This will
   // prevent a burst of static if for some reason the audio thread doesn't
   // start up quickly enough.
   memset(shared_memory_->memory(), 0, shared_memory_size_);
   memset(client_buffer_.get(), 0, client_buffer_size_bytes_);
 #if !defined(OS_NACL)
   DCHECK(!audio_thread_.get());
   audio_thread_.reset(
       new base::DelegateSimpleThread(this, "plugin_audio_thread"));
   audio_thread_->Start();
 #else
-  // 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;
-
+  DCHECK(!thread_active_);
   int result = thread_functions.thread_create(&thread_id_, CallRun, this);
   DCHECK_EQ(result, 0);
   thread_active_ = true;
 #endif
+  return true;
 }
 
 void PPB_Audio_Shared::StopThread() {
 #if !defined(OS_NACL)
   if (audio_thread_.get()) {
     // In general, the audio thread should not do Pepper calls, but it might
     // anyway (for example, our Audio test does CallOnMainThread). If it did
     // a pepper call which acquires the lock (most of them do), and we try to
     // shut down the thread and Join it while holding the lock, we would
     // deadlock. So we give up the lock here so that the thread at least _can_
     // make Pepper calls without causing deadlock.
     CallWhileUnlocked(base::Bind(&base::DelegateSimpleThread::Join,
                                  base::Unretained(audio_thread_.get())));
     audio_thread_.reset();
   }
 #else
   if (thread_active_) {
     // See comment above about why we unlock here.
     int result = CallWhileUnlocked(thread_functions.thread_join, thread_id_);
     DCHECK_EQ(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
 
@@ skipping 20 matching lines @@
     // Let the other end know which buffer we just filled.  The buffer index is
     // used to ensure the other end is getting the buffer it expects.  For more
     // details on how this works see AudioSyncReader::WaitUntilDataIsReady().
     size_t bytes_sent = socket_->Send(&buffer_index_, sizeof(buffer_index_));
     if (bytes_sent != sizeof(buffer_index_))
       break;
   }
 }
 
 }  // namespace ppapi