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

net/http/http_stream_parser.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/http/http_stream_parser.h"
 
 #include "base/compiler_specific.h"
 #include "base/trace_event.h"
 #include "net/base/io_buffer.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 
 namespace net {
 
 HttpStreamParser::HttpStreamParser(ClientSocketHandle* connection,
                                    GrowableIOBuffer* read_buffer,
-                                   LoadLog* load_log)
+                                   const BoundNetLog& net_log)
     : io_state_(STATE_NONE),
       request_(NULL),
       request_headers_(NULL),
       request_body_(NULL),
       read_buf_(read_buffer),
       read_buf_unused_offset_(0),
       response_header_start_offset_(-1),
       response_body_length_(-1),
       response_body_read_(0),
       chunked_decoder_(NULL),
       user_read_buf_(NULL),
       user_read_buf_len_(0),
       user_callback_(NULL),
       connection_(connection),
-      load_log_(load_log),
+      net_log_(net_log),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           io_callback_(this, &HttpStreamParser::OnIOComplete)) {
   DCHECK_EQ(0, read_buffer->offset());
 }
 
 int HttpStreamParser::SendRequest(const HttpRequestInfo* request,
                                   const std::string& headers,
                                   UploadDataStream* request_body,
                                   HttpResponseInfo* response,
                                   CompletionCallback* callback) {
@@ skipping 97 matching lines @@
         else
           result = DoSendBody(result);
         TRACE_EVENT_END("http.write_body", request_, request_->url.spec());
         break;
       case STATE_REQUEST_SENT:
         DCHECK(result != ERR_IO_PENDING);
         can_do_more = false;
         break;
       case STATE_READ_HEADERS:
         TRACE_EVENT_BEGIN("http.read_headers", request_, request_->url.spec());
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS);
+        net_log_.BeginEvent(NetLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS);
         result = DoReadHeaders();
         break;
       case STATE_READ_HEADERS_COMPLETE:
         result = DoReadHeadersComplete(result);
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS);
+        net_log_.EndEvent(NetLog::TYPE_HTTP_STREAM_PARSER_READ_HEADERS);
         TRACE_EVENT_END("http.read_headers", request_, request_->url.spec());
         break;
       case STATE_BODY_PENDING:
         DCHECK(result != ERR_IO_PENDING);
         can_do_more = false;
         break;
       case STATE_READ_BODY:
         TRACE_EVENT_BEGIN("http.read_body", request_, request_->url.spec());
         result = DoReadBody();
         // DoReadBodyComplete handles error conditions.
@@ skipping 364 matching lines @@
 
 bool HttpStreamParser::CanFindEndOfResponse() const {
   return chunked_decoder_.get() || response_body_length_ >= 0;
 }
 
 bool HttpStreamParser::IsMoreDataBuffered() const {
   return read_buf_->offset() > read_buf_unused_offset_;
 }
 
 }  // namespace net