Add net log entries that summarize transmit and receive byte counts.

net/socket/tcp_client_socket_win.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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"
@@ skipping 253 matching lines @@
     HANDLE object) {
   DCHECK_EQ(object, core_->write_overlapped_.hEvent);
   if (core_->socket_)
     core_->socket_->DidCompleteWrite();
 
   core_->Release();
 }
 
 //-----------------------------------------------------------------------------
 
-TCPClientSocketWin::TCPClientSocketWin(const AddressList& addresses)
+TCPClientSocketWin::TCPClientSocketWin(const AddressList& addresses,
+                                       net::NetLog* net_log)
     : socket_(INVALID_SOCKET),
       addresses_(addresses),
       current_ai_(addresses_.head()),
       waiting_connect_(false),
       waiting_read_(false),
       waiting_write_(false),
       read_callback_(NULL),
-      write_callback_(NULL) {
+      write_callback_(NULL),
+      net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
   EnsureWinsockInit();
 }
 
 TCPClientSocketWin::~TCPClientSocketWin() {
   Disconnect();
+  net_log_.AddEvent(NetLog::TYPE_TCP_SOCKET_DONE);
 }
 
-int TCPClientSocketWin::Connect(CompletionCallback* callback,
-                                const BoundNetLog& net_log) {
+int TCPClientSocketWin::Connect(CompletionCallback* callback) {
   // If already connected, then just return OK.
   if (socket_ != INVALID_SOCKET)
     return OK;
 
-  DCHECK(!net_log_.net_log());
-
   static StatsCounter connects("tcp.connect");
   connects.Increment();
 
   TRACE_EVENT_BEGIN("socket.connect", this, "");
 
-  net_log.BeginEvent(NetLog::TYPE_TCP_CONNECT);
+  net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT);
 
   int rv = DoConnect();
 
   if (rv == ERR_IO_PENDING) {
     // Synchronous operation not supported.
     DCHECK(callback);
 
-    net_log_ = net_log;
     waiting_connect_ = true;
     read_callback_ = callback;
   } else {
     TRACE_EVENT_END("socket.connect", this, "");
-    net_log.EndEvent(NetLog::TYPE_TCP_CONNECT);
+    net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
     if (rv == OK)
       UpdateConnectionTypeHistograms(CONNECTION_ANY);
   }
 
   return rv;
 }
 
 int TCPClientSocketWin::DoConnect() {
   const struct addrinfo* ai = current_ai_;
   DCHECK(ai);
@@ skipping 143 matching lines @@
 
       // 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);
+      net_log_.AddEventWithInteger(NetLog::TYPE_SOCKET_BYTES_RECEIVED, num);
       return static_cast<int>(num);
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING)
       return MapWinsockError(os_error);
   }
   core_->WatchForRead();
   waiting_read_ = true;
   read_callback_ = callback;
@@ skipping 30 matching lines @@
       if (rv > buf_len || rv < 0) {
         // It seems that some winsock interceptors report that more was written
         // than was available. Treat this as an error.  http://crbug.com/27870
         LOG(ERROR) << "Detected broken LSP: Asked to write " << buf_len
                    << " bytes, but " << rv << " bytes reported.";
         return ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES;
       }
       TRACE_EVENT_END("socket.write", this, StringPrintf("%d bytes", rv));
       static StatsCounter write_bytes("tcp.write_bytes");
       write_bytes.Add(rv);
+      net_log_.AddEventWithInteger(NetLog::TYPE_SOCKET_BYTES_SENT, rv);
       return rv;
     }
   } else {
     int os_error = WSAGetLastError();
     if (os_error != WSA_IO_PENDING)
       return MapWinsockError(os_error);
   }
   core_->WatchForWrite();
   waiting_write_ = true;
   write_callback_ = callback;
@@ skipping 111 matching lines @@
   if (rv == SOCKET_ERROR) {
     NOTREACHED();
     result = MapWinsockError(WSAGetLastError());
   } else if (events.lNetworkEvents & FD_CONNECT) {
     int os_error = events.iErrorCode[FD_CONNECT_BIT];
     if (current_ai_->ai_next && ShouldTryNextAddress(os_error)) {
       // Try using the next address.
       const struct addrinfo* next = current_ai_->ai_next;
       Disconnect();
       current_ai_ = next;
-      BoundNetLog net_log(net_log_);
-      net_log_ = BoundNetLog();
       TRACE_EVENT_END("socket.connect", this, "");
-      net_log.EndEvent(NetLog::TYPE_TCP_CONNECT);
-      result = Connect(read_callback_, net_log);
+      net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
+      result = Connect(read_callback_);
     } else {
       result = MapConnectError(os_error);
       TRACE_EVENT_END("socket.connect", this, "");
       net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
-      net_log_ = BoundNetLog();
     }
   } else {
     NOTREACHED();
     result = ERR_UNEXPECTED;
     TRACE_EVENT_END("socket.connect", this, "");
     net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
-    net_log_ = BoundNetLog();
   }
 
   if (result != ERR_IO_PENDING) {
     if (result == OK)
       UpdateConnectionTypeHistograms(CONNECTION_ANY);
     DoReadCallback(result);
   }
 }
 
 void TCPClientSocketWin::DidCompleteRead() {
   DCHECK(waiting_read_);
   DWORD num_bytes, flags;
   BOOL ok = WSAGetOverlappedResult(socket_, &core_->read_overlapped_,
                                    &num_bytes, FALSE, &flags);
   WSAResetEvent(core_->read_overlapped_.hEvent);
   TRACE_EVENT_END("socket.read", this, StringPrintf("%d bytes", num_bytes));
   waiting_read_ = false;
   core_->read_iobuffer_ = NULL;
+  if (ok)
+    net_log_.AddEventWithInteger(NetLog::TYPE_SOCKET_BYTES_RECEIVED, num_bytes);
   DoReadCallback(ok ? num_bytes : MapWinsockError(WSAGetLastError()));
 }
 
 void TCPClientSocketWin::DidCompleteWrite() {
   DCHECK(waiting_write_);
 
   DWORD num_bytes, flags;
   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;
   int rv;
   if (!ok) {
     rv = MapWinsockError(WSAGetLastError());
   } else {
     rv = static_cast<int>(num_bytes);
     if (rv > core_->write_buffer_length_ || rv < 0) {
       // It seems that some winsock interceptors report that more was written
       // than was available. Treat this as an error.  http://crbug.com/27870
       LOG(ERROR) << "Detected broken LSP: Asked to write "
                  << core_->write_buffer_length_ << " bytes, but " << rv
                  << " bytes reported.";
       rv = ERR_WINSOCK_UNEXPECTED_WRITTEN_BYTES;
+    } else {
+      net_log_.AddEventWithInteger(NetLog::TYPE_SOCKET_BYTES_SENT, rv);
     }
   }
   core_->write_iobuffer_ = NULL;
   DoWriteCallback(rv);
 }
 
 }  // namespace net