Remove timing limitation of SetOption invocation for PPAPI sockets.

ppapi/proxy/udp_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/udp_socket_resource_base.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/logging.h"
@@ skipping 16 matching lines @@
     1024 * UDPSocketResourceBase::kMaxWriteSize;
 const int32_t UDPSocketResourceBase::kMaxReceiveBufferSize =
     1024 * UDPSocketResourceBase::kMaxReadSize;
 const size_t UDPSocketResourceBase::kPluginReceiveBufferSlots = 32u;
 
 UDPSocketResourceBase::UDPSocketResourceBase(Connection connection,
                                              PP_Instance instance,
                                              bool private_api)
     : PluginResource(connection, instance),
       private_api_(private_api),
+      bind_called_(false),
       bound_(false),
       closed_(false),
       read_buffer_(NULL),
       bytes_to_read_(-1),
       recvfrom_addr_resource_(NULL) {
   recvfrom_addr_.size = 0;
   memset(recvfrom_addr_.data, 0,
          arraysize(recvfrom_addr_.data) * sizeof(*recvfrom_addr_.data));
   bound_addr_.size = 0;
   memset(bound_addr_.data, 0,
          arraysize(bound_addr_.data) * sizeof(*bound_addr_.data));
 
   if (private_api)
     SendCreate(BROWSER, PpapiHostMsg_UDPSocket_CreatePrivate());
   else
     SendCreate(BROWSER, PpapiHostMsg_UDPSocket_Create());
 
   PluginGlobals::Get()->resource_reply_thread_registrar()->HandleOnIOThread(
       PpapiPluginMsg_UDPSocket_PushRecvResult::ID);
 }
 
 UDPSocketResourceBase::~UDPSocketResourceBase() {
 }
 
 int32_t UDPSocketResourceBase::SetOptionImpl(
     PP_UDPSocket_Option name,
     const PP_Var& value,
+    bool check_bind_state,
     scoped_refptr<TrackedCallback> callback) {
   if (closed_)
     return PP_ERROR_FAILED;
 
   SocketOptionData option_data;
   switch (name) {
     case PP_UDPSOCKET_OPTION_ADDRESS_REUSE:

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

In the UDP IDL file, the documentation doesn't say ADDRESS_REUSE can be set
after Bind() in version 1.1, but here it appears to not cause an error.

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

First, I thought it was not necessary, because message filter rejects it.
However, I was wrong, and I should return an error here to provide stable
behavior, because the message filter's behavior depends on the Bind() result.

     case PP_UDPSOCKET_OPTION_BROADCAST: {
-      if (bound_)
+      if (check_bind_state && bind_called_)

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

You should add a comment about *why* you use bind_called_ here instead of
bound_.

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

Done.

         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_UDPSOCKET_OPTION_SEND_BUFFER_SIZE:
     case PP_UDPSOCKET_OPTION_RECV_BUFFER_SIZE: {
-      if (!bound_)
+      if (check_bind_state && !bound_)
         return PP_ERROR_FAILED;
       if (value.type != PP_VARTYPE_INT32)
         return PP_ERROR_BADARGUMENT;
       option_data.SetInt32(value.value.as_int);
       break;
     }
     default: {
       NOTREACHED();
       return PP_ERROR_BADARGUMENT;
     }
@@ skipping 12 matching lines @@
 int32_t UDPSocketResourceBase::BindImpl(
     const PP_NetAddress_Private* addr,
     scoped_refptr<TrackedCallback> callback) {
   if (!addr)
     return PP_ERROR_BADARGUMENT;
   if (bound_ || closed_)
     return PP_ERROR_FAILED;
   if (TrackedCallback::IsPending(bind_callback_))
     return PP_ERROR_INPROGRESS;
 
+  bind_called_ = true;
   bind_callback_ = callback;
 
   // Send the request, the browser will call us back via BindReply.
   Call<PpapiPluginMsg_UDPSocket_BindReply>(
       BROWSER,
       PpapiHostMsg_UDPSocket_Bind(*addr),
       base::Bind(&UDPSocketResourceBase::OnPluginMsgBindReply,
                  base::Unretained(this)),
       callback);
   return PP_OK_COMPLETIONPENDING;
@@ skipping 220 matching lines @@
   if (result == PP_OK && !data.empty())
     memcpy(output_buffer, data.c_str(), data.size());
 
   recvfrom_addr_ = addr;
 
   return result == PP_OK ? static_cast<int32_t>(data.size()) : result;
 }
 
 }  // namespace proxy
 }  // namespace ppapi