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

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/stats_counters.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "net/base/connection_type_histograms.h"
 #include "net/base/load_flags.h"
-#include "net/base/load_log.h"
+#include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/socket/client_socket.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/spdy/spdy_frame_builder.h"
 #include "net/spdy/spdy_protocol.h"
@@ skipping 225 matching lines @@
 
   // This is a newly initialized session that no client should have a handle to
   // yet, so there's no need to start writing data as in OnTCPConnect(), but we
   // should start reading data.
   ReadSocket();
 }
 
 net::Error SpdySession::Connect(const std::string& group_name,
                                 const TCPSocketParams& destination,
                                 RequestPriority priority,
-                                LoadLog* load_log) {
+                                const BoundNetLog& net_log) {
   DCHECK(priority >= SPDY_PRIORITY_HIGHEST && priority <= SPDY_PRIORITY_LOWEST);
 
   // If the connect process is started, let the caller continue.
   if (state_ > IDLE)
     return net::OK;
 
   state_ = CONNECTING;
 
   static StatsCounter spdy_sessions("spdy.sessions");
   spdy_sessions.Increment();
 
   int rv = connection_->Init(group_name, destination, priority,
                              &connect_callback_, session_->tcp_socket_pool(),
-                             load_log);
+                             net_log);
   DCHECK(rv <= 0);
 
   // If the connect is pending, we still return ok.  The APIs enqueue
   // work until after the connect completes asynchronously later.
   if (rv == net::ERR_IO_PENDING)
     return net::OK;
   OnTCPConnect(rv);
   return static_cast<net::Error>(rv);
 }
 
 scoped_refptr<SpdyStream> SpdySession::GetOrCreateStream(
     const HttpRequestInfo& request,
     const UploadDataStream* upload_data,
-    LoadLog* log) {
+    const BoundNetLog& log) {
   const GURL& url = request.url;
   const std::string& path = url.PathForRequest();
 
   scoped_refptr<SpdyStream> stream;
 
   // Check if we have a push stream for this path.
   if (request.method == "GET") {
     stream = GetPushStream(path);
     if (stream) {
       DCHECK(streams_pushed_and_claimed_count_ < streams_pushed_count_);
       streams_pushed_and_claimed_count_++;
       return stream;
     }
   }
 
   // Check if we have a pending push stream for this url.
   PendingStreamMap::iterator it;
   it = pending_streams_.find(path);
   if (it != pending_streams_.end()) {
     DCHECK(!it->second);
     // Server will assign a stream id when the push stream arrives.  Use 0 for
     // now.
-    LoadLog::AddEvent(log, LoadLog::TYPE_SPDY_STREAM_ADOPTED_PUSH_STREAM);
+    log.AddEvent(NetLog::TYPE_SPDY_STREAM_ADOPTED_PUSH_STREAM);
     SpdyStream* stream = new SpdyStream(this, 0, true, log);
     stream->set_path(path);
     it->second = stream;
     return it->second;
   }
 
   const spdy::SpdyStreamId stream_id = GetNewStreamId();
 
   // If we still don't have a stream, activate one now.
   stream = new SpdyStream(this, stream_id, false, log);
@@ skipping 144 matching lines @@
 
   if (use_ssl_) {
     // Add a SSL socket on top of our existing transport socket.
     ClientSocket* socket = connection_->release_socket();
     // TODO(mbelshe): Fix the hostname.  This is BROKEN without having
     //                a real hostname.
     socket = session_->socket_factory()->CreateSSLClientSocket(
         socket, "" /* request_->url.HostNoBrackets() */ , ssl_config_);
     connection_->set_socket(socket);
     is_secure_ = true;
-    // TODO(willchan): Plumb LoadLog into SPDY code.
+    // TODO(willchan): Plumb NetLog into SPDY code.
     int status = connection_->socket()->Connect(&ssl_connect_callback_, NULL);
     if (status != ERR_IO_PENDING)
       OnSSLConnect(status);
   } else {
     DCHECK_EQ(state_, CONNECTING);
     state_ = CONNECTED;
 
     // Make sure we get any pending data sent.
     WriteSocketLater();
     // Start reading
@@ skipping 400 matching lines @@
   if (it != pending_streams_.end()) {
     stream = it->second;
     pending_streams_.erase(it);
   }
 
   if (stream) {
     CHECK(stream->pushed());
     CHECK_EQ(0u, stream->stream_id());
     stream->set_stream_id(stream_id);
   } else {
-    // TODO(mbelshe): can we figure out how to use a LoadLog here?
+    // TODO(mbelshe): can we figure out how to use a NetLog here?
     stream = new SpdyStream(this, stream_id, true, NULL);
 
     // A new HttpResponseInfo object needs to be generated so the call to
     // OnResponseReceived below has something to fill in.
     // When a SpdyNetworkTransaction is created for this resource, the
     // response_info is copied over and this version is destroyed.
     //
     // TODO(cbentzel): Minimize allocations and copies of HttpResponseInfo
     // object. Should it just be part of SpdyStream?
     HttpResponseInfo* response_info = new HttpResponseInfo();
@@ skipping 144 matching lines @@
 
   // TODO(willchan): Cancel any streams that are past the GoAway frame's
   // |last_accepted_stream_id|.
 
   // Don't bother killing any streams that are still reading.  They'll either
   // complete successfully or get an ERR_CONNECTION_CLOSED when the socket is
   // closed.
 }
 
 }  // namespace net