PPB_TCPSocket: add support for TCP server socket operations.

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 14 matching lines @@
 
 const int32_t TCPSocketResourceBase::kMaxReadSize = 1024 * 1024;
 const int32_t TCPSocketResourceBase::kMaxWriteSize = 1024 * 1024;
 const int32_t TCPSocketResourceBase::kMaxSendBufferSize =
     1024 * TCPSocketResourceBase::kMaxWriteSize;
 const int32_t TCPSocketResourceBase::kMaxReceiveBufferSize =
     1024 * TCPSocketResourceBase::kMaxReadSize;
 
 TCPSocketResourceBase::TCPSocketResourceBase(Connection connection,
                                              PP_Instance instance,
-                                             bool private_api)
+                                             TCPSocketVersion version)
     : PluginResource(connection, instance),
-      connection_state_(BEFORE_CONNECT),
+      state_(TCPSocketState::INITIAL),
       read_buffer_(NULL),
       bytes_to_read_(-1),
-      private_api_(private_api) {
+      accepted_tcp_socket_(NULL),
+      version_(version) {
   local_addr_.size = 0;
   memset(local_addr_.data, 0,
          arraysize(local_addr_.data) * sizeof(*local_addr_.data));
   remote_addr_.size = 0;
   memset(remote_addr_.data, 0,
          arraysize(remote_addr_.data) * sizeof(*remote_addr_.data));
 }
 
 TCPSocketResourceBase::TCPSocketResourceBase(
     Connection connection,
     PP_Instance instance,
-    bool private_api,
+    TCPSocketVersion version,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr)
     : PluginResource(connection, instance),
-      connection_state_(CONNECTED),
+      state_(TCPSocketState::CONNECTED),
       read_buffer_(NULL),
       bytes_to_read_(-1),
       local_addr_(local_addr),
       remote_addr_(remote_addr),
-      private_api_(private_api) {
+      accepted_tcp_socket_(NULL),
+      version_(version) {
 }
 
 TCPSocketResourceBase::~TCPSocketResourceBase() {
+  CloseImpl();
+}
+
+int32_t TCPSocketResourceBase::BindImpl(
+    const PP_NetAddress_Private* addr,
+    scoped_refptr<TrackedCallback> callback) {
+  if (!addr)
+    return PP_ERROR_BADARGUMENT;
+  if (state_.IsPending(TCPSocketState::BIND))
+    return PP_ERROR_INPROGRESS;
+  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)));
+  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 (connection_state_ != BEFORE_CONNECT)
+  if (state_.IsPending(TCPSocketState::CONNECT))
+    return PP_ERROR_INPROGRESS;
+  if (!state_.IsValidTransition(TCPSocketState::CONNECT))
     return PP_ERROR_FAILED;
-  if (TrackedCallback::IsPending(connect_callback_))
-    return PP_ERROR_INPROGRESS;  // Can only have one pending request.
 
   connect_callback_ = callback;
