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

net/socket/client_socket_pool_base.h

 // Copyright (c) 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.
 //
 // A ClientSocketPoolBase is used to restrict the number of sockets open at
 // a time.  It also maintains a list of idle persistent sockets for reuse.
 // Subclasses of ClientSocketPool should compose ClientSocketPoolBase to handle
 // the core logic of (1) restricting the number of active (connected or
 // connecting) sockets per "group" (generally speaking, the hostname), (2)
 // maintaining a per-group list of idle, persistent sockets for reuse, and (3)
@@ skipping 20 matching lines @@
 #include "base/compiler_specific.h"
 #include "base/ref_counted.h"
 #include "base/scoped_ptr.h"
 #include "base/task.h"
 #include "base/time.h"
 #include "base/timer.h"
 #include "net/base/address_list.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
+#include "net/base/net_log.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/request_priority.h"
 #include "net/socket/client_socket.h"
 #include "net/socket/client_socket_pool.h"
 
 namespace net {
 
 class ClientSocketHandle;
-class LoadLog;
 
 // ConnectJob provides an abstract interface for "connecting" a socket.
 // The connection may involve host resolution, tcp connection, ssl connection,
 // etc.
 class ConnectJob {
  public:
   class Delegate {
    public:
     Delegate() {}
     virtual ~Delegate() {}
 
     // Alerts the delegate that the connection completed.
     virtual void OnConnectJobComplete(int result, ConnectJob* job) = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(Delegate);
   };
 
   // A |timeout_duration| of 0 corresponds to no timeout.
   ConnectJob(const std::string& group_name,
              base::TimeDelta timeout_duration,
              Delegate* delegate,
-             LoadLog* load_log);
+             const BoundNetLog& net_log);
   virtual ~ConnectJob();
 
   // Accessors
   const std::string& group_name() const { return group_name_; }
-  LoadLog* load_log() { return load_log_; }
+  const BoundNetLog& net_log() { return net_log_; }
 
   // Releases |socket_| to the client.  On connection error, this should return
   // NULL.
   ClientSocket* ReleaseSocket() { return socket_.release(); }
 
   // Begins connecting the socket.  Returns OK on success, ERR_IO_PENDING if it
   // cannot complete synchronously without blocking, or another net error code
   // on error.  In asynchronous completion, the ConnectJob will notify
   // |delegate_| via OnConnectJobComplete.  In both asynchronous and synchronous
   // completion, ReleaseSocket() can be called to acquire the connected socket
@@ skipping 12 matching lines @@
 
   // Alerts the delegate that the ConnectJob has timed out.
   void OnTimeout();
 
   const std::string group_name_;
   const base::TimeDelta timeout_duration_;
   // Timer to abort jobs that take too long.
   base::OneShotTimer<ConnectJob> timer_;
   Delegate* delegate_;
   scoped_ptr<ClientSocket> socket_;
-  scoped_refptr<LoadLog> load_log_;
+  BoundNetLog net_log_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectJob);
 };
 
 namespace internal {
 
 // ClientSocketPoolBaseHelper is an internal class that implements almost all
 // the functionality from ClientSocketPoolBase without using templates.
 // ClientSocketPoolBase adds templated definitions built on top of
 // ClientSocketPoolBaseHelper.  This class is not for external use, please use
 // ClientSocketPoolBase instead.
 class ClientSocketPoolBaseHelper
     : public base::RefCounted<ClientSocketPoolBaseHelper>,
       public ConnectJob::Delegate,
       public NetworkChangeNotifier::Observer {
  public:
   class Request {
    public:
     Request(ClientSocketHandle* handle,
             CompletionCallback* callback,
             RequestPriority priority,
-            LoadLog* load_log);
+            const BoundNetLog& net_log);
 
     virtual ~Request();
 
     ClientSocketHandle* handle() const { return handle_; }
     CompletionCallback* callback() const { return callback_; }
     RequestPriority priority() const { return priority_; }
-    LoadLog* load_log() const { return load_log_.get(); }
+    const BoundNetLog& net_log() const { return net_log_; }
 
    private:
     ClientSocketHandle* const handle_;
     CompletionCallback* const callback_;
     const RequestPriority priority_;
-    const scoped_refptr<LoadLog> load_log_;
+    BoundNetLog net_log_;
 
     DISALLOW_COPY_AND_ASSIGN(Request);
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const Request& request,
         ConnectJob::Delegate* delegate,
-        LoadLog* load_log) const = 0;
+        const BoundNetLog& net_log) const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   ClientSocketPoolBaseHelper(
       int max_sockets,
       int max_sockets_per_group,
       base::TimeDelta unused_idle_socket_timeout,
       base::TimeDelta used_idle_socket_timeout,
@@ skipping 178 matching lines @@
 
   // Process a request from a group's pending_requests queue.
   void ProcessPendingRequest(const std::string& group_name, Group* group);
 
   // Assigns |socket| to |handle| and updates |group|'s counters appropriately.
   void HandOutSocket(ClientSocket* socket,
                      bool reused,
                      ClientSocketHandle* handle,
                      base::TimeDelta time_idle,
                      Group* group,
-                     LoadLog* load_log);
+                     const BoundNetLog& net_log);
 
   // Adds |socket| to the list of idle sockets for |group|.  |used| indicates
   // whether or not the socket has previously been used.
   void AddIdleSocket(ClientSocket* socket, bool used, Group* group);
 
   // Iterates through |connect_job_map_|, canceling all ConnectJobs.
   // Afterwards, it iterates through all groups and deletes them if they are no
   // longer needed.
   void CancelAllConnectJobs();
 
   // Returns true if we can't create any more sockets due to the total limit.
   // TODO(phajdan.jr): Also take idle sockets into account.
   bool ReachedMaxSocketsLimit() const;
 
   // This is the internal implementation of RequestSocket().  It differs in that
