Remove timing limitation of SetOption invocation for PPAPI sockets.

net/udp/udp_socket_libevent.cc

 // Copyright (c) 2012 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 "net/udp/udp_socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <net/if.h>
@@ skipping 299 matching lines @@
   if (rv < 0) {
     Close();
     return rv;
   }
   local_address_.reset();
   return rv;
 }
 
 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());
-
-  socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
+  if (!is_connected()) {
+    socket_options_ |= SOCKET_OPTION_REUSE_ADDRESS;
+    return OK;
+  }
+  return SetAddressReuseInternal(true);
 }
 
-void UDPSocketLibevent::AllowBroadcast() {
+int UDPSocketLibevent::DisallowAddressReuse() {
   DCHECK(CalledOnValidThread());
-  DCHECK(!is_connected());
+  if (!is_connected()) {
+    socket_options_ &= ~SOCKET_OPTION_REUSE_ADDRESS;
+    return OK;
+  }
+  return SetAddressReuseInternal(false);
+}
 
-  socket_options_ |= SOCKET_OPTION_BROADCAST;
+int UDPSocketLibevent::AllowBroadcast() {
+  DCHECK(CalledOnValidThread());
+  if (!is_connected()) {
+    socket_options_ |= SOCKET_OPTION_BROADCAST;
+    return OK;
+  }
+  return SetBroadcastInternal(true);
+}
+
+int UDPSocketLibevent::DisallowBroadcast() {
+  DCHECK(CalledOnValidThread());
+  if (!is_connected()) {
+    socket_options_ &= ~SOCKET_OPTION_BROADCAST;
+    return OK;
+  }
+  return SetBroadcastInternal(false);
 }
 
 void UDPSocketLibevent::ReadWatcher::OnFileCanReadWithoutBlocking(int) {
   if (!socket_->read_callback_.is_null())
     socket_->DidCompleteRead();
 }
 
 void UDPSocketLibevent::WriteWatcher::OnFileCanWriteWithoutBlocking(int) {
   if (!socket_->write_callback_.is_null())
     socket_->DidCompleteWrite();
@@ skipping 151 matching lines @@
                             addr,
                             storage.addr_len));
   if (result < 0)
     result = MapSystemError(errno);
   if (result != ERR_IO_PENDING)
     LogWrite(result, buf->data(), address);
   return result;
 }
 
 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) {
       u_char loop = 0;
       rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_LOOP,
                       &loop, sizeof(loop));
     } else {
       u_int loop = 0;
       rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
                       &loop, sizeof(loop));
     }
     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) {
       u_char ttl = multicast_time_to_live_;
       rv = setsockopt(socket_, IPPROTO_IP, IP_MULTICAST_TTL,
                       &ttl, sizeof(ttl));
     } else {
       // Signed integer. -1 to use route default.
       int ttl = multicast_time_to_live_;
       rv = setsockopt(socket_, IPPROTO_IPV6, IPV6_MULTICAST_HOPS,
@@ skipping 32 matching lines @@
         break;
       }
       default:
         NOTREACHED() << "Invalid address family";
         return ERR_ADDRESS_INVALID;
     }
   }
   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))
     return ERR_ADDRESS_INVALID;
   int rv = bind(socket_, storage.addr, storage.addr_len);
   if (rv == 0)
     return OK;
   int last_error = errno;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.UdpSocketBindErrorFromPosix", last_error);
 #if defined(OS_CHROMEOS)
@@ skipping 149 matching lines @@
     return MapSystemError(errno);
 
   return OK;
 }
 
 void UDPSocketLibevent::DetachFromThread() {
   base::NonThreadSafe::DetachFromThread();
 }
 
 }  // namespace net