Add methods for setting socket buffers to the Socket

net/socket/tcp_client_socket_win.cc

 // Copyright (c) 2006-2008 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_client_socket_win.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory_debug.h"
+#include "base/stats_counters.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/trace_event.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/winsock_init.h"
 
 namespace net {
 
 namespace {
@@ skipping 212 matching lines @@
 
 TCPClientSocketWin::~TCPClientSocketWin() {
   Disconnect();
 }
 
 int TCPClientSocketWin::Connect(CompletionCallback* callback) {
   // If already connected, then just return OK.
   if (socket_ != INVALID_SOCKET)
     return OK;
 
+  static StatsCounter connects("tcp.connect");
+  connects.Increment();
+
   TRACE_EVENT_BEGIN("socket.connect", this, "");
   const struct addrinfo* ai = current_ai_;
   DCHECK(ai);
 
   int rv = CreateSocket(ai);
   if (rv != OK)
     return rv;
 
   DCHECK(!core_);
   core_ = new Core(this);
@@ skipping 127 matching lines @@
     if (ResetEventIfSignaled(core_->read_overlapped_.hEvent)) {
       TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", num));
 
       // Because of how WSARecv fills memory when used asynchronously, Purify
       // isn't able to detect that it's been initialized, so it scans for 0xcd
       // in the buffer and reports UMRs (uninitialized memory reads) for those
       // individual bytes. We override that in PURIFY builds to avoid the
       // false error reports.
       // See bug 5297.
       base::MemoryDebug::MarkAsInitialized(core_->read_buffer_.buf, num);
+      static StatsCounter read_bytes("tcp.read_bytes");
+      read_bytes.Add(num);
       return static_cast<int>(num);
     }
   } else {
     int err = WSAGetLastError();
     if (err != WSA_IO_PENDING)
       return MapWinsockError(err);
   }
   core_->WatchForRead();
   waiting_read_ = true;
   read_callback_ = callback;
   core_->read_iobuffer_ = buf;
   return ERR_IO_PENDING;
 }
 
 int TCPClientSocketWin::Write(IOBuffer* buf,
                               int buf_len,
                               CompletionCallback* callback) {
   DCHECK_NE(socket_, INVALID_SOCKET);
   DCHECK(!waiting_write_);
   DCHECK(!write_callback_);
   DCHECK_GT(buf_len, 0);
   DCHECK(!core_->write_iobuffer_);
 
+  static StatsCounter reads("tcp.writes");
+  reads.Increment();
+
   core_->write_buffer_.len = buf_len;
   core_->write_buffer_.buf = buf->data();
 
   TRACE_EVENT_BEGIN("socket.write", this, "");
   // TODO(wtc): Remove the CHECK after enough testing.
   CHECK(
       WaitForSingleObject(core_->write_overlapped_.hEvent, 0) == WAIT_TIMEOUT);
   DWORD num;
   int rv = WSASend(socket_, &core_->write_buffer_, 1, &num, 0,
                    &core_->write_overlapped_, NULL);
   if (rv == 0) {
     if (ResetEventIfSignaled(core_->write_overlapped_.hEvent)) {
       TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", num));
+      static StatsCounter write_bytes("tcp.write_bytes");
+      write_bytes.Add(num);
       return static_cast<int>(num);
     }
   } else {
     int err = WSAGetLastError();
     if (err != WSA_IO_PENDING)
       return MapWinsockError(err);
   }
   core_->WatchForWrite();
   waiting_write_ = true;
   write_callback_ = callback;
   core_->write_iobuffer_ = buf;
   return ERR_IO_PENDING;
 }
 
+bool TCPClientSocketWin::SetReceiveBufferSize(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;
+}
+
+bool TCPClientSocketWin::SetSendBufferSize(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 TCPClientSocketWin::CreateSocket(const struct addrinfo* ai) {
   socket_ = WSASocket(ai->ai_family, ai->ai_socktype, ai->ai_protocol, NULL, 0,
                       WSA_FLAG_OVERLAPPED);
   if (socket_ == INVALID_SOCKET) {
     DWORD err = WSAGetLastError();
     LOG(ERROR) << "WSASocket failed: " << err;
     return MapWinsockError(err);
   }
 
   // Increase the socket buffer sizes from the default sizes for WinXP.  In
   // performance testing, there is substantial benefit by increasing from 8KB
   // to 64KB.
   // See also:
   //    http://support.microsoft.com/kb/823764/EN-US
   // On Vista, if we manually set these sizes, Vista turns off its receive
   // window auto-tuning feature.
   //    http://blogs.msdn.com/wndp/archive/2006/05/05/Winhec-blog-tcpip-2.aspx
   // Since Vista's auto-tune is better than any static value we can could set,
   // only change these on pre-vista machines.
   int32 major_version, minor_version, fix_version;
   base::SysInfo::OperatingSystemVersionNumbers(&major_version, &minor_version,
     &fix_version);
   if (major_version < 6) {
-    const int kSocketBufferSize = 64 * 1024;
-    int rv = setsockopt(socket_, SOL_SOCKET, SO_SNDBUF,
-        reinterpret_cast<const char*>(&kSocketBufferSize),
-        sizeof(kSocketBufferSize));
-    DCHECK(!rv) << "Could not set socket send buffer size";
-    rv = setsockopt(socket_, SOL_SOCKET, SO_RCVBUF,
-        reinterpret_cast<const char*>(&kSocketBufferSize),
-        sizeof(kSocketBufferSize));
-    DCHECK(!rv) << "Could not set socket receive buffer size";
+    const int32 kSocketBufferSize = 64 * 1024;
+    SetReceiveBufferSize(kSocketBufferSize);
+    SetSendBufferSize(kSocketBufferSize);
   }
 
   // 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 16 matching lines @@
       reinterpret_cast<const char*>(&kDisableNagle), sizeof(kDisableNagle));
   DCHECK(!rv) << "Could not disable nagle";
 
   return OK;
 }
 
 void TCPClientSocketWin::DoReadCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
   DCHECK(read_callback_);
 
+  static StatsCounter read_bytes("tcp.read_bytes");
+  read_bytes.Add(rv);
+
   // since Run may result in Read being called, clear read_callback_ up front.
   CompletionCallback* c = read_callback_;
   read_callback_ = NULL;
   c->Run(rv);
 }
 
 void TCPClientSocketWin::DoWriteCallback(int rv) {
   DCHECK_NE(rv, ERR_IO_PENDING);
   DCHECK(write_callback_);
 
+  static StatsCounter write_bytes("tcp.write_bytes");
+  write_bytes.Add(rv);
+
   // since Run may result in Write being called, clear write_callback_ up front.
   CompletionCallback* c = write_callback_;
   write_callback_ = NULL;
   c->Run(rv);
 }
 
 void TCPClientSocketWin::DidCompleteConnect() {
   DCHECK(waiting_connect_);
   int result;
 
@@ skipping 51 matching lines @@
   BOOL ok = WSAGetOverlappedResult(socket_, &core_->write_overlapped_,
                                    &num_bytes, FALSE, &flags);
   WSAResetEvent(core_->write_overlapped_.hEvent);
   TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", num_bytes));
   waiting_write_ = false;
   core_->write_iobuffer_ = NULL;
   DoWriteCallback(ok ? num_bytes : MapWinsockError(WSAGetLastError()));
 }
 
 }  // namespace net