Rework the logging for sockets/connectjobs....

net/socket/socks_client_socket_pool.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/socket/socks_client_socket_pool.h"
 
 #include "base/time.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_errors.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/client_socket_pool_base.h"
 #include "net/socket/socks5_client_socket.h"
 #include "net/socket/socks_client_socket.h"
 
 namespace net {
 
 // SOCKSConnectJobs will time out after this many seconds.  Note this is on
 // top of the timeout for the transport socket.
 static const int kSOCKSConnectJobTimeoutInSeconds = 30;
 
 SOCKSConnectJob::SOCKSConnectJob(
     const std::string& group_name,
     const SOCKSSocketParams& socks_params,
     const base::TimeDelta& timeout_duration,
     const scoped_refptr<TCPClientSocketPool>& tcp_pool,
     const scoped_refptr<HostResolver>& host_resolver,
     Delegate* delegate,
-    const BoundNetLog& net_log)
-    : ConnectJob(group_name, timeout_duration, delegate, net_log),
+    NetLog* net_log)
+    : ConnectJob(group_name, timeout_duration, delegate,
+                 BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       socks_params_(socks_params),
       tcp_pool_(tcp_pool),
       resolver_(host_resolver),
       ALLOW_THIS_IN_INITIALIZER_LIST(
-          callback_(this, &SOCKSConnectJob::OnIOComplete)) {}
+          callback_(this, &SOCKSConnectJob::OnIOComplete)) {
+}
 
 SOCKSConnectJob::~SOCKSConnectJob() {
   // We don't worry about cancelling the tcp socket since the destructor in
   // scoped_ptr<ClientSocketHandle> tcp_socket_handle_ will take care of it.
 }
 
 LoadState SOCKSConnectJob::GetLoadState() const {
   switch (next_state_) {
     case kStateTCPConnect:
     case kStateTCPConnectComplete:
@@ skipping 91 matching lines @@
     return result;
   }
 
   set_socket(socket_.release());
   return result;
 }
 
 ConnectJob* SOCKSClientSocketPool::SOCKSConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const PoolBase::Request& request,
-    ConnectJob::Delegate* delegate,
-    const BoundNetLog& net_log) const {
+    ConnectJob::Delegate* delegate) const {
   return new SOCKSConnectJob(group_name, request.params(), ConnectionTimeout(),
-                             tcp_pool_, host_resolver_, delegate, net_log);
+                             tcp_pool_, host_resolver_, delegate, net_log_);
 }
 
 base::TimeDelta
 SOCKSClientSocketPool::SOCKSConnectJobFactory::ConnectionTimeout() const {
   return tcp_pool_->ConnectionTimeout() +
       base::TimeDelta::FromSeconds(kSOCKSConnectJobTimeoutInSeconds);
 }
 
 SOCKSClientSocketPool::SOCKSClientSocketPool(
     int max_sockets,
     int max_sockets_per_group,
     const scoped_refptr<ClientSocketPoolHistograms>& histograms,
     const scoped_refptr<HostResolver>& host_resolver,
     const scoped_refptr<TCPClientSocketPool>& tcp_pool,
-    NetworkChangeNotifier* network_change_notifier)
+    NetworkChangeNotifier* network_change_notifier,
+    NetLog* net_log)
     : base_(max_sockets, max_sockets_per_group, histograms,
             base::TimeDelta::FromSeconds(kUnusedIdleSocketTimeout),
             base::TimeDelta::FromSeconds(kUsedIdleSocketTimeout),
-            new SOCKSConnectJobFactory(tcp_pool, host_resolver),
+            new SOCKSConnectJobFactory(tcp_pool, host_resolver, net_log),
             network_change_notifier) {}
 
 SOCKSClientSocketPool::~SOCKSClientSocketPool() {}
 
 int SOCKSClientSocketPool::RequestSocket(
     const std::string& group_name,
     const void* socket_params,
     RequestPriority priority,
     ClientSocketHandle* handle,
     CompletionCallback* callback,
@@ skipping 25 matching lines @@
     const std::string& group_name) const {
   return base_.IdleSocketCountInGroup(group_name);
 }
 
 LoadState SOCKSClientSocketPool::GetLoadState(
     const std::string& group_name, const ClientSocketHandle* handle) const {
   return base_.GetLoadState(group_name, handle);
 }
 
 }  // namespace net