Fix the crash for the AudioShared.

ppapi/shared_impl/ppb_audio_shared.h

 // 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.
 
 #ifndef PPAPI_SHARED_IMPL_PPB_AUDIO_SHARED_H_
 #define PPAPI_SHARED_IMPL_PPB_AUDIO_SHARED_H_
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
 #include "base/sync_socket.h"
 #include "base/threading/simple_thread.h"
 #include "media/base/audio_bus.h"
 #include "ppapi/c/ppb_audio.h"
 #include "ppapi/c/ppb_audio_config.h"
 #include "ppapi/shared_impl/resource.h"
 #include "ppapi/thunk/ppb_audio_api.h"
 
-#if defined(OS_NACL)
-#include "ppapi/nacl_irt/public/irt_ppapi.h"
-#endif
+struct PP_ThreadFunctions;
 
 namespace ppapi {
 
 class PPAPI_SHARED_EXPORT AudioCallbackCombined {
  public:
   AudioCallbackCombined();
   explicit AudioCallbackCombined(PPB_Audio_Callback_1_0 callback_1_0);
   explicit AudioCallbackCombined(PPB_Audio_Callback callback);
 
   ~AudioCallbackCombined();
@@ skipping 47 matching lines @@
                      base::SyncSocket::Handle socket_handle,
                      PP_AudioSampleRate sample_rate,
                      int sample_frame_count);
 
   // Returns whether a thread can be created on the client context.
   // In trusted plugin, this should always return true, as it uses Chrome's
   // thread library. In NaCl plugin, this returns whether SetThreadFunctions
   // was invoked properly.
   static bool IsThreadFunctionReady();
 
-#if defined(OS_NACL)
+  // Sets the mode that this class is used for NaCl plugin.
+  // If set, SetThreadFunctions() must be called before this class is used.

[bbudge, 2014/04/21 23:12:24]

This comment suggests to me that you could eliminate SetNaClMode. I don't think
that's the case.

Is it really true that SetThreadFunctions must be called before using the class,
or only that it must be called before calling SetStartPlaybackState? Could we
refine the comment to say that?

// Configures this instance to run in a NaCl plugin.
// If called, SetThreadFunctions() must be called before calling
SetStartPlaybackState
// on any instance of this class.

[hidehiko, 2014/04/21 23:32:10]

I see. Done.

On 2014/04/21 23:12:24, bbudge wrote:

+  static void SetNaClMode();
+
   // NaCl has a special API for IRT code to create threads that can call back
   // into user code.
   static void SetThreadFunctions(const struct PP_ThreadFunctions* functions);
-#endif
 
  private:
   // Starts execution of the audio thread.
   void StartThread();
 
   // Stop execution of the audio thread.
   void StopThread();
 
   // DelegateSimpleThread::Delegate implementation. Run on the audio thread.
   virtual void Run();
 
   // True if playing the stream.
   bool playing_;
 
   // Socket used to notify us when audio is ready to accept new samples. This
   // pointer is created in StreamCreated().
   scoped_ptr<base::CancelableSyncSocket> socket_;
 
   // Sample buffer in shared memory. This pointer is created in
   // StreamCreated(). The memory is only mapped when the audio thread is
   // created.
   scoped_ptr<base::SharedMemory> shared_memory_;
 
   // The size of the sample buffer in bytes.
   size_t shared_memory_size_;
 
-#if !defined(OS_NACL)
   // When the callback is set, this thread is spawned for calling it.
   scoped_ptr<base::DelegateSimpleThread> audio_thread_;
-#else
-  uintptr_t thread_id_;
-  bool thread_active_;
+  uintptr_t nacl_thread_id_;
+  bool nacl_thread_active_;
 
   static void CallRun(void* self);
-#endif
 
   // Callback to call when audio is ready to accept new samples.
   AudioCallbackCombined callback_;
 
   // User data pointer passed verbatim to the callback function.
   void* user_data_;
 
   // AudioBus for shuttling data across the shared memory.
   scoped_ptr<media::AudioBus> audio_bus_;
 
   // Internal buffer for client's integer audio data.
   int client_buffer_size_bytes_;
   scoped_ptr<uint8_t[]> client_buffer_;
 
   // The size (in bytes) of one second of audio data. Used to calculate latency.
   size_t bytes_per_second_;
 
   // Buffer index used to coordinate with the browser side audio receiver.
   uint32_t buffer_index_;
 
   DISALLOW_COPY_AND_ASSIGN(PPB_Audio_Shared);
 };
 
 }  // namespace ppapi
 
 #endif  // PPAPI_SHARED_IMPL_PPB_AUDIO_SHARED_H_