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

net/http/http_network_transaction.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_network_transaction.h"
 
 #include "base/format_macros.h"
 #include "base/scoped_ptr.h"
 #include "base/compiler_specific.h"
 #include "base/field_trial.h"
@@ skipping 222 matching lines @@
   g_next_protos = new std::string(next_protos);
 }
 
 // static
 void HttpNetworkTransaction::IgnoreCertificateErrors(bool enabled) {
   g_ignore_certificate_errors = enabled;
 }
 
 int HttpNetworkTransaction::Start(const HttpRequestInfo* request_info,
                                   CompletionCallback* callback,
-                                  LoadLog* load_log) {
+                                  const BoundNetLog& net_log) {
   SIMPLE_STATS_COUNTER("HttpNetworkTransaction.Count");
 
-  load_log_ = load_log;
+  net_log_ = net_log;
   request_ = request_info;
   start_time_ = base::Time::Now();
 
   next_state_ = STATE_RESOLVE_PROXY;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     user_callback_ = callback;
   return rv;
 }
 
@@ skipping 278 matching lines @@
         TRACE_EVENT_BEGIN("http.ssl_connect", request_, request_->url.spec());
         rv = DoSSLConnect();
         break;
       case STATE_SSL_CONNECT_COMPLETE:
         rv = DoSSLConnectComplete(rv);
         TRACE_EVENT_END("http.ssl_connect", request_, request_->url.spec());
         break;
       case STATE_SEND_REQUEST:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.send_request", request_, request_->url.spec());
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);
+        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);
         rv = DoSendRequest();
         break;
       case STATE_SEND_REQUEST_COMPLETE:
         rv = DoSendRequestComplete(rv);
         TRACE_EVENT_END("http.send_request", request_, request_->url.spec());
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);
+        net_log_.EndEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST);
         break;
       case STATE_READ_HEADERS:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.read_headers", request_, request_->url.spec());
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);
+        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);
         rv = DoReadHeaders();
         break;
       case STATE_READ_HEADERS_COMPLETE:
         rv = DoReadHeadersComplete(rv);
         TRACE_EVENT_END("http.read_headers", request_, request_->url.spec());
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);
+        net_log_.EndEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS);
         break;
       case STATE_READ_BODY:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.read_body", request_, request_->url.spec());
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_HTTP_TRANSACTION_READ_BODY);
+        net_log_.BeginEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_BODY);
         rv = DoReadBody();
         break;
       case STATE_READ_BODY_COMPLETE:
         rv = DoReadBodyComplete(rv);
         TRACE_EVENT_END("http.read_body", request_, request_->url.spec());
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_HTTP_TRANSACTION_READ_BODY);
+        net_log_.EndEvent(NetLog::TYPE_HTTP_TRANSACTION_READ_BODY);
         break;
       case STATE_DRAIN_BODY_FOR_AUTH_RESTART:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.drain_body_for_auth_restart",
                           request_, request_->url.spec());
-        LoadLog::BeginEvent(
-            load_log_,
-            LoadLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART);
+        net_log_.BeginEvent(
+            NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART);
         rv = DoDrainBodyForAuthRestart();
         break;
       case STATE_DRAIN_BODY_FOR_AUTH_RESTART_COMPLETE:
         rv = DoDrainBodyForAuthRestartComplete(rv);
         TRACE_EVENT_END("http.drain_body_for_auth_restart",
                         request_, request_->url.spec());
-        LoadLog::EndEvent(
-            load_log_,
-            LoadLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART);
+        net_log_.EndEvent(
+            NetLog::TYPE_HTTP_TRANSACTION_DRAIN_BODY_FOR_AUTH_RESTART);
         break;
       case STATE_SPDY_SEND_REQUEST:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.send_request", request_, request_->url.spec());
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
         rv = DoSpdySendRequest();
         break;
       case STATE_SPDY_SEND_REQUEST_COMPLETE:
         rv = DoSpdySendRequestComplete(rv);
         TRACE_EVENT_END("http.send_request", request_, request_->url.spec());
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_SEND_REQUEST);
         break;
       case STATE_SPDY_READ_HEADERS:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.read_headers", request_, request_->url.spec());
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
         rv = DoSpdyReadHeaders();
         break;
       case STATE_SPDY_READ_HEADERS_COMPLETE:
         rv = DoSpdyReadHeadersComplete(rv);
         TRACE_EVENT_END("http.read_headers", request_, request_->url.spec());
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_HEADERS);
         break;
       case STATE_SPDY_READ_BODY:
         DCHECK_EQ(OK, rv);
         TRACE_EVENT_BEGIN("http.read_body", request_, request_->url.spec());
