Convert ppapi/shared to use TrackedCallback.

ppapi/shared_impl/private/tcp_socket_private_impl.cc

Index: ppapi/shared_impl/private/tcp_socket_private_impl.cc
diff --git a/ppapi/shared_impl/private/tcp_socket_private_impl.cc b/ppapi/shared_impl/private/tcp_socket_private_impl.cc
index 7ec1535907a7f76022dd1d3dd6af8a732b57d84f..86cd8431c82dcaf3cc54c5737db574f15de754db 100644
--- a/ppapi/shared_impl/private/tcp_socket_private_impl.cc
+++ b/ppapi/shared_impl/private/tcp_socket_private_impl.cc
@@ -17,14 +17,6 @@
 
 namespace ppapi {
 
-namespace {
-
-void AbortCallback(PP_CompletionCallback callback) {
-  PP_RunCompletionCallback(&callback, PP_ERROR_ABORTED);
-}
-
-}  // namespace
-
 const int32_t TCPSocketPrivateImpl::kMaxReadSize = 1024 * 1024;
 const int32_t TCPSocketPrivateImpl::kMaxWriteSize = 1024 * 1024;
 
@@ -57,10 +49,10 @@ int32_t TCPSocketPrivateImpl::Connect(const char* host,
     return PP_ERROR_BLOCKS_MAIN_THREAD;
   if (connection_state_ != BEFORE_CONNECT)
     return PP_ERROR_FAILED;
-  if (connect_callback_.func)
+  if (connect_callback_.get())
     return PP_ERROR_INPROGRESS;  // Can only have one pending request.
 
-  connect_callback_ = callback;
+  connect_callback_ = new TrackedCallback(this, callback);
   // Send the request, the browser will call us back via ConnectACK.
   SendConnect(host, port);
   return PP_OK_COMPLETIONPENDING;
@@ -75,10 +67,10 @@ int32_t TCPSocketPrivateImpl::ConnectWithNetAddress(
     return PP_ERROR_BLOCKS_MAIN_THREAD;
   if (connection_state_ != BEFORE_CONNECT)
     return PP_ERROR_FAILED;
-  if (connect_callback_.func)
+  if (connect_callback_.get())
     return PP_ERROR_INPROGRESS;  // Can only have one pending request.
 
-  connect_callback_ = callback;
+  connect_callback_ = new TrackedCallback(this, callback);
   // Send the request, the browser will call us back via ConnectACK.
   SendConnectWithNetAddress(*addr);
   return PP_OK_COMPLETIONPENDING;
@@ -112,11 +104,11 @@ int32_t TCPSocketPrivateImpl::SSLHandshake(const char* server_name,
 
   if (connection_state_ != CONNECTED)
     return PP_ERROR_FAILED;
-  if (ssl_handshake_callback_.func || read_callback_.func ||
-      write_callback_.func)
+  if (ssl_handshake_callback_.get() || read_callback_.get() ||
+      write_callback_.get())
     return PP_ERROR_INPROGRESS;
 
-  ssl_handshake_callback_ = callback;
+  ssl_handshake_callback_ = new TrackedCallback(this, callback);
 
   // Send the request, the browser will call us back via SSLHandshakeACK.
   SendSSLHandshake(server_name, server_port);
@@ -133,13 +125,13 @@ int32_t TCPSocketPrivateImpl::Read(char* buffer,
 
   if (!IsConnected())
     return PP_ERROR_FAILED;
-  if (read_callback_.func || ssl_handshake_callback_.func)
+  if (read_callback_.get() || ssl_handshake_callback_.get())
     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_ = callback;
+  read_callback_ = new TrackedCallback(this, callback);
 
   // Send the request, the browser will call us back via ReadACK.
   SendRead(bytes_to_read_);
@@ -156,13 +148,13 @@ int32_t TCPSocketPrivateImpl::Write(const char* buffer,
 
   if (!IsConnected())
     return PP_ERROR_FAILED;
-  if (write_callback_.func || ssl_handshake_callback_.func)
+  if (write_callback_.get() || ssl_handshake_callback_.get())
     return PP_ERROR_INPROGRESS;
 
   if (bytes_to_write > kMaxWriteSize)
     bytes_to_write = kMaxWriteSize;
 
-  write_callback_ = callback;
+  write_callback_ = new TrackedCallback(this, callback);
 
   // Send the request, the browser will call us back via WriteACK.
   SendWrite(std::string(buffer, bytes_to_write));
@@ -190,7 +182,7 @@ void TCPSocketPrivateImpl::OnConnectCompleted(
     bool succeeded,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
-  if (connection_state_ != BEFORE_CONNECT || !connect_callback_.func) {
+  if (connection_state_ != BEFORE_CONNECT || !connect_callback_.get()) {
     NOTREACHED();
     return;
   }
@@ -200,28 +192,28 @@ void TCPSocketPrivateImpl::OnConnectCompleted(
     remote_addr_ = remote_addr;
     connection_state_ = CONNECTED;
   }
-  PP_RunAndClearCompletionCallback(&connect_callback_,
-                                   succeeded ? PP_OK : PP_ERROR_FAILED);
+  TrackedCallback::ClearAndRun(&connect_callback_,
+                               succeeded ? PP_OK : PP_ERROR_FAILED);
 }
 
 void TCPSocketPrivateImpl::OnSSLHandshakeCompleted(bool succeeded) {
-  if (connection_state_ != CONNECTED || !ssl_handshake_callback_.func) {
+  if (connection_state_ != CONNECTED || !ssl_handshake_callback_.get()) {
     NOTREACHED();
     return;
   }
 
   if (succeeded) {
     connection_state_ = SSL_CONNECTED;
-    PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_OK);
+    TrackedCallback::ClearAndRun(&ssl_handshake_callback_, PP_OK);
   } else {
-    PP_RunAndClearCompletionCallback(&ssl_handshake_callback_, PP_ERROR_FAILED);
+    TrackedCallback::ClearAndRun(&ssl_handshake_callback_, PP_ERROR_FAILED);
     Disconnect();
   }
 }
 
 void TCPSocketPrivateImpl::OnReadCompleted(bool succeeded,
                                            const std::string& data) {
-  if (!read_callback_.func || !read_buffer_) {
+  if (!read_callback_.get() || !read_buffer_) {
     NOTREACHED();
     return;
   }
@@ -234,7 +226,7 @@ void TCPSocketPrivateImpl::OnReadCompleted(bool succeeded,
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
 
-  PP_RunAndClearCompletionCallback(
+  TrackedCallback::ClearAndRun(
       &read_callback_,
       succeeded ? static_cast<int32_t>(data.size()) :
                   static_cast<int32_t>(PP_ERROR_FAILED));
@@ -242,12 +234,12 @@ void TCPSocketPrivateImpl::OnReadCompleted(bool succeeded,
 
 void TCPSocketPrivateImpl::OnWriteCompleted(bool succeeded,
                                             int32_t bytes_written) {
-  if (!write_callback_.func || (succeeded && bytes_written < 0)) {
+  if (!write_callback_.get() || (succeeded && bytes_written < 0)) {
     NOTREACHED();
     return;
   }
 
-  PP_RunAndClearCompletionCallback(
+  TrackedCallback::ClearAndRun(
       &write_callback_,
       succeeded ? bytes_written : static_cast<int32_t>(PP_ERROR_FAILED));
 }
@@ -256,10 +248,6 @@ void TCPSocketPrivateImpl::Init(uint32 socket_id) {
   DCHECK(socket_id != 0);
   socket_id_ = socket_id;
   connection_state_ = BEFORE_CONNECT;
-  connect_callback_ = PP_BlockUntilComplete();
-  ssl_handshake_callback_ = PP_BlockUntilComplete();
-  read_callback_ = PP_BlockUntilComplete();
-  write_callback_ = PP_BlockUntilComplete();
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
 
@@ -276,13 +264,10 @@ bool TCPSocketPrivateImpl::IsConnected() const {
 }
 
 void TCPSocketPrivateImpl::PostAbortAndClearIfNecessary(
-    PP_CompletionCallback* callback) {
-  DCHECK(callback);
-
-  if (callback->func) {
-    MessageLoop::current()->PostTask(FROM_HERE,
-                                     base::Bind(&AbortCallback, *callback));
-    *callback = PP_BlockUntilComplete();
+    scoped_refptr<TrackedCallback>* callback) {
+  if (callback->get()) {
+    (*callback)->PostAbort();
+    *callback = NULL;
   }
 }