Rework the logging for sockets/connectjobs....

net/socket/client_socket_pool_base.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.
 //
 // 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 73 matching lines @@
   // 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
   // if it succeeded.
   int Connect();
 
   virtual LoadState GetLoadState() const = 0;
 
  protected:
-  void set_socket(ClientSocket* socket) { socket_.reset(socket); }
+  void set_socket(ClientSocket* socket);
   ClientSocket* socket() { return socket_.get(); }
   void NotifyDelegateOfCompletion(int rv);
   void ResetTimer(base::TimeDelta remainingTime);
 
  private:
   virtual int ConnectInternal() = 0;
 
+  void LogConnectStart();
+  void LogConnectCompletion(int net_error);
+
   // 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_;
   BoundNetLog net_log_;
@@ skipping 39 matching lines @@
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const Request& request,
-        ConnectJob::Delegate* delegate,
-        const BoundNetLog& net_log) const = 0;
+        ConnectJob::Delegate* delegate) const = 0;
 
     virtual base::TimeDelta ConnectionTimeout() const = 0;
 
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobFactory);
   };
 
   ClientSocketPoolBaseHelper(
       int max_sockets,
       int max_sockets_per_group,
@@ skipping 51 matching lines @@
   }
 
   // Closes all idle sockets if |force| is true.  Else, only closes idle
   // sockets that timed out or can't be reused.  Made public for testing.
   void CleanupIdleSockets(bool force);
 
   base::TimeDelta ConnectionTimeout() const {
     return connect_job_factory_->ConnectionTimeout();
   }
 
-  void enable_backup_jobs() { backup_jobs_enabled_ = true; };
+  void enable_backup_jobs() { backup_jobs_enabled_ = true; }
 
  private:
   friend class base::RefCounted<ClientSocketPoolBaseHelper>;
 
   ~ClientSocketPoolBaseHelper();
 
   // Entry for a persistent socket which became idle at time |start_time|.
   struct IdleSocket {
     IdleSocket() : socket(NULL), used(false) {}
     ClientSocket* socket;
@@ skipping 135 matching lines @@
   // 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 NetLog of the queueing status of
   // |request|.
   int RequestSocketInternal(const std::string& group_name,
                             const Request* request);
 
+  static void LogBoundConnectJobToRequest(
+      const NetLog::Source& connect_job_source, 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);
 
   GroupMap group_map_;
 
   // Timer used to periodically prune idle sockets that timed out or can't be
   // reused.
@@ skipping 79 matching lines @@
   };
 
   class ConnectJobFactory {
    public:
     ConnectJobFactory() {}
     virtual ~ConnectJobFactory() {}
 
     virtual ConnectJob* NewConnectJob(
         const std::string& group_name,
         const Request& request,
-        ConnectJob::Delegate* delegate,
-        const BoundNetLog& net_log) const = 0;
+        ConnectJob::Delegate* delegate) const = 0;
 
     virtual base::TimeDelta ConnectionTimeout() 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
@@ skipping 72 matching lines @@
   }
 
   base::TimeDelta ConnectionTimeout() const {
     return helper_->ConnectionTimeout();
   }
 
   scoped_refptr<ClientSocketPoolHistograms> histograms() const {
     return histograms_;
   }
 
-  void enable_backup_jobs() { helper_->enable_backup_jobs(); };
+  void enable_backup_jobs() { helper_->enable_backup_jobs(); }
 
  private:
   // This adaptor class exists to bridge the
   // internal::ClientSocketPoolBaseHelper::ConnectJobFactory and
   // ClientSocketPoolBase::ConnectJobFactory types, allowing clients to use the
   // typesafe ClientSocketPoolBase::ConnectJobFactory, rather than having to
   // static_cast themselves.
   class ConnectJobFactoryAdaptor
       : public internal::ClientSocketPoolBaseHelper::ConnectJobFactory {
    public:
     typedef typename ClientSocketPoolBase<SocketParams>::ConnectJobFactory
         ConnectJobFactory;
 
     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,
-        const BoundNetLog& net_log) const {
+        ConnectJob::Delegate* delegate) const {
       const Request* casted_request = static_cast<const Request*>(&request);
       return connect_job_factory_->NewConnectJob(
-          group_name, *casted_request, delegate, net_log);
+          group_name, *casted_request, delegate);
     }
 
     virtual base::TimeDelta ConnectionTimeout() const {
       return connect_job_factory_->ConnectionTimeout();
     }
 
     const scoped_ptr<ConnectJobFactory> connect_job_factory_;
   };
 
   // Histograms for the pool
   const scoped_refptr<ClientSocketPoolHistograms> histograms_;
 
   // 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_