Support using TrackedCallbacks as hints to determine the handling thread of resource reply messages

ppapi/proxy/tcp_socket_resource_base.cc

 // Copyright 2013 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/tcp_socket_resource_base.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 66 matching lines @@
   if (!state_.IsValidTransition(TCPSocketState::BIND))
     return PP_ERROR_FAILED;
 
   bind_callback_ = callback;
   state_.SetPendingTransition(TCPSocketState::BIND);
 
   Call<PpapiPluginMsg_TCPSocket_BindReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Bind(*addr),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgBindReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketResourceBase::ConnectImpl(
     const char* host,
     uint16_t port,
     scoped_refptr<TrackedCallback> callback) {
   if (!host)
     return PP_ERROR_BADARGUMENT;
   if (state_.IsPending(TCPSocketState::CONNECT))
     return PP_ERROR_INPROGRESS;
   if (!state_.IsValidTransition(TCPSocketState::CONNECT))
     return PP_ERROR_FAILED;
 
   connect_callback_ = callback;
   state_.SetPendingTransition(TCPSocketState::CONNECT);
 
   Call<PpapiPluginMsg_TCPSocket_ConnectReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Connect(host, port),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgConnectReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketResourceBase::ConnectWithNetAddressImpl(
     const PP_NetAddress_Private* addr,
     scoped_refptr<TrackedCallback> callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
   if (state_.IsPending(TCPSocketState::CONNECT))
     return PP_ERROR_INPROGRESS;
   if (!state_.IsValidTransition(TCPSocketState::CONNECT))
     return PP_ERROR_FAILED;
 
   connect_callback_ = callback;
   state_.SetPendingTransition(TCPSocketState::CONNECT);
 
   Call<PpapiPluginMsg_TCPSocket_ConnectReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_ConnectWithNetAddress(*addr),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgConnectReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool TCPSocketResourceBase::GetLocalAddressImpl(
     PP_NetAddress_Private* local_addr) {
   if (!state_.IsBound() || !local_addr)
     return PP_FALSE;
   *local_addr = local_addr_;
   return PP_TRUE;
 }
@@ skipping 24 matching lines @@
   ssl_handshake_callback_ = callback;
   state_.SetPendingTransition(TCPSocketState::SSL_CONNECT);
 
   Call<PpapiPluginMsg_TCPSocket_SSLHandshakeReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_SSLHandshake(server_name,
                                           server_port,
                                           trusted_certificates_,
                                           untrusted_certificates_),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgSSLHandshakeReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Resource TCPSocketResourceBase::GetServerCertificateImpl() {
   if (!server_certificate_.get())
     return 0;
   return server_certificate_->GetReference();
 }
 
 PP_Bool TCPSocketResourceBase::AddChainBuildingCertificateImpl(
@@ skipping 40 matching lines @@
       state_.IsPending(TCPSocketState::SSL_CONNECT))
     return PP_ERROR_INPROGRESS;
   read_buffer_ = buffer;
   bytes_to_read_ = std::min(bytes_to_read, kMaxReadSize);
   read_callback_ = callback;
 
   Call<PpapiPluginMsg_TCPSocket_ReadReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Read(bytes_to_read_),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgReadReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketResourceBase::WriteImpl(
     const char* buffer,
     int32_t bytes_to_write,
     scoped_refptr<TrackedCallback> callback) {
   if (!buffer || bytes_to_write <= 0)
     return PP_ERROR_BADARGUMENT;
 
   if (!state_.IsConnected())
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(write_callback_) ||
       state_.IsPending(TCPSocketState::SSL_CONNECT))
     return PP_ERROR_INPROGRESS;
 
   if (bytes_to_write > kMaxWriteSize)
     bytes_to_write = kMaxWriteSize;
 
   write_callback_ = callback;
 
   Call<PpapiPluginMsg_TCPSocket_WriteReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Write(std::string(buffer, bytes_to_write)),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgWriteReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketResourceBase::ListenImpl(
     int32_t backlog,
     scoped_refptr<TrackedCallback> callback) {
   if (backlog <= 0)
     return PP_ERROR_BADARGUMENT;
   if (state_.IsPending(TCPSocketState::LISTEN))
     return PP_ERROR_INPROGRESS;
   if (!state_.IsValidTransition(TCPSocketState::LISTEN))
     return PP_ERROR_FAILED;
 
   listen_callback_ = callback;
   state_.SetPendingTransition(TCPSocketState::LISTEN);
 
   Call<PpapiPluginMsg_TCPSocket_ListenReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Listen(backlog),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgListenReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketResourceBase::AcceptImpl(
     PP_Resource* accepted_tcp_socket,
     scoped_refptr<TrackedCallback> callback) {
   if (!accepted_tcp_socket)
     return PP_ERROR_BADARGUMENT;
   if (TrackedCallback::IsPending(accept_callback_))
     return PP_ERROR_INPROGRESS;
   if (state_.state() != TCPSocketState::LISTENING)
     return PP_ERROR_FAILED;
 
   accept_callback_ = callback;
   accepted_tcp_socket_ = accepted_tcp_socket;
 
   Call<PpapiPluginMsg_TCPSocket_AcceptReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Accept(),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgAcceptReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void TCPSocketResourceBase::CloseImpl() {
   if (state_.state() == TCPSocketState::CLOSED)
     return;
 
   state_.DoTransition(TCPSocketState::CLOSE, true);
 
   Post(BROWSER, PpapiHostMsg_TCPSocket_Close());
@@ skipping 41 matching lines @@
       return PP_ERROR_BADARGUMENT;
     }
   }
 
   set_option_callbacks_.push(callback);
 
   Call<PpapiPluginMsg_TCPSocket_SetOptionReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_SetOption(name, option_data),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgSetOptionReply,
-                 base::Unretained(this)));
+                 base::Unretained(this)),
+      callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 void TCPSocketResourceBase::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (TrackedCallback::IsPending(*callback))
     (*callback)->PostAbort();
 }
 
 void TCPSocketResourceBase::OnPluginMsgBindReply(
@@ skipping 135 matching lines @@
 }
 
 void TCPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
                                         int32_t pp_result) {
   callback->Run(ConvertNetworkAPIErrorForCompatibility(
       pp_result, version_ == TCP_SOCKET_VERSION_PRIVATE));
 }
 
 }  // namespace ppapi
 }  // namespace proxy