+  state_.SetPendingTransition(TCPSocketState::CONNECT);
 
   Call<PpapiPluginMsg_TCPSocket_ConnectReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_Connect(host, port),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgConnectReply,
                  base::Unretained(this)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t TCPSocketResourceBase::ConnectWithNetAddressImpl(
     const PP_NetAddress_Private* addr,
     scoped_refptr<TrackedCallback> callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
-  if (connection_state_ != BEFORE_CONNECT)
+  if (state_.IsPending(TCPSocketState::CONNECT))
+    return PP_ERROR_INPROGRESS;
+  if (!state_.IsValidTransition(TCPSocketState::CONNECT))
     return PP_ERROR_FAILED;
-  if (TrackedCallback::IsPending(connect_callback_))
-    return PP_ERROR_INPROGRESS;  // Can only have one pending request.
 
   connect_callback_ = callback;
+  state_.SetPendingTransition(TCPSocketState::CONNECT);
 
   Call<PpapiPluginMsg_TCPSocket_ConnectReply>(
       BROWSER,
       PpapiHostMsg_TCPSocket_ConnectWithNetAddress(*addr),
       base::Bind(&TCPSocketResourceBase::OnPluginMsgConnectReply,
                  base::Unretained(this)));
   return PP_OK_COMPLETIONPENDING;
 }
 
 PP_Bool TCPSocketResourceBase::GetLocalAddressImpl(
     PP_NetAddress_Private* local_addr) {
-  if (!IsConnected() || !local_addr)
+  if (!state_.IsBound() || !local_addr)
     return PP_FALSE;
   *local_addr = local_addr_;
   return PP_TRUE;
 }
 
 PP_Bool TCPSocketResourceBase::GetRemoteAddressImpl(
     PP_NetAddress_Private* remote_addr) {
-  if (!IsConnected() || !remote_addr)
+  if (!state_.IsConnected() || !remote_addr)
     return PP_FALSE;
   *remote_addr = remote_addr_;
   return PP_TRUE;
 }
 
 int32_t TCPSocketResourceBase::SSLHandshakeImpl(
     const char* server_name,
     uint16_t server_port,
     scoped_refptr<TrackedCallback> callback) {
   if (!server_name)
     return PP_ERROR_BADARGUMENT;
 
-  if (connection_state_ != CONNECTED)
-    return PP_ERROR_FAILED;
-  if (TrackedCallback::IsPending(ssl_handshake_callback_) ||
+  if (state_.IsPending(TCPSocketState::SSL_CONNECT) ||
       TrackedCallback::IsPending(read_callback_) ||
       TrackedCallback::IsPending(write_callback_)) {
     return PP_ERROR_INPROGRESS;
   }
+  if (!state_.IsValidTransition(TCPSocketState::SSL_CONNECT))
+    return PP_ERROR_FAILED;
 
   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)));
   return PP_OK_COMPLETIONPENDING;
@@ skipping 36 matching lines @@
   return success;
 }
 
 int32_t TCPSocketResourceBase::ReadImpl(
     char* buffer,
     int32_t bytes_to_read,
     scoped_refptr<TrackedCallback> callback) {
   if (!buffer || bytes_to_read <= 0)
     return PP_ERROR_BADARGUMENT;
 
-  if (!IsConnected())
+  if (!state_.IsConnected())
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(read_callback_) ||
-      TrackedCallback::IsPending(ssl_handshake_callback_))
+      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)));
   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 (!IsConnected())
+  if (!state_.IsConnected())
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(write_callback_) ||
-      TrackedCallback::IsPending(ssl_handshake_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)));
   return PP_OK_COMPLETIONPENDING;
 }
 
-void TCPSocketResourceBase::DisconnectImpl() {
-  if (connection_state_ == DISCONNECTED)
+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)));
+  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)));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void TCPSocketResourceBase::CloseImpl() {
+  if (state_.state() == TCPSocketState::CLOSED)
     return;
 
-  connection_state_ = DISCONNECTED;
+  state_.DoTransition(TCPSocketState::CLOSE, true);
 
-  Post(BROWSER, PpapiHostMsg_TCPSocket_Disconnect());
+  Post(BROWSER, PpapiHostMsg_TCPSocket_Close());
 
+  PostAbortIfNecessary(&bind_callback_);
   PostAbortIfNecessary(&connect_callback_);
   PostAbortIfNecessary(&ssl_handshake_callback_);
   PostAbortIfNecessary(&read_callback_);
   PostAbortIfNecessary(&write_callback_);
+  PostAbortIfNecessary(&listen_callback_);
+  PostAbortIfNecessary(&accept_callback_);
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
   server_certificate_ = NULL;
+  accepted_tcp_socket_ = NULL;
 }
 
 int32_t TCPSocketResourceBase::SetOptionImpl(
     PP_TCPSocket_Option name,
     const PP_Var& value,
     scoped_refptr<TrackedCallback> callback) {
-  if (!IsConnected())
-    return PP_ERROR_FAILED;
-
   SocketOptionData option_data;
   switch (name) {
     case PP_TCPSOCKET_OPTION_NO_DELAY: {
+      if (!state_.IsConnected())
+        return PP_ERROR_FAILED;
+
       if (value.type != PP_VARTYPE_BOOL)
         return PP_ERROR_BADARGUMENT;
       option_data.SetBool(PP_ToBool(value.value.as_bool));
       break;
     }
     case PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE:
     case PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE: {
+      if (!state_.IsConnected())
+        return PP_ERROR_FAILED;
+
       if (value.type != PP_VARTYPE_INT32)
         return PP_ERROR_BADARGUMENT;
       option_data.SetInt32(value.value.as_int);
       break;
     }
+    case PP_TCPSOCKET_OPTION_ADDRESS_REUSE: {
+      if (version_ != TCP_SOCKET_VERSION_1_1_OR_ABOVE)
+        return PP_ERROR_NOTSUPPORTED;
+      if (state_.state() != TCPSocketState::INITIAL)
+        return PP_ERROR_FAILED;
+
+      if (value.type != PP_VARTYPE_BOOL)
+        return PP_ERROR_BADARGUMENT;
+      option_data.SetBool(PP_ToBool(value.value.as_bool));
+      break;
+    }
     default: {
       NOTREACHED();
       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)));
   return PP_OK_COMPLETIONPENDING;
 }
 
