More cleanup of net_log.h

net/socket/tcp_client_socket_win.cc

 // 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"
@@ skipping 270 matching lines @@
       waiting_read_(false),
       waiting_write_(false),
       read_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);
+  net_log_.AddEvent(NetLog::TYPE_TCP_SOCKET_DONE, NULL);
 }
 
 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, "");
 
-  net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT);
+  net_log_.BeginEvent(NetLog::TYPE_TCP_CONNECT, NULL);
 
   int rv = DoConnect();
 
   if (rv == ERR_IO_PENDING) {
     // Synchronous operation not supported.
     DCHECK(callback);
 
     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, NULL);
     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_bytes", num);
+      net_log_.AddEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED,
+                        new NetLogIntegerParameter("num_bytes", 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,
-                                   "num_bytes", rv);
+      net_log_.AddEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
+                        new NetLogIntegerParameter("num_bytes", 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 112 matching lines @@
     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;
       TRACE_EVENT_END("socket.connect", this, "");
-      net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
+      net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT, NULL);
       result = Connect(read_callback_);
     } else {
       result = MapConnectError(os_error);
       TRACE_EVENT_END("socket.connect", this, "");
-      net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
+      net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT, NULL);
     }
   } else {
     NOTREACHED();
     result = ERR_UNEXPECTED;
     TRACE_EVENT_END("socket.connect", this, "");
-    net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
+    net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT, NULL);
   }
 
   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", num_bytes);
+    net_log_.AddEvent(NetLog::TYPE_SOCKET_BYTES_RECEIVED,
+                      new NetLogIntegerParameter("num_bytes", 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,
-                                   "num_bytes", rv);
+      net_log_.AddEvent(NetLog::TYPE_SOCKET_BYTES_SENT,
+                        new NetLogIntegerParameter("num_bytes", rv));
     }
   }
   core_->write_iobuffer_ = NULL;
   DoWriteCallback(rv);
 }
 
 }  // namespace net