Remove timing limitation of SetOption invocation for PPAPI sockets.

net/udp/udp_socket_libevent.cc

Index: net/udp/udp_socket_libevent.cc
diff --git a/net/udp/udp_socket_libevent.cc b/net/udp/udp_socket_libevent.cc
index 9b1a9957189d968c3fed617ba02aa3ee7d13cb98..584bb3f6ca20b4e3ba0e182594a570041531ce47 100644
--- a/net/udp/udp_socket_libevent.cc
+++ b/net/udp/udp_socket_libevent.cc
@@ -317,34 +317,58 @@ int UDPSocketLibevent::Bind(const IPEndPoint& address) {
 
 int UDPSocketLibevent::SetReceiveBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
-                      reinterpret_cast<const char*>(&size), sizeof(size));
-  int last_error = errno;
-  DCHECK(!rv) << "Could not set socket receive buffer size: " << last_error;
-  return rv == 0 ? OK : MapSystemError(last_error);
+  if (!is_connected()) {
+    socket_options_ |= SOCKET_OPTION_RCVBUF_SIZE;
+    rcvbuf_size_ = size;
+    return OK;

[mmenke, 2014/10/30 14:40:38]

Sockets can be disconnected and then reconnected, so this is rather weird -
setting buffer size, opening, closing, and then reopening keeps the size, but
opening, setting size, closing, and then reopening does not.

Same goes for pretty much all the changes you've made.

Reusing a socket like that is rather weird, but since we allow it, should have
consistent behaviors when someone does it.

[hidehiko, 2014/11/03 13:34:37]

oops, sorry, I forgot to reply this comment. I made a change for net/... code. I
kept PPAPI related code as is, assuming reusing a closed socket is unexpected
use case.

+  }
+  return SetReceiveBufferSizeInternal(size);
 }
 
 int UDPSocketLibevent::SetSendBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
-  int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
-                      reinterpret_cast<const char*>(&size), sizeof(size));
-  int last_error = errno;
-  DCHECK(!rv) << "Could not set socket send buffer size: " << last_error;
-  return rv == 0 ? OK : MapSystemError(last_error);
+  if (!is_connected()) {
+    socket_options_ |= SOCKET_OPTION_SNDBUF_SIZE;
+    sndbuf_size_ = size;
+    return OK;
+  }
+  return SetSendBufferSizeInternal(size);
 }
 
