make SetReceiveBufferSize and SetSendBufferSize return net error codes (instead of bools)

net/socket/tcp_socket_win.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 "net/socket/tcp_socket_win.h"
 
 #include <mstcpip.h>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 #include "net/base/winsock_util.h"
 #include "net/socket/socket_descriptor.h"
 #include "net/socket/socket_net_log_params.h"
 
 namespace net {
 
 namespace {
 
 const int kTCPKeepAliveSeconds = 45;
 
-bool SetSocketReceiveBufferSize(SOCKET socket, int32 size) {
+int SetSocketReceiveBufferSize(SOCKET socket, int32 size) {
   int rv = setsockopt(socket, SOL_SOCKET, SO_RCVBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
-  DCHECK(!rv) << "Could not set socket receive buffer size: " << GetLastError();
-  return rv == 0;
+  int net_error = (rv == 0) ? OK : MapSystemError(WSAGetLastError());

[Ryan Hamilton, 2014/04/08 19:55:11]

Possibly again here with the map error code.

[jar (doing other things), 2014/04/08 23:16:26]

Since I'm not seeing any problems on Windows... I'll assume they are
compliant... and can use this simpler/standard code.

+  DCHECK(!rv) << "Could not set socket receive buffer size: " << net_error;
+  return net_error;
 }
 
-bool SetSocketSendBufferSize(SOCKET socket, int32 size) {
+int SetSocketSendBufferSize(SOCKET socket, int32 size) {
   int rv = setsockopt(socket, SOL_SOCKET, SO_SNDBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
-  DCHECK(!rv) << "Could not set socket send buffer size: " << GetLastError();
-  return rv == 0;
+  int net_error = (rv == 0) ? OK : MapSystemError(WSAGetLastError());

[Ryan Hamilton, 2014/04/08 19:55:11]

we could consider doing the DCHECK here too.

[jar (doing other things), 2014/04/08 23:16:26]

See above.

+  DCHECK(!rv) << "Could not set socket send buffer size: " << net_error;
+  return net_error;
 }
 
 // Disable Nagle.
 // The Nagle implementation on windows is governed by RFC 896.  The idea
 // behind Nagle is to reduce small packets on the network.  When Nagle is
 // enabled, if a partial packet has been sent, the TCP stack will disallow
 // further *partial* packets until an ACK has been received from the other
 // side.  Good applications should always strive to send as much data as
 // possible and avoid partial-packet sends.  However, in most real world
 // applications, there are edge cases where this does not happen, and two
@@ skipping 539 matching lines @@
 
   BOOL true_value = 1;
   int rv = setsockopt(socket_, SOL_SOCKET, SO_EXCLUSIVEADDRUSE,
                       reinterpret_cast<const char*>(&true_value),
                       sizeof(true_value));
   if (rv < 0)
     return MapSystemError(errno);
   return OK;
 }
 
-bool TCPSocketWin::SetReceiveBufferSize(int32 size) {
+int TCPSocketWin::SetReceiveBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
   return SetSocketReceiveBufferSize(socket_, size);
 }
 
-bool TCPSocketWin::SetSendBufferSize(int32 size) {
+int TCPSocketWin::SetSendBufferSize(int32 size) {
   DCHECK(CalledOnValidThread());
   return SetSocketSendBufferSize(socket_, size);
 }
 
 bool TCPSocketWin::SetKeepAlive(bool enable, int delay) {
   return SetTCPKeepAlive(socket_, enable, delay);
 }
 
 bool TCPSocketWin::SetNoDelay(bool no_delay) {
   return DisableNagle(socket_, no_delay);
@@ skipping 374 matching lines @@
   waiting_read_ = false;
   core_->read_iobuffer_ = NULL;
   core_->read_buffer_length_ = 0;
 
   DCHECK_NE(rv, ERR_IO_PENDING);
   base::ResetAndReturn(&read_callback_).Run(rv);
 }
 
 }  // namespace net