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

net/socket_stream/socket_stream.h

 // 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.
 
 #ifndef NET_SOCKET_STREAM_SOCKET_STREAM_H_
 #define NET_SOCKET_STREAM_SOCKET_STREAM_H_
 
 #include <deque>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/linked_ptr.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
+#include "net/base/net_log.h"
 #include "net/http/http_auth.h"
 #include "net/http/http_auth_cache.h"
 #include "net/http/http_auth_handler.h"
 #include "net/proxy/proxy_service.h"
 #include "net/socket/tcp_client_socket.h"
-#include "net/url_request/request_tracker.h"
 #include "net/url_request/url_request_context.h"
 
 namespace net {
 
 class AuthChallengeInfo;
 class ClientSocketFactory;
 class HostResolver;
 class HttpAuthHandlerFactory;
-class LoadLog;
 class SSLConfigService;
 class SingleRequestHostResolver;
 class SocketStreamMetrics;
 class SocketStreamThrottle;
 
 // SocketStream is used to implement Web Sockets.
 // It provides plain full-duplex stream with proxy and SSL support.
 // For proxy authentication, only basic mechanisum is supported.  It will try
 // authentication identity for proxy URL first.  If server requires proxy
 // authentication, it will try authentication identity for realm that server
@@ skipping 57 matching lines @@
 
   const GURL& url() const { return url_; }
   bool is_secure() const;
   const AddressList& address_list() const { return addresses_; }
   Delegate* delegate() const { return delegate_; }
   int max_pending_send_allowed() const { return max_pending_send_allowed_; }
 
   URLRequestContext* context() const { return context_.get(); }
   void set_context(URLRequestContext* context);
 
-  LoadLog* load_log() const { return load_log_; }
+  BoundNetLog* net_log() { return &net_log_; }
 
   // Opens the connection on the IO thread.
   // Once the connection is established, calls delegate's OnConnected.
   virtual void Connect();
 
   // Requests to send |len| bytes of |data| on the connection.
   // Returns true if |data| is buffered in the job.
   // Returns false if size of buffered data would exceeds
   // |max_pending_send_allowed_| and |data| is not sent at all.
   virtual bool SendData(const char* data, int len);
@@ skipping 77 matching lines @@
     STATE_CLOSE,
   };
 
   enum ProxyMode {
     kDirectConnection,  // If using a direct connection
     kTunnelProxy,  // If using a tunnel (CONNECT method as HTTPS)
     kSOCKSProxy,  // If using a SOCKS proxy
   };
 
   typedef std::deque< scoped_refptr<IOBufferWithSize> > PendingDataQueue;
-  friend class RequestTracker<SocketStream>;
 
   friend class WebSocketThrottleTest;
 
   // Copies the given addrinfo list in |addresses_|.
   // Used for WebSocketThrottleTest.
   void CopyAddrInfo(struct addrinfo* head);
 
   // Finishes the job.
   // Calls OnError and OnClose of delegate, and no more
   // notifications will be sent to delegate.
@@ skipping 28 matching lines @@
   GURL ProxyAuthOrigin() const;
   int HandleAuthChallenge(const HttpResponseHeaders* headers);
   void DoAuthRequired();
   void DoRestartWithAuth();
 
   int HandleCertificateError(int result);
 
   SSLConfigService* ssl_config_service() const;
   ProxyService* proxy_service() const;
 
-  void GetInfoForTracker(
-      RequestTracker<SocketStream>::RecentRequestInfo* info) const;
-
-  scoped_refptr<LoadLog> load_log_;
+  BoundNetLog net_log_;
 
   GURL url_;
   int max_pending_send_allowed_;
   scoped_refptr<URLRequestContext> context_;
 
   typedef std::map<const void*, linked_ptr<UserData> > UserDataMap;
   UserDataMap user_data_;
 
   State next_state_;
   scoped_refptr<HostResolver> host_resolver_;
@@ skipping 42 matching lines @@
   scoped_refptr<IOBuffer> write_buf_;
   scoped_refptr<DrainableIOBuffer> current_write_buf_;
   int write_buf_offset_;
   int write_buf_size_;
   PendingDataQueue pending_write_bufs_;
 
   SocketStreamThrottle* throttle_;
 
   scoped_ptr<SocketStreamMetrics> metrics_;
 
-  RequestTracker<SocketStream>::Node request_tracker_node_;
-
   DISALLOW_COPY_AND_ASSIGN(SocketStream);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_STREAM_SOCKET_STREAM_H_