Remove timing limitation of SetOption invocation for PPAPI sockets.

content/browser/renderer_host/pepper/pepper_tcp_socket_message_filter.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 "content/browser/renderer_host/pepper/pepper_tcp_socket_message_filter.h"
 
 #include <cstring>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 45 matching lines @@
     : version_(version),
       external_plugin_(host->external_plugin()),
       render_process_id_(0),
       render_frame_id_(0),
       ppapi_host_(host->GetPpapiHost()),
       factory_(factory),
       instance_(instance),
       state_(TCPSocketState::INITIAL),
       end_of_file_reached_(false),
       bind_input_addr_(NetAddressPrivateImpl::kInvalidNetAddress),
+      socket_options_(SOCKET_OPTION_NODELAY),

[bbudge, 2014/12/09 18:37:37]

Even though not strictly necessary in this case, we generally initialize all
fields, so initialize rcvbuf_size and sndbuf_size here.
Here and below.

[hidehiko, 2014/12/09 19:51:42]

Done.

       address_index_(0),
       socket_(new net::TCPSocket(NULL, net::NetLog::Source())),
       ssl_context_helper_(host->ssl_context_helper()),
       pending_accept_(false) {
   DCHECK(host);
   ++g_num_instances;
   if (!host->GetRenderFrameIDsForInstance(
           instance, &render_process_id_, &render_frame_id_)) {
     NOTREACHED();
   }
 }
 
 PepperTCPSocketMessageFilter::PepperTCPSocketMessageFilter(
     BrowserPpapiHostImpl* host,
     PP_Instance instance,
     TCPSocketVersion version,
     scoped_ptr<net::TCPSocket> socket)
     : version_(version),
       external_plugin_(host->external_plugin()),
       render_process_id_(0),
       render_frame_id_(0),
       ppapi_host_(host->GetPpapiHost()),
       factory_(NULL),
       instance_(instance),
       state_(TCPSocketState::CONNECTED),
       end_of_file_reached_(false),
       bind_input_addr_(NetAddressPrivateImpl::kInvalidNetAddress),
