PPAPI: Make blocking completion callbacks work.

webkit/plugins/ppapi/ppb_transport_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_transport_impl.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 219 matching lines @@
       break;
     }
 
     default:
       return PP_ERROR_BADARGUMENT;
   }
 
   return PP_OK;
 }
 
-int32_t PPB_Transport_Impl::Connect(PP_CompletionCallback callback) {
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
+int32_t PPB_Transport_Impl::Connect(scoped_refptr<TrackedCallback> callback) {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   // Connect() has already been called.
   if (started_)
     return PP_ERROR_INPROGRESS;
 
   P2PTransport::Protocol protocol = (type_ == PP_TRANSPORTTYPE_STREAM) ?
       P2PTransport::PROTOCOL_TCP : P2PTransport::PROTOCOL_UDP;
 
   if (!p2p_transport_->Init(
           GetFrameForResource(this), name_, protocol, config_, this)) {
     return PP_ERROR_FAILED;
   }
 
   started_ = true;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
-  connect_callback_ = new TrackedCallback(this, callback);
+  connect_callback_ = callback;
   return PP_OK_COMPLETIONPENDING;
 }
 
-int32_t PPB_Transport_Impl::GetNextAddress(PP_Var* address,
-                                           PP_CompletionCallback callback) {
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
+int32_t PPB_Transport_Impl::GetNextAddress(
+    PP_Var* address,
+    scoped_refptr<TrackedCallback> callback) {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   if (TrackedCallback::IsPending(next_address_callback_))
     return PP_ERROR_INPROGRESS;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
   if (!local_candidates_.empty()) {
     *address = StringVar::StringToPPVar(local_candidates_.front());
     local_candidates_.pop_front();
     return PP_OK;
   }
 
-  next_address_callback_ = new TrackedCallback(this, callback);
+  next_address_callback_ = callback;
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_Transport_Impl::ReceiveRemoteAddress(PP_Var address) {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   StringVar* address_str = StringVar::FromPPVar(address);
   if (!address_str)
     return PP_ERROR_BADARGUMENT;
 
   return p2p_transport_->AddRemoteCandidate(address_str->value()) ?
       PP_OK : PP_ERROR_FAILED;
 }
 
 int32_t PPB_Transport_Impl::Recv(void* data, uint32_t len,
-                                 PP_CompletionCallback callback) {
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
+                                 scoped_refptr<TrackedCallback> callback) {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   if (TrackedCallback::IsPending(recv_callback_))
     return PP_ERROR_INPROGRESS;
 
   net::Socket* channel = p2p_transport_->GetChannel();
   if (!channel)
     return PP_ERROR_FAILED;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
   scoped_refptr<net::IOBuffer> buffer =
       new net::WrappedIOBuffer(static_cast<const char*>(data));
   int result = MapNetError(
       channel->Read(buffer, len, base::Bind(&PPB_Transport_Impl::OnRead,
                                             base::Unretained(this))));
   if (result == PP_OK_COMPLETIONPENDING)
-    recv_callback_ = new TrackedCallback(this, callback);
+    recv_callback_ = callback;
 
   return result;
 }
 
 int32_t PPB_Transport_Impl::Send(const void* data, uint32_t len,
-                                 PP_CompletionCallback callback) {
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
+                                 scoped_refptr<TrackedCallback> callback) {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   if (TrackedCallback::IsPending(send_callback_))
     return PP_ERROR_INPROGRESS;
 
   net::Socket* channel = p2p_transport_->GetChannel();
   if (!channel)
     return PP_ERROR_FAILED;
 
   PluginModule* plugin_module = ResourceHelper::GetPluginModule(this);
   if (!plugin_module)
     return PP_ERROR_FAILED;
 
   scoped_refptr<net::IOBuffer> buffer =
       new net::WrappedIOBuffer(static_cast<const char*>(data));
   int result = MapNetError(
       channel->Write(buffer, len, base::Bind(&PPB_Transport_Impl::OnWritten,
                                              base::Unretained(this))));
   if (result == PP_OK_COMPLETIONPENDING)
-    send_callback_ = new TrackedCallback(this, callback);
+    send_callback_ = callback;
 
   return result;
 }
 
 int32_t PPB_Transport_Impl::Close() {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   p2p_transport_.reset();
 
@@ skipping 27 matching lines @@
   TrackedCallback::ClearAndRun(&recv_callback_, MapNetError(result));
 }
 
 void PPB_Transport_Impl::OnWritten(int result) {
   DCHECK(TrackedCallback::IsPending(send_callback_));
   TrackedCallback::ClearAndRun(&send_callback_, MapNetError(result));
 }
 
 }  // namespace ppapi
 }  // namespace webkit