-        LoadLog::BeginEvent(load_log_,
-                            LoadLog::TYPE_SPDY_TRANSACTION_READ_BODY);
+        net_log_.BeginEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_BODY);
         rv = DoSpdyReadBody();
         break;
       case STATE_SPDY_READ_BODY_COMPLETE:
         rv = DoSpdyReadBodyComplete(rv);
         TRACE_EVENT_END("http.read_body", request_, request_->url.spec());
-        LoadLog::EndEvent(load_log_,
-                          LoadLog::TYPE_SPDY_TRANSACTION_READ_BODY);
+        net_log_.EndEvent(NetLog::TYPE_SPDY_TRANSACTION_READ_BODY);
         break;
       default:
         NOTREACHED() << "bad state";
         rv = ERR_FAILED;
         break;
     }
   } while (rv != ERR_IO_PENDING && next_state_ != STATE_NONE);
 
   return rv;
 }
 
 int HttpNetworkTransaction::DoResolveProxy() {
   DCHECK(!pac_request_);
 
   next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
 
   if (request_->load_flags & LOAD_BYPASS_PROXY) {
     proxy_info_.UseDirect();
     return OK;
   }
 
   return session_->proxy_service()->ResolveProxy(
-      request_->url, &proxy_info_, &io_callback_, &pac_request_, load_log_);
+      request_->url, &proxy_info_, &io_callback_, &pac_request_, net_log_);
 }
 
 int HttpNetworkTransaction::DoResolveProxyComplete(int result) {
   pac_request_ = NULL;
 
   if (result != OK)
     return result;
 
   // Remove unsupported proxies from the list.
   proxy_info_.RemoveProxiesWithoutScheme(
@@ skipping 85 matching lines @@
 
   // If the user is refreshing the page, bypass the host cache.
   bool disable_resolver_cache = request_->load_flags & LOAD_BYPASS_CACHE ||
     request_->load_flags & LOAD_DISABLE_CACHE;
 
   TCPSocketParams tcp_params(host, port, request_->priority, request_->referrer,
                              disable_resolver_cache);
 
   int rv = connection_->Init(connection_group, tcp_params, request_->priority,
                              &io_callback_, session_->tcp_socket_pool(),
-                             load_log_);
+                             net_log_);
   return rv;
 }
 
 int HttpNetworkTransaction::DoInitConnectionComplete(int result) {
   if (result < 0) {
     if (alternate_protocol_mode_ == kUsingAlternateProtocol) {
       // Mark the alternate protocol as broken and fallback.
       MarkBrokenAlternateProtocolAndFallback();
       return OK;
     }
@@ skipping 45 matching lines @@
   HostResolver::RequestInfo req_info(request_->url.HostNoBrackets(),
                                      request_->url.EffectiveIntPort());
   req_info.set_referrer(request_->referrer);
   req_info.set_priority(request_->priority);
 
   if (proxy_info_.proxy_server().scheme() == ProxyServer::SCHEME_SOCKS5)
     s = new SOCKS5ClientSocket(s, req_info);
   else
     s = new SOCKSClientSocket(s, req_info, session_->host_resolver());
   connection_->set_socket(s);
-  return connection_->socket()->Connect(&io_callback_, load_log_);
+  return connection_->socket()->Connect(&io_callback_, net_log_);
 }
 
 int HttpNetworkTransaction::DoSOCKSConnectComplete(int result) {
   DCHECK_EQ(kSOCKSProxy, proxy_mode_);
 
   if (result == OK) {
     if (using_ssl_) {
       next_state_ = STATE_SSL_CONNECT;
     } else {
       next_state_ = STATE_SEND_REQUEST;
@@ skipping 10 matching lines @@
   if (request_->load_flags & LOAD_VERIFY_EV_CERT)
     ssl_config_.verify_ev_cert = true;
 
   ssl_connect_start_time_ = base::TimeTicks::Now();
 
   // Add a SSL socket on top of our existing transport socket.
   ClientSocket* s = connection_->release_socket();
   s = session_->socket_factory()->CreateSSLClientSocket(
       s, request_->url.HostNoBrackets(), ssl_config_);
   connection_->set_socket(s);
-  return connection_->socket()->Connect(&io_callback_, load_log_);
+  return connection_->socket()->Connect(&io_callback_, net_log_);
 }
 
 int HttpNetworkTransaction::DoSSLConnectComplete(int result) {
   SSLClientSocket* ssl_socket =
       reinterpret_cast<SSLClientSocket*>(connection_->socket());
 
   SSLClientSocket::NextProtoStatus status =
       SSLClientSocket::kNextProtoUnsupported;
   std::string proto;
   // GetNextProto will fail and and trigger a NOTREACHED if we pass in a socket
@@ skipping 90 matching lines @@
 
     if (establishing_tunnel_) {
       BuildTunnelRequest(request_, authorization_headers, &request_headers_);
     } else {
       BuildRequestHeaders(request_, authorization_headers, request_body,
                           proxy_mode_ == kHTTPProxy, &request_headers_);
     }
   }
 
   headers_valid_ = false;
-  http_stream_.reset(new HttpBasicStream(connection_.get(), load_log_));
+  http_stream_.reset(new HttpBasicStream(connection_.get(), net_log_));
 
   return http_stream_->SendRequest(request_, request_headers_,
                                    request_body, &response_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoSendRequestComplete(int result) {
   if (result < 0)
     return HandleIOError(result);
 
   next_state_ = STATE_READ_HEADERS;
@@ skipping 79 matching lines @@
   if (establishing_tunnel_) {
     switch (response_.headers->response_code()) {
       case 200:  // OK
         if (http_stream_->IsMoreDataBuffered()) {
           // The proxy sent extraneous data after the headers.
           return ERR_TUNNEL_CONNECTION_FAILED;
         }
         next_state_ = STATE_SSL_CONNECT;
         // Reset for the real request and response headers.
         request_headers_.clear();
-        http_stream_.reset(new HttpBasicStream(connection_.get(), load_log_));
+        http_stream_.reset(new HttpBasicStream(connection_.get(), net_log_));
         headers_valid_ = false;
         establishing_tunnel_ = false;
         return OK;
 
       // We aren't able to CONNECT to the remote host through the proxy.  We
       // need to be very suspicious about the response because an active network
       // attacker can force us into this state by masquerading as the proxy.
       // The only safe thing to do here is to fail the connection because our
       // client is expecting an SSL protected response.
       // See http://crbug.com/7338.
@@ skipping 145 matching lines @@
     spdy_session = spdy_pool->GetSpdySessionFromSSLSocket(
         host_port_pair, session_, connection_.release());
   }
 
   CHECK(spdy_session.get());
 
   UploadDataStream* upload_data = request_->upload_data ?
       new UploadDataStream(request_->upload_data) : NULL;
   headers_valid_ = false;
   spdy_stream_ = spdy_session->GetOrCreateStream(
-      *request_, upload_data, load_log_);
+      *request_, upload_data, net_log_);
   return spdy_stream_->SendRequest(upload_data, &response_, &io_callback_);
 }
 
 int HttpNetworkTransaction::DoSpdySendRequestComplete(int result) {
   if (result < 0)
     return result;
 
   next_state_ = STATE_SPDY_READ_HEADERS;
   return OK;
 }
@@ skipping 365 matching lines @@
       return ERR_ADDRESS_UNREACHABLE;
     default:
       return error;
   }
 
   if (request_->load_flags & LOAD_BYPASS_PROXY) {
     return error;
   }
 
   int rv = session_->proxy_service()->ReconsiderProxyAfterError(
-      request_->url, &proxy_info_, &io_callback_, &pac_request_, load_log_);
+      request_->url, &proxy_info_, &io_callback_, &pac_request_, net_log_);
   if (rv == OK || rv == ERR_IO_PENDING) {
     // If the error was during connection setup, there is no socket to
     // disconnect.
     if (connection_->socket())
       connection_->socket()->Disconnect();
     connection_->Reset();
     next_state_ = STATE_RESOLVE_PROXY_COMPLETE;
   } else {
     // If ReconsiderProxyAfterError() failed synchronously, it means
     // there was nothing left to fall-back to, so fail the transaction
@@ skipping 292 matching lines @@
       http_host_port_pair);
 
   alternate_protocol_mode_ = kDoNotUseAlternateProtocol;
   if (connection_->socket())
     connection_->socket()->Disconnect();
   connection_->Reset();
   next_state_ = STATE_INIT_CONNECTION;
 }
 
 }  // namespace net