-bool TCPSocketResourceBase::IsConnected() const {
-  return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
-}
-
 void TCPSocketResourceBase::PostAbortIfNecessary(
     scoped_refptr<TrackedCallback>* callback) {
   if (TrackedCallback::IsPending(*callback))
     (*callback)->PostAbort();
 }
 
+void TCPSocketResourceBase::OnPluginMsgBindReply(
+    const ResourceMessageReplyParams& params,
+    const PP_NetAddress_Private& local_addr) {
+  // It is possible that CloseImpl() has been called. We don't want to update
+  // class members in this case.
+  if (!state_.IsPending(TCPSocketState::BIND))
+    return;
+
+  DCHECK(TrackedCallback::IsPending(bind_callback_));
+  if (params.result() == PP_OK) {
+    local_addr_ = local_addr;
+    state_.CompletePendingTransition(true);
+  } else {
+    state_.CompletePendingTransition(false);
+  }
+  RunCallback(bind_callback_, params.result());
+}
+
 void TCPSocketResourceBase::OnPluginMsgConnectReply(
     const ResourceMessageReplyParams& params,
     const PP_NetAddress_Private& local_addr,
     const PP_NetAddress_Private& remote_addr) {
-  // It is possible that |connect_callback_| is pending while
-  // |connection_state_| is not BEFORE_CONNECT: DisconnectImpl() has been
-  // called, but a ConnectCompleted notification came earlier than the task to
-  // abort |connect_callback_|. We don't want to update |connection_state_| or
-  // other members in that case.
-  if (connection_state_ != BEFORE_CONNECT ||
-      !TrackedCallback::IsPending(connect_callback_)) {
+  // It is possible that CloseImpl() has been called. We don't want to update
+  // class members in this case.
+  if (!state_.IsPending(TCPSocketState::CONNECT))
     return;
-  }
 
+  DCHECK(TrackedCallback::IsPending(connect_callback_));
   if (params.result() == PP_OK) {
     local_addr_ = local_addr;
     remote_addr_ = remote_addr;
-    connection_state_ = CONNECTED;
+    state_.CompletePendingTransition(true);
+  } else {
+    if (version_ == TCP_SOCKET_VERSION_1_1_OR_ABOVE) {
+      state_.CompletePendingTransition(false);
+    } else {
+      // In order to maintain backward compatibility, allow to connect the
+      // socket again.
+      state_ = TCPSocketState(TCPSocketState::INITIAL);
+    }
   }
   RunCallback(connect_callback_, params.result());
 }
 
 void TCPSocketResourceBase::OnPluginMsgSSLHandshakeReply(
       const ResourceMessageReplyParams& params,
       const PPB_X509Certificate_Fields& certificate_fields) {
-  // It is possible that |ssl_handshake_callback_| is pending while
-  // |connection_state_| is not CONNECT: DisconnectImpl() has been
-  // called, but a SSLHandshakeCompleted notification came earlier than the task
-  // to abort |ssl_handshake_callback_|. We don't want to update
-  // |connection_state_| or other members in that case.
-  if (connection_state_ != CONNECTED ||
-      !TrackedCallback::IsPending(ssl_handshake_callback_)) {
+  // It is possible that CloseImpl() has been called. We don't want to
+  // update class members in this case.
+  if (!state_.IsPending(TCPSocketState::SSL_CONNECT))
     return;
-  }
 
+  DCHECK(TrackedCallback::IsPending(ssl_handshake_callback_));
   if (params.result() == PP_OK) {
-    connection_state_ = SSL_CONNECTED;
+    state_.CompletePendingTransition(true);
     server_certificate_ = new PPB_X509Certificate_Private_Shared(
         OBJECT_IS_PROXY,
         pp_instance(),
         certificate_fields);
-    RunCallback(ssl_handshake_callback_, params.result());
   } else {
-    // The resource might be released in the callback so we need to hold
-    // a reference so we can Disconnect() first.
-    AddRef();
-    RunCallback(ssl_handshake_callback_, params.result());
-    DisconnectImpl();
-    Release();
+    state_.CompletePendingTransition(false);
   }
+  RunCallback(ssl_handshake_callback_, params.result());
 }
 
 void TCPSocketResourceBase::OnPluginMsgReadReply(
     const ResourceMessageReplyParams& params,
     const std::string& data) {
-  // It is possible that |read_callback_| is pending while |read_buffer_| is
-  // NULL: DisconnectImpl() has been called, but a ReadCompleted notification
-  // came earlier than the task to abort |read_callback_|. We shouldn't access
-  // the buffer in that case. The user may have released it.
-  if (!TrackedCallback::IsPending(read_callback_) || !read_buffer_)
+  // It is possible that CloseImpl() has been called. We shouldn't access the
+  // buffer in that case. The user may have released it.
+  if (!state_.IsConnected() || !TrackedCallback::IsPending(read_callback_) ||
+      !read_buffer_) {
     return;
+  }
 
   const bool succeeded = params.result() == PP_OK;
   if (succeeded) {
     CHECK_LE(static_cast<int32_t>(data.size()), bytes_to_read_);
     if (!data.empty())
       memmove(read_buffer_, data.c_str(), data.size());
   }
   read_buffer_ = NULL;
   bytes_to_read_ = -1;
 
-  read_callback_->Run(succeeded ?
-                      static_cast<int32_t>(data.size()) :
-                      ConvertNetworkAPIErrorForCompatibility(params.result(),
-                                                             private_api_));
+  RunCallback(read_callback_,
+              succeeded ? static_cast<int32_t>(data.size()) : params.result());
 }
 
 void TCPSocketResourceBase::OnPluginMsgWriteReply(
     const ResourceMessageReplyParams& params) {
-  if (!TrackedCallback::IsPending(write_callback_))
+  if (!state_.IsConnected() || !TrackedCallback::IsPending(write_callback_))
     return;
   RunCallback(write_callback_, params.result());
 }
 