+      socket_options_(SOCKET_OPTION_NODELAY),
       address_index_(0),
       socket_(socket.Pass()),
       ssl_context_helper_(host->ssl_context_helper()),
       pending_accept_(false) {
   DCHECK(host);
   DCHECK_NE(version, ppapi::TCP_SOCKET_VERSION_1_0);
 
   ++g_num_instances;
   if (!host->GetRenderFrameIDsForInstance(
           instance, &render_process_id_, &render_frame_id_)) {
@@ skipping 346 matching lines @@
 }
 
 int32_t PepperTCPSocketMessageFilter::OnMsgSetOption(
     const ppapi::host::HostMessageContext* context,
     PP_TCPSocket_Option name,
     const ppapi::SocketOptionData& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   switch (name) {
     case PP_TCPSOCKET_OPTION_NO_DELAY: {
-      if (state_.state() != TCPSocketState::CONNECTED)
-        return PP_ERROR_FAILED;
-
       bool boolean_value = false;
       if (!value.GetBool(&boolean_value))
         return PP_ERROR_BADARGUMENT;
-      return socket_->SetNoDelay(boolean_value) ? PP_OK : PP_ERROR_FAILED;
+
+      // If the socket is already connected, proxy the value to TCPSocket.
+      if (state_.state() == TCPSocketState::CONNECTED)
+        return socket_->SetNoDelay(boolean_value) ? PP_OK : PP_ERROR_FAILED;
+
+      // TCPSocket instance is not yet created. So remember the value here.
+      if (boolean_value) {
+        socket_options_ |= SOCKET_OPTION_NODELAY;
+      } else {
+        socket_options_ &= ~SOCKET_OPTION_NODELAY;
+      }
+      return PP_OK;
     }
-    case PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE:
-    case PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE: {
-      if (state_.state() != TCPSocketState::CONNECTED)
-        return PP_ERROR_FAILED;
-
+    case PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE: {
       int32_t integer_value = 0;
-      if (!value.GetInt32(&integer_value) || integer_value <= 0)
+      if (!value.GetInt32(&integer_value) ||
+          integer_value <= 0 ||
+          integer_value > TCPSocketResourceBase::kMaxSendBufferSize)
         return PP_ERROR_BADARGUMENT;
 
-      int net_result = net::ERR_UNEXPECTED;
-      if (name == PP_TCPSOCKET_OPTION_SEND_BUFFER_SIZE) {
-        if (integer_value > TCPSocketResourceBase::kMaxSendBufferSize)
-          return PP_ERROR_BADARGUMENT;
-        net_result = socket_->SetSendBufferSize(integer_value);
-      } else {
-        if (integer_value > TCPSocketResourceBase::kMaxReceiveBufferSize)
-          return PP_ERROR_BADARGUMENT;
-        net_result = socket_->SetReceiveBufferSize(integer_value);
+      // If the socket is already connected, proxy the value to TCPSocket.
+      if (state_.state() == TCPSocketState::CONNECTED) {
+        return NetErrorToPepperError(
+            socket_->SetSendBufferSize(integer_value));
       }
-      // TODO(wtc): Add error mapping code.
-      return (net_result == net::OK) ? PP_OK : PP_ERROR_FAILED;
+
+      // TCPSocket instance is not yet created. So remember the value here.
+      socket_options_ |= SOCKET_OPTION_SNDBUF_SIZE;
+      sndbuf_size_ = integer_value;
+      return PP_OK;
+    }
+    case PP_TCPSOCKET_OPTION_RECV_BUFFER_SIZE: {
+      int32_t integer_value = 0;
+      if (!value.GetInt32(&integer_value) ||
+          integer_value <= 0 ||
+          integer_value > TCPSocketResourceBase::kMaxReceiveBufferSize)
+        return PP_ERROR_BADARGUMENT;
+
+      // If the socket is already connected, proxy the value to TCPSocket.
+      if (state_.state() == TCPSocketState::CONNECTED) {
+        return NetErrorToPepperError(
+            socket_->SetReceiveBufferSize(integer_value));
+      }
+
+      // TCPSocket instance is not yet created. So remember the value here.
+      socket_options_ |= SOCKET_OPTION_RCVBUF_SIZE;
+      rcvbuf_size_ = integer_value;
+      return PP_OK;
     }
     default: {
       NOTREACHED();
       return PP_ERROR_BADARGUMENT;
     }
   }
 }
 
 void PepperTCPSocketMessageFilter::DoBind(
     const ppapi::host::ReplyMessageContext& context,
@@ skipping 185 matching lines @@
 
   StartConnect(context);
 }
 
 void PepperTCPSocketMessageFilter::StartConnect(
     const ppapi::host::ReplyMessageContext& context) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(state_.IsPending(TCPSocketState::CONNECT));
   DCHECK_LT(address_index_, address_list_.size());
 
-  int net_result = net::OK;
-  if (!socket_->IsValid())
-    net_result = socket_->Open(address_list_[address_index_].GetFamily());
+  if (!socket_->IsValid()) {
+    int net_result = socket_->Open(address_list_[address_index_].GetFamily());
+    if (net_result != net::OK) {
+      OnConnectCompleted(context, net_result);
+      return;
+    }
+  }
 
-  if (net_result == net::OK) {
-    net_result = socket_->Connect(
-        address_list_[address_index_],
-        base::Bind(&PepperTCPSocketMessageFilter::OnConnectCompleted,
-                   base::Unretained(this),
-                   context));
+  socket_->SetDefaultOptionsForClient();
+
+  if (!(socket_options_ & SOCKET_OPTION_NODELAY)) {
+    if (!socket_->SetNoDelay(false)) {
+      OnConnectCompleted(context, net::ERR_FAILED);
+      return;
+    }
   }
+  if (socket_options_ & SOCKET_OPTION_RCVBUF_SIZE) {
+    int net_result = socket_->SetReceiveBufferSize(rcvbuf_size_);
+    if (net_result != net::OK) {
+      OnConnectCompleted(context, net_result);
+      return;
+    }
+  }
+  if (socket_options_ & SOCKET_OPTION_SNDBUF_SIZE) {
+    int net_result = socket_->SetSendBufferSize(sndbuf_size_);
+    if (net_result != net::OK) {
+      OnConnectCompleted(context, net_result);
+      return;
+    }
+  }
+
+  int net_result = socket_->Connect(
+      address_list_[address_index_],
+      base::Bind(&PepperTCPSocketMessageFilter::OnConnectCompleted,
+                 base::Unretained(this),
+                 context));
   if (net_result != net::ERR_IO_PENDING)
     OnConnectCompleted(context, net_result);
 }
 
 void PepperTCPSocketMessageFilter::OnConnectCompleted(
     const ppapi::host::ReplyMessageContext& context,
     int net_result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (!state_.IsPending(TCPSocketState::CONNECT)) {
@@ skipping 27 matching lines @@
             ip_end_point_local.port(),
             &local_addr) ||
         !NetAddressPrivateImpl::IPEndPointToNetAddress(
             ip_end_point_remote.address(),
             ip_end_point_remote.port(),
             &remote_addr)) {
       pp_result = PP_ERROR_ADDRESS_INVALID;
       break;
     }
 
-    socket_->SetDefaultOptionsForClient();
     SendConnectReply(context, PP_OK, local_addr, remote_addr);
     state_.CompletePendingTransition(true);
     return;
   } while (false);
 
   if (version_ == ppapi::TCP_SOCKET_VERSION_1_1_OR_ABOVE) {
     DCHECK_EQ(1u, address_list_.size());
 
     SendConnectError(context, pp_result);
     state_.CompletePendingTransition(false);
@@ skipping 231 matching lines @@
     const ppapi::host::ReplyMessageContext& context,
     int32_t pp_error) {
   SendAcceptReply(context,
                   pp_error,
                   0,
                   NetAddressPrivateImpl::kInvalidNetAddress,
                   NetAddressPrivateImpl::kInvalidNetAddress);
 }
 
 }  // namespace content