PPAPI: Make blocking completion callbacks work.

webkit/plugins/ppapi/ppb_audio_input_impl.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 "webkit/plugins/ppapi/ppb_audio_input_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/shared_memory.h"
 #include "base/sync_socket.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/shared_impl/ppb_device_ref_shared.h"
 #include "ppapi/shared_impl/tracked_callback.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/resource_helper.h"
 
+using ppapi::ApiCallbackType;
 using ppapi::TrackedCallback;
 
 namespace webkit {
 namespace ppapi {
 
 // PPB_AudioInput_Impl ---------------------------------------------------------
 
 PPB_AudioInput_Impl::PPB_AudioInput_Impl(PP_Instance instance)
     : ::ppapi::PPB_AudioInput_Shared(instance),
       audio_input_(NULL) {
 }
 
 PPB_AudioInput_Impl::~PPB_AudioInput_Impl() {
   Close();
 }
 
 // static
 PP_Resource PPB_AudioInput_Impl::Create0_1(
     PP_Instance instance,
     PP_Resource config,
     PPB_AudioInput_Callback audio_input_callback,
     void* user_data) {
   scoped_refptr<PPB_AudioInput_Impl>
       audio_input(new PPB_AudioInput_Impl(instance));
   int32_t result = audio_input->Open(
       "", config, audio_input_callback, user_data,
-      MakeIgnoredCompletionCallback());
+      MakeIgnoredCompletionCallback(audio_input.get()));
   if (result != PP_OK && result != PP_OK_COMPLETIONPENDING)
     return 0;
   return audio_input->GetReference();
 }
 
 int32_t PPB_AudioInput_Impl::OpenTrusted(
     const std::string& device_id,
     PP_Resource config,
-    const PP_CompletionCallback& create_callback) {
+    ApiCallbackType create_callback) {
   return CommonOpen(device_id, config, NULL, NULL, create_callback);
 }
 
 int32_t PPB_AudioInput_Impl::GetSyncSocket(int* sync_socket) {
   if (socket_.get()) {
 #if defined(OS_POSIX)
     *sync_socket = socket_->handle();
 #elif defined(OS_WIN)
     *sync_socket = reinterpret_cast<int>(socket_->handle());
 #else
@@ skipping 32 matching lines @@
   OnOpenComplete(PP_OK, shared_memory_handle, shared_memory_size, socket);
 }
 
 void PPB_AudioInput_Impl::StreamCreationFailed() {
   OnOpenComplete(PP_ERROR_FAILED, base::SharedMemory::NULLHandle(), 0,
                  base::SyncSocket::kInvalidHandle);
 }
 
 int32_t PPB_AudioInput_Impl::InternalEnumerateDevices(
     PP_Resource* devices,
-    PP_CompletionCallback callback) {
+    ApiCallbackType callback) {
   PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
   if (!plugin_delegate)
     return PP_ERROR_FAILED;
 
   devices_ = devices;
-  enumerate_devices_callback_ = new TrackedCallback(this, callback);
+  enumerate_devices_callback_ = callback;
   plugin_delegate->EnumerateDevices(
       PP_DEVICETYPE_DEV_AUDIOCAPTURE,
       base::Bind(&PPB_AudioInput_Impl::EnumerateDevicesCallbackFunc,
                  AsWeakPtr()));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_AudioInput_Impl::InternalOpen(const std::string& device_id,
                                           PP_AudioSampleRate sample_rate,
                                           uint32_t sample_frame_count,
-                                          PP_CompletionCallback callback) {
+                                          ApiCallbackType callback) {
   PluginDelegate* plugin_delegate = ResourceHelper::GetPluginDelegate(this);
   if (!plugin_delegate)
     return PP_ERROR_FAILED;
 
   // When the stream is created, we'll get called back on StreamCreated().
   DCHECK(!audio_input_);
   audio_input_ = plugin_delegate->CreateAudioInput(
       device_id, sample_rate, sample_frame_count, this);
   if (audio_input_) {
-    open_callback_ = new TrackedCallback(this, callback);
+    open_callback_ = callback;
     return PP_OK_COMPLETIONPENDING;
   } else {
     return PP_ERROR_FAILED;
   }
 }
 
 PP_Bool PPB_AudioInput_Impl::InternalStartCapture() {
   if (!audio_input_)
     return PP_FALSE;
   SetStartCaptureState();
@@ skipping 27 matching lines @@
     const DeviceRefDataVector& devices) {
   devices_data_.clear();
   if (succeeded)
     devices_data_ = devices;
 
   OnEnumerateDevicesComplete(succeeded ? PP_OK : PP_ERROR_FAILED, devices);
 }
 
 }  // namespace ppapi
 }  // namespace webkit