-  // it does not handle logging into LoadLog of the queueing status of
+  // it does not handle logging into NetLog of the queueing status of
   // |request|.
   int RequestSocketInternal(const std::string& group_name,
                             const Request* request);
 
   // Set a timer to create a backup socket if it takes too long to create one.
   void StartBackupSocketTimer(const std::string& group_name);
 
   // Called when the backup socket timer fires.
   void OnBackupSocketTimerFired(const std::string& group_name);
 
@@ skipping 58 matching lines @@
 
 template <typename SocketParams>
 class ClientSocketPoolBase {
  public:
   class Request : public internal::ClientSocketPoolBaseHelper::Request {
    public:
     Request(ClientSocketHandle* handle,
             CompletionCallback* callback,
             RequestPriority priority,
             const SocketParams& params,
-            LoadLog* load_log)
+            const BoundNetLog& net_log)
         : internal::ClientSocketPoolBaseHelper::Request(
-            handle, callback, priority, load_log),
+            handle, callback, priority, net_log),
           params_(params) {}
 
     const SocketParams& params() const { return params_; }
 
    private:
     SocketParams params_;
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const Request& request,
         ConnectJob::Delegate* delegate,
-        LoadLog* load_log) const = 0;
+        const BoundNetLog& net_log) const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   // |max_sockets| is the maximum number of sockets to be maintained by this
   // ClientSocketPool.  |max_sockets_per_group| specifies the maximum number of
   // sockets a "group" can have.  |unused_idle_socket_timeout| specifies how
   // long to leave an unused idle socket open before closing it.
   // |used_idle_socket_timeout| specifies how long to leave a previously used
@@ skipping 16 matching lines @@
   // These member functions simply forward to ClientSocketPoolBaseHelper.
 
   // RequestSocket bundles up the parameters into a Request and then forwards to
   // ClientSocketPoolBaseHelper::RequestSocket().  Note that the memory
   // ownership is transferred in the asynchronous (ERR_IO_PENDING) case.
   int RequestSocket(const std::string& group_name,
                     const SocketParams& params,
                     RequestPriority priority,
                     ClientSocketHandle* handle,
                     CompletionCallback* callback,
-                    LoadLog* load_log) {
+                    const BoundNetLog& net_log) {
     scoped_ptr<Request> request(
-        new Request(handle, callback, priority, params, load_log));
+        new Request(handle, callback, priority, params, net_log));
     int rv = helper_->RequestSocket(group_name, request.get());
     if (rv == ERR_IO_PENDING)
       request.release();
     return rv;
   }
 
   void CancelRequest(const std::string& group_name,
                      const ClientSocketHandle* handle) {
     return helper_->CancelRequest(group_name, handle);
   }
@@ skipping 46 matching lines @@
 
     explicit ConnectJobFactoryAdaptor(
         ConnectJobFactory* connect_job_factory)
         : connect_job_factory_(connect_job_factory) {}
     virtual ~ConnectJobFactoryAdaptor() {}
 
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const internal::ClientSocketPoolBaseHelper::Request& request,
         ConnectJob::Delegate* delegate,
-        LoadLog* load_log) const {
+        const BoundNetLog& net_log) const {
       const Request* casted_request = static_cast<const Request*>(&request);
       return connect_job_factory_->NewConnectJob(
-          group_name, *casted_request, delegate, load_log);
+          group_name, *casted_request, delegate, net_log);
     }
 
     const scoped_ptr<ConnectJobFactory> connect_job_factory_;
   };
 
   // One might ask why ClientSocketPoolBaseHelper is also refcounted if its
   // containing ClientSocketPool is already refcounted.  The reason is because
   // DoReleaseSocket() posts a task.  If ClientSocketPool gets deleted between
   // the posting of the task and the execution, then we'll hit the DCHECK that
   // |ClientSocketPoolBaseHelper::group_map_| is empty.
   scoped_refptr<internal::ClientSocketPoolBaseHelper> helper_;
 
   DISALLOW_COPY_AND_ASSIGN(ClientSocketPoolBase);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_CLIENT_SOCKET_POOL_BASE_H_