PPAPI: Make blocking completion callbacks work.

ppapi/shared_impl/private/tcp_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/tcp_socket_private_impl.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 32 matching lines @@
 TCPSocketPrivateImpl::~TCPSocketPrivateImpl() {
 }
 
 thunk::PPB_TCPSocket_Private_API*
 TCPSocketPrivateImpl::AsPPB_TCPSocket_Private_API() {
   return this;
 }
 
 int32_t TCPSocketPrivateImpl::Connect(const char* host,
                                       uint16_t port,
-                                      PP_CompletionCallback callback) {
+                                      scoped_refptr<TrackedCallback> callback) {
   if (!host)
     return PP_ERROR_BADARGUMENT;
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
   if (connection_state_ != BEFORE_CONNECT)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(connect_callback_))
     return PP_ERROR_INPROGRESS;  // Can only have one pending request.
 
-  connect_callback_ = new TrackedCallback(this, callback);
+  connect_callback_ = callback;
   // Send the request, the browser will call us back via ConnectACK.
   SendConnect(host, port);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketPrivateImpl::ConnectWithNetAddress(
     const PP_NetAddress_Private* addr,
-    PP_CompletionCallback callback) {
+    scoped_refptr<TrackedCallback> callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
   if (connection_state_ != BEFORE_CONNECT)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(connect_callback_))
     return PP_ERROR_INPROGRESS;  // Can only have one pending request.
 
-  connect_callback_ = new TrackedCallback(this, callback);
+  connect_callback_ = callback;
   // Send the request, the browser will call us back via ConnectACK.
   SendConnectWithNetAddress(*addr);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool TCPSocketPrivateImpl::GetLocalAddress(
     PP_NetAddress_Private* local_addr) {
   if (!IsConnected() || !local_addr)
     return PP_FALSE;
 
   *local_addr = local_addr_;
   return PP_TRUE;
 }
 
 PP_Bool TCPSocketPrivateImpl::GetRemoteAddress(
     PP_NetAddress_Private* remote_addr) {
   if (!IsConnected() || !remote_addr)
     return PP_FALSE;
 
   *remote_addr = remote_addr_;
   return PP_TRUE;
 }
 
-int32_t TCPSocketPrivateImpl::SSLHandshake(const char* server_name,
-                                           uint16_t server_port,
-                                           PP_CompletionCallback callback) {
+int32_t TCPSocketPrivateImpl::SSLHandshake(
+    const char* server_name,
+    uint16_t server_port,
+    scoped_refptr<TrackedCallback> callback) {
   if (!server_name)
     return PP_ERROR_BADARGUMENT;
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   if (connection_state_ != CONNECTED)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(ssl_handshake_callback_) ||
       TrackedCallback::IsPending(read_callback_) ||
       TrackedCallback::IsPending(write_callback_))
     return PP_ERROR_INPROGRESS;
 
-  ssl_handshake_callback_ = new TrackedCallback(this, callback);
+  ssl_handshake_callback_ = callback;
 
   // Send the request, the browser will call us back via SSLHandshakeACK.
   SendSSLHandshake(server_name, server_port, trusted_certificates_,
       untrusted_certificates_);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Resource TCPSocketPrivateImpl::GetServerCertificate() {
   if (!server_certificate_.get())
     return 0;
@@ skipping 26 matching lines @@
     else
       untrusted_certificates_.push_back(der);
     success = PP_TRUE;
   }
   PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(der_var);
   return success;
 }
 
 int32_t TCPSocketPrivateImpl::Read(char* buffer,
                                    int32_t bytes_to_read,
-                                   PP_CompletionCallback callback) {
+                                   scoped_refptr<TrackedCallback> callback) {
   if (!buffer || bytes_to_read <= 0)
     return PP_ERROR_BADARGUMENT;
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   if (!IsConnected())
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(read_callback_) ||
       TrackedCallback::IsPending(ssl_handshake_callback_))
     return PP_ERROR_INPROGRESS;
-  // TODO(dmichael): use some other strategy for determining if an
-  // operation is in progress
   read_buffer_ = buffer;
   bytes_to_read_ = std::min(bytes_to_read, kMaxReadSize);
-  read_callback_ = new TrackedCallback(this, callback);
+  read_callback_ = callback;
 
   // Send the request, the browser will call us back via ReadACK.
   SendRead(bytes_to_read_);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketPrivateImpl::Write(const char* buffer,
                                     int32_t bytes_to_write,
-                                    PP_CompletionCallback callback) {
+                                    scoped_refptr<TrackedCallback> callback) {
   if (!buffer || bytes_to_write <= 0)
     return PP_ERROR_BADARGUMENT;
-  if (!callback.func)
-    return PP_ERROR_BLOCKS_MAIN_THREAD;
 
   if (!IsConnected())
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(write_callback_) ||
       TrackedCallback::IsPending(ssl_handshake_callback_))
     return PP_ERROR_INPROGRESS;
 
   if (bytes_to_write > kMaxWriteSize)
     bytes_to_write = kMaxWriteSize;
 
-  write_callback_ = new TrackedCallback(this, callback);
+  write_callback_ = callback;
 
   // Send the request, the browser will call us back via WriteACK.
   SendWrite(std::string(buffer, bytes_to_write));
   return PP_OK_COMPLETIONPENDING;
 }
 
 void TCPSocketPrivateImpl::Disconnect() {
   if (connection_state_ == DISCONNECTED)
     return;
 
@@ skipping 109 matching lines @@
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }
 
 void TCPSocketPrivateImpl::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (callback->get())
     (*callback)->PostAbort();
 }
 
 }  // namespace ppapi