-void UDPSocketLibevent::AllowAddressReuse() {
+int UDPSocketLibevent::AllowAddressReuse() {
   DCHECK(CalledOnValidThread());
-  DCHECK(!is_connected());
+  if (!is_connected()) {
+    socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
+    return OK;
+  }
+  return SetAddressReuseInternal(true);
+}
 
-  socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
+int UDPSocketLibevent::DisallowAddressReuse() {
+  DCHECK(CalledOnValidThread());
+  if (!is_connected()) {
+    socket_options_ &= ~SOCKET_OPTION_REUSE_ADDRESS;
+    return OK;
+  }
+  return SetAddressReuseInternal(false);
 }
 
-void UDPSocketLibevent::AllowBroadcast() {
+int UDPSocketLibevent::AllowBroadcast() {
   DCHECK(CalledOnValidThread());
-  DCHECK(!is_connected());
+  if (!is_connected()) {
+    socket_options_ |= SOCKET_OPTION_BROADCAST;
+    return OK;
+  }
+  return SetBroadcastInternal(true);
+}
 
-  socket_options_ |= SOCKET_OPTION_BROADCAST;
+int UDPSocketLibevent::DisallowBroadcast() {
+  DCHECK(CalledOnValidThread());
+  if (!is_connected()) {
+    socket_options_ &= ~SOCKET_OPTION_BROADCAST;
+    return OK;
+  }
+  return SetBroadcastInternal(false);
 }
 
 void UDPSocketLibevent::ReadWatcher::OnFileCanReadWithoutBlocking(int) {
@@ -516,29 +540,17 @@ int UDPSocketLibevent::InternalSendTo(IOBuffer* buf, int buf_len,
 }
 
 int UDPSocketLibevent::SetSocketOptions() {
-  int true_value = 1;
+  DCHECK(CalledOnValidThread());
   if (socket_options_ & SOCKET_OPTION_REUSE_ADDRESS) {
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEADDR, &true_value,
-                        sizeof(true_value));
-    if (rv < 0)
-      return MapSystemError(errno);
+    int rv = SetAddressReuseInternal(true);
+    if (rv != OK)
+      return rv;
   }
   if (socket_options_ & SOCKET_OPTION_BROADCAST) {
-    int rv;
-#if defined(OS_MACOSX)
-    // SO_REUSEPORT on OSX permits multiple processes to each receive
-    // UDP multicast or broadcast datagrams destined for the bound
-    // port.
-    rv = setsockopt(socket_, SOL_SOCKET, SO_REUSEPORT, &true_value,
-                    sizeof(true_value));
-#else
-    rv = setsockopt(socket_, SOL_SOCKET, SO_BROADCAST, &true_value,
-                    sizeof(true_value));
-#endif  // defined(OS_MACOSX)
-    if (rv < 0)
-      return MapSystemError(errno);
+    int rv = SetBroadcastInternal(true);
+    if (rv != OK)
+      return rv;
   }
-
   if (!(socket_options_ & SOCKET_OPTION_MULTICAST_LOOP)) {
     int rv;
     if (addr_family_ == AF_INET) {
@@ -553,6 +565,17 @@ int UDPSocketLibevent::SetSocketOptions() {
     if (rv < 0)
       return MapSystemError(errno);
   }
+  if (socket_options_ & SOCKET_OPTION_RCVBUF_SIZE) {
+    int rv = SetReceiveBufferSizeInternal(rcvbuf_size_);
+    if (rv != OK)
+      return rv;
+  }
+  if (socket_options_ & SOCKET_OPTION_SNDBUF_SIZE) {
+    int rv = SetSendBufferSizeInternal(sndbuf_size_);
+    if (rv != OK)
+      return rv;
+  }
+
   if (multicast_time_to_live_ != IP_DEFAULT_MULTICAST_TTL) {
     int rv;
     if (addr_family_ == AF_INET) {
@@ -605,6 +628,52 @@ int UDPSocketLibevent::SetSocketOptions() {
   return OK;
 }
 
+int UDPSocketLibevent::SetAddressReuseInternal(bool value) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(is_connected());
+  int opt_value = value ? 1 : 0;
+  int rv = setsockopt(
+      socket_, SOL_SOCKET, SO_REUSEADDR, &opt_value, sizeof(opt_value));
+  return rv == 0 ? OK : MapSystemError(errno);
+}
+
+int UDPSocketLibevent::SetBroadcastInternal(bool value) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(is_connected());
+  int opt_value = value ? 1 : 0;
+#if defined(OS_MACOSX)
+  // SO_REUSEPORT on OSX permits multiple processes to each receive
+  // UDP multicast or broadcast datagrams destined for the bound
+  // port.
+  const int kOptName = SO_REUSEPORT;
+#else
+  const int kOptName = SO_BROADCAST;
+#endif
+  int rv = setsockopt(
+      socket_, SOL_SOCKET, kOptName, &opt_value, sizeof(opt_value));
+  return rv == 0 ? OK : MapSystemError(errno);
+}
+
+int UDPSocketLibevent::SetReceiveBufferSizeInternal(int32 size) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(is_connected());
+  int rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
+                      reinterpret_cast<const char*>(&size), sizeof(size));
+  int last_error = errno;
+  DCHECK(!rv) << "Could not set socket receive buffer size: " << last_error;
+  return rv == 0 ? OK : MapSystemError(last_error);
+}
+
+int UDPSocketLibevent::SetSendBufferSizeInternal(int32 size) {
+  DCHECK(CalledOnValidThread());
+  DCHECK(is_connected());
+  int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
+                      reinterpret_cast<const char*>(&size), sizeof(size));
+  int last_error = errno;
+  DCHECK(!rv) << "Could not set socket send buffer size: " << last_error;
+  return rv == 0 ? OK : MapSystemError(last_error);
+}
+
 int UDPSocketLibevent::DoBind(const IPEndPoint& address) {
   SockaddrStorage storage;
   if (!address.ToSockAddr(storage.addr, &storage.addr_len))