+void TCPSocketResourceBase::OnPluginMsgListenReply(
+    const ResourceMessageReplyParams& params) {
+  if (!state_.IsPending(TCPSocketState::LISTEN))
+    return;
+
+  DCHECK(TrackedCallback::IsPending(listen_callback_));
+  state_.CompletePendingTransition(params.result() == PP_OK);
+
+  RunCallback(listen_callback_, params.result());
+}
+
+void TCPSocketResourceBase::OnPluginMsgAcceptReply(
+    const ResourceMessageReplyParams& params,
+    int pending_host_id,
+    const PP_NetAddress_Private& local_addr,
+    const PP_NetAddress_Private& remote_addr) {
+  // It is possible that CloseImpl() has been called. We shouldn't access the
+  // output parameter in that case. The user may have released it.
+  if (state_.state() != TCPSocketState::LISTENING ||
+      !TrackedCallback::IsPending(accept_callback_) || !accepted_tcp_socket_) {
+    return;
+  }
+
+  if (params.result() == PP_OK) {
+    *accepted_tcp_socket_ = CreateAcceptedSocket(pending_host_id, local_addr,
+                                                 remote_addr);
+  }
+  accepted_tcp_socket_ = NULL;
+  RunCallback(accept_callback_, params.result());
+}
+
 void TCPSocketResourceBase::OnPluginMsgSetOptionReply(
     const ResourceMessageReplyParams& params) {
   if (set_option_callbacks_.empty()) {
     NOTREACHED();
     return;
   }
   scoped_refptr<TrackedCallback> callback = set_option_callbacks_.front();
   set_option_callbacks_.pop();
   if (TrackedCallback::IsPending(callback))
     RunCallback(callback, params.result());
 }
 
 void TCPSocketResourceBase::RunCallback(scoped_refptr<TrackedCallback> callback,
                                         int32_t pp_result) {
-  callback->Run(ConvertNetworkAPIErrorForCompatibility(pp_result,
-                                                       private_api_));
+  callback->Run(ConvertNetworkAPIErrorForCompatibility(
+      pp_result, version_ == TCP_SOCKET_VERSION_PRIVATE));
 }
 
 }  // namespace ppapi
 }  // namespace proxy