net: merge two versions of SetTCPNoDelay() function into one

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.h"
 #include "net/socket/tcp_socket_win.h"
 
 #include <errno.h>
 #include <mstcpip.h>
 
@@ skipping 31 matching lines @@
 
 int SetSocketSendBufferSize(SOCKET socket, int32_t size) {
   int rv = setsockopt(socket, SOL_SOCKET, SO_SNDBUF,
                       reinterpret_cast<const char*>(&size), sizeof(size));
   int net_error = (rv == 0) ? OK : MapSystemError(WSAGetLastError());
   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
-// partial packets may be sent back to back.  For a browser, it is NEVER
-// a benefit to delay for an RTT before the second packet is sent.
-//
-// As a practical example in Chromium today, consider the case of a small
-// POST.  I have verified this:
-//     Client writes 649 bytes of header  (partial packet #1)
-//     Client writes 50 bytes of POST data (partial packet #2)
-// In the above example, with Nagle, a RTT delay is inserted between these
-// two sends due to nagle.  RTTs can easily be 100ms or more.  The best
-// fix is to make sure that for POSTing data, we write as much data as
-// possible and minimize partial packets.  We will fix that.  But disabling
-// Nagle also ensure we don't run into this delay in other edge cases.
-// See also:
-//    http://technet.microsoft.com/en-us/library/bb726981.aspx
-bool DisableNagle(SOCKET socket, bool disable) {
-  BOOL val = disable ? TRUE : FALSE;
-  int rv = setsockopt(socket, IPPROTO_TCP, TCP_NODELAY,
-                      reinterpret_cast<const char*>(&val),
-                      sizeof(val));
-  DCHECK(!rv) << "Could not disable nagle";
-  return rv == 0;
-}
-
 // Enable TCP Keep-Alive to prevent NAT routers from timing out TCP
 // connections. See http://crbug.com/27400 for details.
 bool SetTCPKeepAlive(SOCKET socket, BOOL enable, int delay_secs) {
   unsigned delay = delay_secs * 1000;
   struct tcp_keepalive keepalive_vals = {
       enable ? 1u : 0u,  // TCP keep-alive on.
       delay,  // Delay seconds before sending first TCP keep-alive packet.
       delay,  // Delay seconds between sending TCP keep-alive packets.
   };
   DWORD bytes_returned = 0xABAB;
@@ skipping 480 matching lines @@
     return ERR_SOCKET_NOT_CONNECTED;
   *address = *peer_address_;
   return OK;
 }
 
 int TCPSocketWin::SetDefaultOptionsForServer() {
   return SetExclusiveAddrUse();
 }
 
 void TCPSocketWin::SetDefaultOptionsForClient() {
-  DisableNagle(socket_, true);
+  SetTCPNoDelay(socket_, /*no_delay=*/true);
   SetTCPKeepAlive(socket_, true, kTCPKeepAliveSeconds);
 }
 
 int TCPSocketWin::SetExclusiveAddrUse() {
   // On Windows, a bound end point can be hijacked by another process by
   // setting SO_REUSEADDR. Therefore a Windows-only option SO_EXCLUSIVEADDRUSE
   // was introduced in Windows NT 4.0 SP4. If the socket that is bound to the
   // end point has SO_EXCLUSIVEADDRUSE enabled, it is not possible for another
   // socket to forcibly bind to the end point until the end point is unbound.
   // It is recommend that all server applications must use SO_EXCLUSIVEADDRUSE.
@@ skipping 24 matching lines @@
 int TCPSocketWin::SetSendBufferSize(int32_t 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);
+  return SetTCPNoDelay(socket_, no_delay);
 }
 
 void TCPSocketWin::Close() {
   DCHECK(CalledOnValidThread());
 
   if (socket_ != INVALID_SOCKET) {
     // Only log the close event if there's actually a socket to close.
     net_log_.AddEvent(NetLog::EventType::TYPE_SOCKET_CLOSED);
 
     // Note: don't use CancelIo to cancel pending IO because it doesn't work
@@ skipping 396 matching lines @@
 }
 
 bool TCPSocketWin::GetEstimatedRoundTripTime(base::TimeDelta* out_rtt) const {
   DCHECK(out_rtt);
   // TODO(bmcquade): Consider implementing using
   // GetPerTcpConnectionEStats/GetPerTcp6ConnectionEStats.
   return false;
 }
 
 }  // namespace net