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

net/spdy/spdy_network_transaction.cc

 // Copyright (c) 2009 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_network_transaction.h"
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/stats_counters.h"
@@ skipping 27 matching lines @@
 }
 
 SpdyNetworkTransaction::~SpdyNetworkTransaction() {
   LOG(INFO) << "SpdyNetworkTransaction dead. " << this;
   if (stream_.get())
     stream_->Cancel();
 }
 
 int SpdyNetworkTransaction::Start(const HttpRequestInfo* request_info,
                                   CompletionCallback* callback,
-                                  LoadLog* load_log) {
+                                  const BoundNetLog& net_log) {
   CHECK(request_info);
   CHECK(callback);
 
   SIMPLE_STATS_COUNTER("SpdyNetworkTransaction.Count");
 
-  load_log_ = load_log;
+  net_log_ = net_log;
   request_ = request_info;
   start_time_ = base::TimeTicks::Now();
 
   next_state_ = STATE_INIT_CONNECTION;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
@@ skipping 87 matching lines @@
   if (!request_)
     return 0;
 
   int rv = result;
   do {
     State state = next_state_;
     next_state_ = STATE_NONE;
     switch (state) {
       case STATE_INIT_CONNECTION:
         DCHECK_EQ(OK, rv);
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION);
         rv = DoInitConnection();
         break;
       case STATE_INIT_CONNECTION_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_INIT_CONNECTION);
         rv = DoInitConnectionComplete(rv);
         break;
       case STATE_SEND_REQUEST:
         DCHECK_EQ(OK, rv);
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
         rv = DoSendRequest();
         break;
       case STATE_SEND_REQUEST_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
         rv = DoSendRequestComplete(rv);
         break;
       case STATE_READ_HEADERS:
         DCHECK_EQ(OK, rv);
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
         rv = DoReadHeaders();
         break;
       case STATE_READ_HEADERS_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
         rv = DoReadHeadersComplete(rv);
         break;
       case STATE_READ_BODY:
         DCHECK_EQ(OK, rv);
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_TRANSACTION_READ_BODY);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_BODY);
         rv = DoReadBody();
         break;
       case STATE_READ_BODY_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_TRANSACTION_READ_BODY);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_BODY);
         rv = DoReadBodyComplete(rv);
         break;
       case STATE_NONE:
         rv = ERR_FAILED;
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
         break;
     }
@@ skipping 21 matching lines @@
   connection_group.append(host);
 
   TCPSocketParams tcp_params(host, port, request_->priority, request_->referrer,
                              false);
   HostPortPair host_port_pair(host, port);
 
   spdy_ = session_->spdy_session_pool()->Get(host_port_pair, session_);
   DCHECK(spdy_);
 
   return spdy_->Connect(
-      connection_group, tcp_params, request_->priority, load_log_);
+      connection_group, tcp_params, request_->priority, net_log_);
 }
 
 int SpdyNetworkTransaction::DoInitConnectionComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_SEND_REQUEST;
   return OK;
 }
 
 int SpdyNetworkTransaction::DoSendRequest() {
   next_state_ = STATE_SEND_REQUEST_COMPLETE;
   CHECK(!stream_.get());
   UploadDataStream* upload_data = request_->upload_data ?
       new UploadDataStream(request_->upload_data) : NULL;
-  stream_ = spdy_->GetOrCreateStream(*request_, upload_data, load_log_.get());
+  stream_ = spdy_->GetOrCreateStream(*request_, upload_data, net_log_);
   // Release the reference to |spdy_| since we don't need it anymore.
   spdy_ = NULL;
   return stream_->SendRequest(upload_data, &response_, &io_callback_);
 }
 
 int SpdyNetworkTransaction::DoSendRequestComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_READ_HEADERS;
@@ skipping 21 matching lines @@
   user_buffer_ = NULL;
   user_buffer_len_ = 0;
 
   if (result <= 0)
     stream_ = NULL;
 
   return result;
 }
 
 }  // namespace net