Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

net/socket/tcp_client_socket_libevent.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_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <netinet/tcp.h>
 
 #include "base/eintr_wrapper.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/trace_event.h"
 #include "net/base/io_buffer.h"
-#include "net/base/load_log.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_log.h"
 #if defined(USE_SYSTEM_LIBEVENT)
 #include <event.h>
 #else
 #include "third_party/libevent/event.h"
 #endif
 
 namespace net {
 
 namespace {
 
@@ skipping 101 matching lines @@
       write_watcher_(this),
       read_callback_(NULL),
       write_callback_(NULL) {
 }
 
 TCPClientSocketLibevent::~TCPClientSocketLibevent() {
   Disconnect();
 }
 
 int TCPClientSocketLibevent::Connect(CompletionCallback* callback,
-                                     LoadLog* load_log) {
+                                     const BoundNetLog& net_log) {
   // If already connected, then just return OK.
   if (socket_ != kInvalidSocket)
     return OK;
 
   DCHECK(!waiting_connect_);
-  DCHECK(!load_log_);
+  DCHECK(!net_log_.net_log());
 
   TRACE_EVENT_BEGIN("socket.connect", this, "");
 
-  LoadLog::BeginEvent(load_log, LoadLog::TYPE_TCP_CONNECT);
+  net_log.BeginEvent(NetLog::TYPE_TCP_CONNECT);
 
   int rv = DoConnect();
 
   if (rv == ERR_IO_PENDING) {
     // Synchronous operation not supported.
     DCHECK(callback);
 
-    load_log_ = load_log;
+    net_log_ = net_log;
     waiting_connect_ = true;
     write_callback_ = callback;
   } else {
     TRACE_EVENT_END("socket.connect", this, "");
-    LoadLog::EndEvent(load_log, LoadLog::TYPE_TCP_CONNECT);
+    net_log.EndEvent(NetLog::TYPE_TCP_CONNECT);
   }
 
   return rv;
 }
 
 int TCPClientSocketLibevent::DoConnect() {
   while (true) {
     DCHECK(current_ai_);
 
     int rv = CreateSocket(current_ai_);
@@ skipping 221 matching lines @@
     os_error = errno;
 
   if (os_error == EINPROGRESS || os_error == EALREADY) {
     NOTREACHED();  // This indicates a bug in libevent or our code.
     result = ERR_IO_PENDING;
   } else if (current_ai_->ai_next && ShouldTryNextAddress(os_error)) {
     // This address failed, try next one in list.
     const addrinfo* next = current_ai_->ai_next;
     Disconnect();
     current_ai_ = next;
-    scoped_refptr<LoadLog> load_log;
-    load_log.swap(load_log_);
+    BoundNetLog net_log = net_log_;
+    net_log_ = BoundNetLog();
     TRACE_EVENT_END("socket.connect", this, "");
-    LoadLog::EndEvent(load_log, LoadLog::TYPE_TCP_CONNECT);
-    result = Connect(write_callback_, load_log);
+    net_log.EndEvent(NetLog::TYPE_TCP_CONNECT);
+    result = Connect(write_callback_, net_log);
   } else {
     result = MapConnectError(os_error);
     bool ok = write_socket_watcher_.StopWatchingFileDescriptor();
     DCHECK(ok);
     waiting_connect_ = false;
     TRACE_EVENT_END("socket.connect", this, "");
-    LoadLog::EndEvent(load_log_, LoadLog::TYPE_TCP_CONNECT);
-    load_log_ = NULL;
+    net_log_.EndEvent(NetLog::TYPE_TCP_CONNECT);
+    net_log_ = BoundNetLog();
   }
 
   if (result != ERR_IO_PENDING) {
     DoWriteCallback(result);
   }
 }
 
 void TCPClientSocketLibevent::DidCompleteRead() {
   int bytes_transferred;
   bytes_transferred = HANDLE_EINTR(read(socket_, read_buf_->data(),
@@ skipping 41 matching lines @@
 
 int TCPClientSocketLibevent::GetPeerAddress(AddressList* address) const {
   DCHECK(address);
   if (!current_ai_)
     return ERR_UNEXPECTED;
   address->Copy(current_ai_, false);
   return OK;
 }
 
 }  // namespace net