PPAPI: Make blocking completion callbacks work.

ppapi/shared_impl/ppb_audio_input_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_input_shared.h"
 
 #include "base/logging.h"
 #include "media/audio/audio_parameters.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
@@ skipping 35 matching lines @@
 }
 
 PPB_AudioInput_Shared::~PPB_AudioInput_Shared() {
   DCHECK(open_state_ == CLOSED);
 }
 
 thunk::PPB_AudioInput_API* PPB_AudioInput_Shared::AsPPB_AudioInput_API() {
   return this;
 }
 
-int32_t PPB_AudioInput_Shared::EnumerateDevices(
-    PP_Resource* devices,
-    const PP_CompletionCallback& callback) {
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
+int32_t PPB_AudioInput_Shared::EnumerateDevices(PP_Resource* devices,
+                                                ApiCallbackType callback) {
   if (TrackedCallback::IsPending(enumerate_devices_callback_))
     return PP_ERROR_INPROGRESS;
 
   return InternalEnumerateDevices(devices, callback);
 }
 
 int32_t PPB_AudioInput_Shared::Open(
     const std::string& device_id,
     PP_Resource config,
     PPB_AudioInput_Callback audio_input_callback,
     void* user_data,
-    const PP_CompletionCallback& callback) {
+    ApiCallbackType callback) {
   if (!audio_input_callback)
     return PP_ERROR_BADARGUMENT;
 
   return CommonOpen(device_id, config, audio_input_callback, user_data,
                     callback);
 }
 
 PP_Resource PPB_AudioInput_Shared::GetCurrentConfig() {
   // AddRef for the caller.
   if (config_.get())
@@ skipping 83 matching lines @@
     base::SharedMemory temp_mem(shared_memory_handle, false);
     capturing_ = false;
   }
 
   // The callback may have been aborted by Close().
   if (TrackedCallback::IsPending(open_callback_))
     TrackedCallback::ClearAndRun(&open_callback_, result);
 }
 
 // static
-PP_CompletionCallback PPB_AudioInput_Shared::MakeIgnoredCompletionCallback() {
-  return PP_MakeCompletionCallback(&IgnoredCompletionCallback, NULL);
+ApiCallbackType PPB_AudioInput_Shared::MakeIgnoredCompletionCallback(
+    Resource* resource) {
+  return new TrackedCallback(resource,
+      PP_MakeCompletionCallback(&IgnoredCompletionCallback, NULL));
 }
 
 void PPB_AudioInput_Shared::SetStartCaptureState() {
   DCHECK(!capturing_);
   DCHECK(!audio_input_thread_.get());
 
   if (audio_input_callback_ && socket_.get())
     StartThread();
   capturing_ = true;
 }
@@ skipping 55 matching lines @@
     if (buffer->params.size > 0)
       audio_input_callback_(&buffer->audio[0], buffer->params.size, user_data_);
   }
 }
 
 int32_t PPB_AudioInput_Shared::CommonOpen(
     const std::string& device_id,
     PP_Resource config,
     PPB_AudioInput_Callback audio_input_callback,
     void* user_data,
-    PP_CompletionCallback callback) {
+    ApiCallbackType callback) {
   if (open_state_ != BEFORE_OPEN)
     return PP_ERROR_FAILED;
 
   thunk::EnterResourceNoLock<thunk::PPB_AudioConfig_API> enter_config(config,
                                                                       true);
   if (enter_config.failed())
     return PP_ERROR_BADARGUMENT;
 
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
   if (TrackedCallback::IsPending(open_callback_))
     return PP_ERROR_INPROGRESS;
 
   config_ = config;
   audio_input_callback_ = audio_input_callback;
   user_data_ = user_data;
 
   return InternalOpen(device_id, enter_config.object()->GetSampleRate(),
                       enter_config.object()->GetSampleFrameCount(), callback);
 }
 
 }  // namespace ppapi