Revert of 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() {
-  SetTCPNoDelay(socket_, /*no_delay=*/true);
+  DisableNagle(socket_, 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 SetTCPNoDelay(socket_, no_delay);
+  return DisableNagle(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