PPAPI: Make blocking completion callbacks work.

ppapi/proxy/ppb_video_capture_proxy.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/proxy/ppb_video_capture_proxy.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "build/build_config.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 144 matching lines @@
     buffer_in_use_ = std::vector<bool>(count);
   }
 
   void SetBufferInUse(uint32_t buffer) {
     DCHECK(buffer < buffer_in_use_.size());
     buffer_in_use_[buffer] = true;
   }
 
  private:
   // PPB_VideoCapture_Shared implementation.
-  virtual int32_t InternalEnumerateDevices(
-      PP_Resource* devices,
-      const PP_CompletionCallback& callback) OVERRIDE;
+  virtual int32_t InternalEnumerateDevices(PP_Resource* devices,
+                                           ApiCallbackType callback) OVERRIDE;
   virtual int32_t InternalOpen(
       const std::string& device_id,
       const PP_VideoCaptureDeviceInfo_Dev& requested_info,
       uint32_t buffer_count,
-      const PP_CompletionCallback& callback) OVERRIDE;
+      ApiCallbackType callback) OVERRIDE;
   virtual int32_t InternalStartCapture() OVERRIDE;
   virtual int32_t InternalReuseBuffer(uint32_t buffer) OVERRIDE;
   virtual int32_t InternalStopCapture() OVERRIDE;
   virtual void InternalClose() OVERRIDE;
   virtual int32_t InternalStartCapture0_1(
       const PP_VideoCaptureDeviceInfo_Dev& requested_info,
       uint32_t buffer_count) OVERRIDE;
   virtual const std::vector<DeviceRefData>&
       InternalGetDeviceRefData() const OVERRIDE;
 
@@ skipping 23 matching lines @@
     case PP_VIDEO_CAPTURE_STATUS_STARTING:
     case PP_VIDEO_CAPTURE_STATUS_STOPPING:
       // Those states are not sent by the browser.
       break;
   }
 
   NOTREACHED();
   return false;
 }
 
-int32_t VideoCapture::InternalEnumerateDevices(
-    PP_Resource* devices, const PP_CompletionCallback& callback) {
+int32_t VideoCapture::InternalEnumerateDevices(PP_Resource* devices,
+                                               ApiCallbackType callback) {
   devices_ = devices;
-  enumerate_devices_callback_ = new TrackedCallback(this, callback);
+  enumerate_devices_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_EnumerateDevices(
       API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource()));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t VideoCapture::InternalOpen(
     const std::string& device_id,
     const PP_VideoCaptureDeviceInfo_Dev& requested_info,
     uint32_t buffer_count,
-    const PP_CompletionCallback& callback) {
-  // Disallow blocking call. The base class doesn't check this.
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
-
-  open_callback_ = new TrackedCallback(this, callback);
+    ApiCallbackType callback) {
+  open_callback_ = callback;
   GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_Open(
       API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource(), device_id, requested_info,
       buffer_count));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t VideoCapture::InternalStartCapture() {
   buffer_in_use_.clear();
   GetDispatcher()->Send(new PpapiHostMsg_PPBVideoCapture_StartCapture(
       API_ID_PPB_VIDEO_CAPTURE_DEV, host_resource()));
@@ skipping 292 matching lines @@
     return;
 
   VideoCapture* capture = static_cast<VideoCapture*>(enter.object());
   capture->SetBufferInUse(buffer);
   ppp_video_capture_impl_->OnBufferReady(
       host_resource.instance(), capture->pp_resource(), buffer);
 }
 
 }  // namespace proxy
 }  // namespace ppapi