Remove timing limitation of SetOption invocation for PPAPI sockets.

content/browser/renderer_host/pepper/pepper_udp_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_udp_socket_message_filter.h"
 
 #include <cstring>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "content/browser/renderer_host/pepper/browser_ppapi_host_impl.h"
 #include "content/browser/renderer_host/pepper/pepper_socket_utils.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/socket_permission_request.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
-#include "net/udp/udp_server_socket.h"
+#include "net/base/rand_callback.h"
+#include "net/udp/udp_socket.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/private/ppb_net_address_private.h"
 #include "ppapi/host/dispatch_host_message.h"
 #include "ppapi/host/error_conversion.h"
 #include "ppapi/host/host_message_context.h"
 #include "ppapi/host/ppapi_host.h"
 #include "ppapi/host/resource_host.h"
 #include "ppapi/proxy/ppapi_messages.h"
 #include "ppapi/proxy/udp_socket_resource_base.h"
 #include "ppapi/shared_impl/private/net_address_private_impl.h"
 #include "ppapi/shared_impl/socket_option_data.h"
 
 using ppapi::NetAddressPrivateImpl;
 using ppapi::host::NetErrorToPepperError;
 
 namespace {
 
 size_t g_num_instances = 0;
 
 }  // namespace
 
 namespace content {
 
 PepperUDPSocketMessageFilter::PepperUDPSocketMessageFilter(
     BrowserPpapiHostImpl* host,
     PP_Instance instance,
     bool private_api)
-    : allow_address_reuse_(false),
-      allow_broadcast_(false),
+    : socket_options_(0),
+      rcvbuf_size_(0),
+      sndbuf_size_(0),
       closed_(false),
       remaining_recv_slots_(
           ppapi::proxy::UDPSocketResourceBase::kPluginReceiveBufferSlots),
       external_plugin_(host->external_plugin()),
       private_api_(private_api),
       render_process_id_(0),
       render_frame_id_(0) {
   ++g_num_instances;
   DCHECK(host);
 
@@ skipping 48 matching lines @@
 int32_t PepperUDPSocketMessageFilter::OnMsgSetOption(
     const ppapi::host::HostMessageContext* context,
     PP_UDPSocket_Option name,
     const ppapi::SocketOptionData& value) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (closed_)
     return PP_ERROR_FAILED;
 
   switch (name) {
-    case PP_UDPSOCKET_OPTION_ADDRESS_REUSE:
-    case PP_UDPSOCKET_OPTION_BROADCAST: {
+    case PP_UDPSOCKET_OPTION_ADDRESS_REUSE: {
       if (socket_.get()) {
-        // They only take effect before the socket is bound.
+        // AllowReuseAddress is only effective before Bind().
+        // Note that this limitation originally comes from Windows, but
+        // PPAPI tries to provide platform independent APIs.
         return PP_ERROR_FAILED;
       }
 
       bool boolean_value = false;
       if (!value.GetBool(&boolean_value))
         return PP_ERROR_BADARGUMENT;
 
-      if (name == PP_UDPSOCKET_OPTION_ADDRESS_REUSE)
-        allow_address_reuse_ = boolean_value;
-      else
-        allow_broadcast_ = boolean_value;
+      if (boolean_value) {
+        socket_options_ |= SOCKET_OPTION_ADDRESS_REUSE;
+      } else {
+        socket_options_ &= ~SOCKET_OPTION_ADDRESS_REUSE;
+      }
       return PP_OK;
     }
-    case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
-    case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
-      if (!socket_.get()) {
-        // They only take effect after the socket is bound.
-        return PP_ERROR_FAILED;
-      }
-      int32_t integer_value = 0;
-      if (!value.GetInt32(&integer_value) || integer_value <= 0)
+    case PP_UDPSOCKET_OPTION_BROADCAST: {
+      bool boolean_value = false;
+      if (!value.GetBool(&boolean_value))
         return PP_ERROR_BADARGUMENT;
 
-      int net_result = net::ERR_UNEXPECTED;
-      if (name == PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE) {
-        if (integer_value >
-            ppapi::proxy::UDPSocketResourceBase::kMaxSendBufferSize) {
-          return PP_ERROR_BADARGUMENT;
-        }
-        net_result = socket_->SetSendBufferSize(integer_value);
+      // If the socket is already connected, proxy the value to TCPSocket.
+      if (socket_.get())
+        return NetErrorToPepperError(socket_->SetBroadcast(boolean_value));
+
+      // UDPSocket instance is not yet created, so remember the value here.
+      if (boolean_value) {
+        socket_options_ |= SOCKET_OPTION_BROADCAST;
       } else {
-        if (integer_value >
-            ppapi::proxy::UDPSocketResourceBase::kMaxReceiveBufferSize) {
-          return PP_ERROR_BADARGUMENT;
-        }
-        net_result = socket_->SetReceiveBufferSize(integer_value);
+        socket_options_ &= ~SOCKET_OPTION_BROADCAST;
       }
-      // TODO(wtc): Add error mapping code.
-      return (net_result == net::OK) ? PP_OK : PP_ERROR_FAILED;
+      return PP_OK;
+    }
+    case PP_UDPSOCKET_OPTION_SEND_BUFFER_SIZE: {
+      int32_t integer_value = 0;
+      if (!value.GetInt32(&integer_value) ||
+          integer_value <= 0 ||
+          integer_value >
+              ppapi::proxy::UDPSocketResourceBase::kMaxSendBufferSize)
+        return PP_ERROR_BADARGUMENT;
+
+      // If the socket is already connected, proxy the value to UDPSocket.
+      if (socket_.get()) {
+        return NetErrorToPepperError(
+            socket_->SetSendBufferSize(integer_value));
+      }
+
+      // UDPSocket 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_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
+      int32_t integer_value = 0;
+      if (!value.GetInt32(&integer_value) ||
+          integer_value <= 0 ||
+          integer_value >
+              ppapi::proxy::UDPSocketResourceBase::kMaxReceiveBufferSize)
+        return PP_ERROR_BADARGUMENT;
+
+      // If the socket is already connected, proxy the value to UDPSocket.
+      if (socket_.get()) {
+        return NetErrorToPepperError(
+            socket_->SetReceiveBufferSize(integer_value));
+      }
+
+      // UDPSocket 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;
     }
   }
 }
 
 int32_t PepperUDPSocketMessageFilter::OnMsgBind(
     const ppapi::host::HostMessageContext* context,
@@ skipping 76 matching lines @@
 void PepperUDPSocketMessageFilter::DoBind(
     const ppapi::host::ReplyMessageContext& context,
     const PP_NetAddress_Private& addr) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (closed_ || socket_.get()) {
     SendBindError(context, PP_ERROR_FAILED);
     return;
   }
 
-  scoped_ptr<net::UDPServerSocket> socket(
-      new net::UDPServerSocket(NULL, net::NetLog::Source()));
+  scoped_ptr<net::UDPSocket> socket(new net::UDPSocket(
+      net::DatagramSocket::DEFAULT_BIND, net::RandIntCallback(),
+      NULL, net::NetLog::Source()));
 
   net::IPAddressNumber address;
   uint16 port;
   if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
     SendBindError(context, PP_ERROR_ADDRESS_INVALID);
     return;
   }
+  net::IPEndPoint end_point(address, port);
+  {
+    int net_result = socket->Open(end_point.GetFamily());
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
 
-  if (allow_address_reuse_)
-    socket->AllowAddressReuse();
-  if (allow_broadcast_)
-    socket->AllowBroadcast();
+  if (socket_options_ & SOCKET_OPTION_ADDRESS_REUSE) {
+    int net_result = socket->AllowAddressReuse();
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
+  if (socket_options_ & SOCKET_OPTION_BROADCAST) {
+    int net_result = socket->SetBroadcast(true);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
+  if (socket_options_ & SOCKET_OPTION_SNDBUF_SIZE) {
+    int net_result = socket->SetSendBufferSize(sndbuf_size_);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
+  if (socket_options_ & SOCKET_OPTION_RCVBUF_SIZE) {
+    int net_result = socket->SetReceiveBufferSize(rcvbuf_size_);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
+  }
 
-  int32_t pp_result =
-      NetErrorToPepperError(socket->Listen(net::IPEndPoint(address, port)));
-  if (pp_result != PP_OK) {
-    SendBindError(context, pp_result);
-    return;
+  {
+    int net_result = socket->Bind(end_point);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
   }
 
   net::IPEndPoint bound_address;
-  pp_result = NetErrorToPepperError(socket->GetLocalAddress(&bound_address));
-  if (pp_result != PP_OK) {
-    SendBindError(context, pp_result);
-    return;
+  {
+    int net_result = socket->GetLocalAddress(&bound_address);
+    if (net_result != net::OK) {
+      SendBindError(context, NetErrorToPepperError(net_result));
+      return;
+    }
   }
 
   PP_NetAddress_Private net_address = NetAddressPrivateImpl::kInvalidNetAddress;
   if (!NetAddressPrivateImpl::IPEndPointToNetAddress(
           bound_address.address(), bound_address.port(), &net_address)) {
     SendBindError(context, PP_ERROR_ADDRESS_INVALID);
     return;
   }
 
-  allow_address_reuse_ = false;
-  allow_broadcast_ = false;
   socket_.swap(socket);
   SendBindReply(context, PP_OK, net_address);
 
   DoRecvFrom();
 }
 
 void PepperUDPSocketMessageFilter::DoRecvFrom() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!closed_);
   DCHECK(socket_.get());
@@ skipping 161 matching lines @@
                      NetAddressPrivateImpl::kInvalidNetAddress);
 }
 
 void PepperUDPSocketMessageFilter::SendSendToError(
     const ppapi::host::ReplyMessageContext& context,
     int32_t result) {
   SendSendToReply(context, result, 0);
 }
 
 }  // namespace content