PPAPI: Make blocking completion callbacks work.

ppapi/shared_impl/private/udp_socket_private_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 "ppapi/shared_impl/private/udp_socket_private_impl.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 23 matching lines @@
 
 UDPSocketPrivateImpl::~UDPSocketPrivateImpl() {
 }
 
 thunk::PPB_UDPSocket_Private_API*
 UDPSocketPrivateImpl::AsPPB_UDPSocket_Private_API() {
   return this;
 }
 
 int32_t UDPSocketPrivateImpl::Bind(const PP_NetAddress_Private* addr,
-                                   PP_CompletionCallback callback) {
-  if (!addr || !callback.func)
+                                   ApiCallbackType callback) {
+  if (!addr)
     return PP_ERROR_BADARGUMENT;
   if (bound_ || closed_)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(bind_callback_))
     return PP_ERROR_INPROGRESS;
-  // TODO(dmichael): use some other strategy for determining if an
-  // operation is in progress
 
-  bind_callback_ = new TrackedCallback(this, callback);
+  bind_callback_ = callback;
 
   // Send the request, the browser will call us back via BindACK.
   SendBind(*addr);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool UDPSocketPrivateImpl::GetBoundAddress(PP_NetAddress_Private* addr) {
   if (!addr || !bound_ || closed_)
     return PP_FALSE;
 
   *addr = bound_addr_;
   return PP_TRUE;
 }
 
 int32_t UDPSocketPrivateImpl::RecvFrom(char* buffer,
                                        int32_t num_bytes,
-                                       PP_CompletionCallback callback) {
-  if (!buffer || num_bytes <= 0 || !callback.func)
+                                       ApiCallbackType callback) {
+  if (!buffer || num_bytes <= 0)
     return PP_ERROR_BADARGUMENT;
   if (!bound_)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(recvfrom_callback_))
     return PP_ERROR_INPROGRESS;
 
   read_buffer_ = buffer;
   bytes_to_read_ = std::min(num_bytes, kMaxReadSize);
-  recvfrom_callback_ = new TrackedCallback(this, callback);
+  recvfrom_callback_ = callback;
 
   // Send the request, the browser will call us back via RecvFromACK.
   SendRecvFrom(bytes_to_read_);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool UDPSocketPrivateImpl::GetRecvFromAddress(PP_NetAddress_Private* addr) {
   if (!addr)
     return PP_FALSE;
 
   *addr = recvfrom_addr_;
   return PP_TRUE;
 }
 
 int32_t UDPSocketPrivateImpl::SendTo(const char* buffer,
                                      int32_t num_bytes,
                                      const PP_NetAddress_Private* addr,
-                                     PP_CompletionCallback callback) {
-  if (!buffer || num_bytes <= 0 || !addr || !callback.func)
+                                     ApiCallbackType callback) {
+  if (!buffer || num_bytes <= 0 || !addr)
     return PP_ERROR_BADARGUMENT;
   if (!bound_)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(sendto_callback_))
     return PP_ERROR_INPROGRESS;
 
   if (num_bytes > kMaxWriteSize)
     num_bytes = kMaxWriteSize;
 
-  sendto_callback_ = new TrackedCallback(this, callback);
+  sendto_callback_ = callback;
 
   // Send the request, the browser will call us back via SendToACK.
   SendSendTo(std::string(buffer, num_bytes), *addr);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void UDPSocketPrivateImpl::Close() {
   if(closed_)
     return;
 
@@ skipping 76 matching lines @@
          arraysize(bound_addr_.data) * sizeof(*bound_addr_.data));
 }
 
 void UDPSocketPrivateImpl::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (callback->get())
     (*callback)->PostAbort();
 }
 
 }  // namespace ppapi