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

net/http/http_network_transaction.h

 // Copyright (c) 2006-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.
 
 #ifndef NET_HTTP_HTTP_NETWORK_TRANSACTION_H_
 #define NET_HTTP_HTTP_NETWORK_TRANSACTION_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "net/base/address_list.h"
 #include "net/base/host_resolver.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_flags.h"
 #include "net/base/load_states.h"
+#include "net/base/net_log.h"
 #include "net/base/ssl_config_service.h"
 #include "net/http/http_alternate_protocols.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_handler.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/client_socket_pool.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
@@ skipping 14 matching lines @@
   // Sets the next protocol negotiation value used during the SSL handshake.
   static void SetNextProtos(const std::string& next_protos);
 
   // Sets the HttpNetworkTransaction into a mode where it can ignore
   // certificate errors.  This is for testing.
   static void IgnoreCertificateErrors(bool enabled);
 
   // HttpTransaction methods:
   virtual int Start(const HttpRequestInfo* request_info,
                     CompletionCallback* callback,
-                    LoadLog* load_log);
+                    const BoundNetLog& net_log);
   virtual int RestartIgnoringLastError(CompletionCallback* callback);
   virtual int RestartWithCertificate(X509Certificate* client_cert,
                                      CompletionCallback* callback);
   virtual int RestartWithAuth(const std::wstring& username,
                               const std::wstring& password,
                               CompletionCallback* callback);
   virtual bool IsReadyToRestartForAuth() {
     return pending_auth_target_ != HttpAuth::AUTH_NONE &&
         HaveAuth(pending_auth_target_);
   }
@@ skipping 224 matching lines @@
   // Whether this transaction is waiting for proxy auth, server auth, or is
   // not waiting for any auth at all. |pending_auth_target_| is read and
   // cleared by RestartWithAuth().
   HttpAuth::Target pending_auth_target_;
 
   CompletionCallbackImpl<HttpNetworkTransaction> io_callback_;
   CompletionCallback* user_callback_;
 
   scoped_refptr<HttpNetworkSession> session_;
 
-  scoped_refptr<LoadLog> load_log_;
+  BoundNetLog net_log_;
   const HttpRequestInfo* request_;
   HttpResponseInfo response_;
 
   ProxyService::PacRequest* pac_request_;
   ProxyInfo proxy_info_;
 
   scoped_ptr<ClientSocketHandle> connection_;
   scoped_ptr<HttpStream> http_stream_;
   scoped_refptr<SpdyStream> spdy_stream_;
   bool reused_socket_;
@@ skipping 13 matching lines @@
   // request/response to reuse the STATE_SEND_REQUEST,
   // STATE_SEND_REQUEST_COMPLETE, STATE_READ_HEADERS, and
   // STATE_READ_HEADERS_COMPLETE states and allows us to tell them apart from
   // the real request/response of the transaction.
   bool establishing_tunnel_;
 
   // True if this network transaction is using SPDY instead of HTTP.
   bool using_spdy_;
 
   AlternateProtocolMode alternate_protocol_mode_;
-  
+
   // Only valid if |alternate_protocol_mode_| == kUsingAlternateProtocol.
   HttpAlternateProtocols::Protocol alternate_protocol_;
 
   // True if we've used the username/password embedded in the URL.  This
   // makes sure we use the embedded identity only once for the transaction,
   // preventing an infinite auth restart loop.
   bool embedded_identity_used_;
 
   SSLConfig ssl_config_;
 
@@ skipping 14 matching lines @@
   // The time the DoSSLConnect() method was called (if it got called).
   base::TimeTicks ssl_connect_start_time_;
 
   // The next state in the state machine.
   State next_state_;
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_NETWORK_TRANSACTION_H_