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

net/spdy/spdy_stream.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_stream.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_info.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 SpdyStream::SpdyStream(SpdySession* session, spdy::SpdyStreamId stream_id,
-                       bool pushed, LoadLog* log)
+                       bool pushed, const BoundNetLog& log)
     : stream_id_(stream_id),
       priority_(0),
       pushed_(pushed),
       download_finished_(false),
       metrics_(Singleton<BandwidthMetrics>::get()),
       session_(session),
       response_(NULL),
       request_body_stream_(NULL),
       response_complete_(false),
       io_state_(STATE_NONE),
       response_status_(OK),
       user_callback_(NULL),
       user_buffer_(NULL),
       user_buffer_len_(0),
       cancelled_(false),
-      load_log_(log),
+      net_log_(log),
       send_bytes_(0),
       recv_bytes_(0),
       histograms_recorded_(false),
       buffered_read_callback_pending_(false),
       more_read_data_pending_(false) {}
 
 SpdyStream::~SpdyStream() {
   DLOG(INFO) << "Deleting SpdyStream for stream " << stream_id_;
 
   // TODO(willchan): We're still calling CancelStream() too many times, because
@@ skipping 228 matching lines @@
 }
 
 int SpdyStream::DoLoop(int result) {
   do {
     State state = io_state_;
     io_state_ = STATE_NONE;
     switch (state) {
       // State machine 1: Send headers and wait for response headers.
       case STATE_SEND_HEADERS:
         CHECK_EQ(OK, result);
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_STREAM_SEND_HEADERS);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_STREAM_SEND_HEADERS);
         result = DoSendHeaders();
         break;
       case STATE_SEND_HEADERS_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_STREAM_SEND_HEADERS);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_STREAM_SEND_HEADERS);
         result = DoSendHeadersComplete(result);
         break;
       case STATE_SEND_BODY:
         CHECK_EQ(OK, result);
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_STREAM_SEND_BODY);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_STREAM_SEND_BODY);
         result = DoSendBody();
         break;
       case STATE_SEND_BODY_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_STREAM_SEND_BODY);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_STREAM_SEND_BODY);
         result = DoSendBodyComplete(result);
         break;
       case STATE_READ_HEADERS:
         CHECK_EQ(OK, result);
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_STREAM_READ_HEADERS);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_STREAM_READ_HEADERS);
         result = DoReadHeaders();
         break;
       case STATE_READ_HEADERS_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_STREAM_READ_HEADERS);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_STREAM_READ_HEADERS);
         result = DoReadHeadersComplete(result);
         break;
 
       // State machine 2: Read body.
       // NOTE(willchan): Currently unused.  Currently we handle this stuff in
       // the OnDataReceived()/OnClose()/ReadResponseHeaders()/etc.  Only reason
       // to do this is for consistency with the Http code.
       case STATE_READ_BODY:
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_STREAM_READ_BODY);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_STREAM_READ_BODY);
         result = DoReadBody();
         break;
       case STATE_READ_BODY_COMPLETE:
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_STREAM_READ_BODY);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_STREAM_READ_BODY);
         result = DoReadBodyComplete(result);
         break;
       case STATE_DONE:
         DCHECK(result != ERR_IO_PENDING);
         break;
       default:
         NOTREACHED();
         break;
     }
   } while (result != ERR_IO_PENDING && io_state_ != STATE_NONE);
@@ skipping 164 matching lines @@
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamDownloadTime",
       recv_last_byte_time_ - recv_first_byte_time_);
   UMA_HISTOGRAM_TIMES("Net.SpdyStreamTime",
       recv_last_byte_time_ - send_time_);
 
   UMA_HISTOGRAM_COUNTS("Net.SpdySendBytes", send_bytes_);
   UMA_HISTOGRAM_COUNTS("Net.SpdyRecvBytes", recv_bytes_);
 }
 
 }  // namespace net