Clang format slam.

net/socket/transport_client_socket_pool.cc

Index: net/socket/transport_client_socket_pool.cc
diff --git a/net/socket/transport_client_socket_pool.cc b/net/socket/transport_client_socket_pool.cc
index dc481fa4b6d6004afcc102923a9c3194f91b8940..d8b1e9f16cb6e537e6fcdf4db7f8b3f9d4589001 100644
--- a/net/socket/transport_client_socket_pool.cc
+++ b/net/socket/transport_client_socket_pool.cc
@@ -49,12 +49,12 @@ bool AddressListOnlyContainsIPv6(const AddressList& list) {
 }  // namespace
 
 // This lock protects |g_last_connect_time|.
-static base::LazyInstance<base::Lock>::Leaky
-    g_last_connect_time_lock = LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<base::Lock>::Leaky g_last_connect_time_lock =
+    LAZY_INSTANCE_INITIALIZER;
 
 // |g_last_connect_time| has the last time a connect() call is made.
-static base::LazyInstance<base::TimeTicks>::Leaky
-    g_last_connect_time = LAZY_INSTANCE_INITIALIZER;
+static base::LazyInstance<base::TimeTicks>::Leaky g_last_connect_time =
+    LAZY_INSTANCE_INITIALIZER;
 
 TransportSocketParams::TransportSocketParams(
     const HostPortPair& host_port_pair,
@@ -68,7 +68,8 @@ TransportSocketParams::TransportSocketParams(
     destination_.set_allow_cached_response(false);
 }
 
-TransportSocketParams::~TransportSocketParams() {}
+TransportSocketParams::~TransportSocketParams() {
+}
 
 // TransportConnectJobs will time out after this many seconds.  Note this is
 // the total time, including both host resolution and TCP connect() times.
@@ -90,7 +91,10 @@ TransportConnectJob::TransportConnectJob(
     HostResolver* host_resolver,
     Delegate* delegate,
     NetLog* net_log)
-    : ConnectJob(group_name, timeout_duration, priority, delegate,
+    : ConnectJob(group_name,
+                 timeout_duration,
+                 priority,
+                 delegate,
                  BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
       params_(params),
       client_socket_factory_(client_socket_factory),
@@ -218,15 +222,17 @@ int TransportConnectJob::DoTransportConnect() {
 
   next_state_ = STATE_TRANSPORT_CONNECT_COMPLETE;
   transport_socket_ = client_socket_factory_->CreateTransportClientSocket(
-        addresses_, net_log().net_log(), net_log().source());
+      addresses_, net_log().net_log(), net_log().source());
   int rv = transport_socket_->Connect(
       base::Bind(&TransportConnectJob::OnIOComplete, base::Unretained(this)));
   if (rv == ERR_IO_PENDING &&
       addresses_.front().GetFamily() == ADDRESS_FAMILY_IPV6 &&
       !AddressListOnlyContainsIPv6(addresses_)) {
-    fallback_timer_.Start(FROM_HERE,
+    fallback_timer_.Start(
+        FROM_HERE,
         base::TimeDelta::FromMilliseconds(kIPv6FallbackTimerInMs),
-        this, &TransportConnectJob::DoIPv6FallbackTransportConnect);
+        this,
+        &TransportConnectJob::DoIPv6FallbackTransportConnect);
   }
   return rv;
 }
@@ -238,19 +244,18 @@ int TransportConnectJob::DoTransportConnectComplete(int result) {
     DCHECK(!connect_timing_.dns_start.is_null());
     base::TimeTicks now = base::TimeTicks::Now();
     base::TimeDelta total_duration = now - connect_timing_.dns_start;
-    UMA_HISTOGRAM_CUSTOM_TIMES(
-        "Net.DNS_Resolution_And_TCP_Connection_Latency2",
-        total_duration,
-        base::TimeDelta::FromMilliseconds(1),
-        base::TimeDelta::FromMinutes(10),
-        100);
+    UMA_HISTOGRAM_CUSTOM_TIMES("Net.DNS_Resolution_And_TCP_Connection_Latency2",
+                               total_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
 
     base::TimeDelta connect_duration = now - connect_timing_.connect_start;
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency",
-        connect_duration,
-        base::TimeDelta::FromMilliseconds(1),
-        base::TimeDelta::FromMinutes(10),
-        100);
+                               connect_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
 
     switch (interval_between_connects_) {
       case CONNECT_INTERVAL_LE_10MS:
@@ -332,9 +337,8 @@ void TransportConnectJob::DoIPv6FallbackTransportConnect() {
           *fallback_addresses_, net_log().net_log(), net_log().source());
   fallback_connect_start_time_ = base::TimeTicks::Now();
   int rv = fallback_transport_socket_->Connect(
-      base::Bind(
-          &TransportConnectJob::DoIPv6FallbackTransportConnectComplete,
-          base::Unretained(this)));
+      base::Bind(&TransportConnectJob::DoIPv6FallbackTransportConnectComplete,
+                 base::Unretained(this)));
   if (rv != ERR_IO_PENDING)
     DoIPv6FallbackTransportConnectComplete(rv);
 }
@@ -355,25 +359,24 @@ void TransportConnectJob::DoIPv6FallbackTransportConnectComplete(int result) {
     DCHECK(!connect_timing_.dns_start.is_null());
     base::TimeTicks now = base::TimeTicks::Now();
     base::TimeDelta total_duration = now - connect_timing_.dns_start;
-    UMA_HISTOGRAM_CUSTOM_TIMES(
-        "Net.DNS_Resolution_And_TCP_Connection_Latency2",
-        total_duration,
-        base::TimeDelta::FromMilliseconds(1),
-        base::TimeDelta::FromMinutes(10),
-        100);
+    UMA_HISTOGRAM_CUSTOM_TIMES("Net.DNS_Resolution_And_TCP_Connection_Latency2",
+                               total_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
 
     base::TimeDelta connect_duration = now - fallback_connect_start_time_;
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency",
-        connect_duration,
-        base::TimeDelta::FromMilliseconds(1),
-        base::TimeDelta::FromMinutes(10),
-        100);
+                               connect_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
 
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TCP_Connection_Latency_IPv4_Wins_Race",
-        connect_duration,
-        base::TimeDelta::FromMilliseconds(1),
-        base::TimeDelta::FromMinutes(10),
-        100);
+                               connect_duration,
+                               base::TimeDelta::FromMilliseconds(1),
+                               base::TimeDelta::FromMinutes(10),
+                               100);
     SetSocket(fallback_transport_socket_.Pass());
     next_state_ = STATE_NONE;
     transport_socket_.reset();
@@ -391,23 +394,22 @@ int TransportConnectJob::ConnectInternal() {
 }
 
 scoped_ptr<ConnectJob>
-    TransportClientSocketPool::TransportConnectJobFactory::NewConnectJob(
+TransportClientSocketPool::TransportConnectJobFactory::NewConnectJob(
     const std::string& group_name,
     const PoolBase::Request& request,
     ConnectJob::Delegate* delegate) const {
-  return scoped_ptr<ConnectJob>(
-      new TransportConnectJob(group_name,
-                              request.priority(),
-                              request.params(),
-                              ConnectionTimeout(),
-                              client_socket_factory_,
-                              host_resolver_,
-                              delegate,
-                              net_log_));
+  return scoped_ptr<ConnectJob>(new TransportConnectJob(group_name,
+                                                        request.priority(),
+                                                        request.params(),
+                                                        ConnectionTimeout(),
+                                                        client_socket_factory_,
+                                                        host_resolver_,
+                                                        delegate,
+                                                        net_log_));
 }
 
 base::TimeDelta
-    TransportClientSocketPool::TransportConnectJobFactory::ConnectionTimeout()
+TransportClientSocketPool::TransportConnectJobFactory::ConnectionTimeout()
     const {
   return base::TimeDelta::FromSeconds(kTransportConnectJobTimeoutInSeconds);
 }
@@ -419,23 +421,27 @@ TransportClientSocketPool::TransportClientSocketPool(
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
     NetLog* net_log)
-    : base_(NULL, max_sockets, max_sockets_per_group, histograms,
+    : base_(NULL,
+            max_sockets,
+            max_sockets_per_group,
+            histograms,
             ClientSocketPool::unused_idle_socket_timeout(),
             ClientSocketPool::used_idle_socket_timeout(),
             new TransportConnectJobFactory(client_socket_factory,
-                                           host_resolver, net_log)) {
+                                           host_resolver,
+                                           net_log)) {
   base_.EnableConnectBackupJobs();
 }
 
-TransportClientSocketPool::~TransportClientSocketPool() {}
+TransportClientSocketPool::~TransportClientSocketPool() {
+}
 
-int TransportClientSocketPool::RequestSocket(
-    const std::string& group_name,
-    const void* params,
-    RequestPriority priority,
-    ClientSocketHandle* handle,
-    const CompletionCallback& callback,
-    const BoundNetLog& net_log) {
+int TransportClientSocketPool::RequestSocket(const std::string& group_name,
+                                             const void* params,
+                                             RequestPriority priority,
+                                             ClientSocketHandle* handle,
+                                             const CompletionCallback& callback,
+                                             const BoundNetLog& net_log) {
   const scoped_refptr<TransportSocketParams>* casted_params =
       static_cast<const scoped_refptr<TransportSocketParams>*>(params);
 
@@ -447,15 +453,14 @@ int TransportClientSocketPool::RequestSocket(
             &casted_params->get()->destination().host_port_pair()));
   }
 
-  return base_.RequestSocket(group_name, *casted_params, priority, handle,
-                             callback, net_log);
+  return base_.RequestSocket(
+      group_name, *casted_params, priority, handle, callback, net_log);
 }
 
-void TransportClientSocketPool::RequestSockets(
-    const std::string& group_name,
-    const void* params,
-    int num_sockets,
-    const BoundNetLog& net_log) {
+void TransportClientSocketPool::RequestSockets(const std::string& group_name,
+                                               const void* params,
+                                               int num_sockets,
+                                               const BoundNetLog& net_log) {
   const scoped_refptr<TransportSocketParams>* casted_params =
       static_cast<const scoped_refptr<TransportSocketParams>*>(params);
 
@@ -470,16 +475,14 @@ void TransportClientSocketPool::RequestSockets(
   base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
 }
 
-void TransportClientSocketPool::CancelRequest(
-    const std::string& group_name,
-    ClientSocketHandle* handle) {
+void TransportClientSocketPool::CancelRequest(const std::string& group_name,
+                                              ClientSocketHandle* handle) {
   base_.CancelRequest(group_name, handle);
 }
 
-void TransportClientSocketPool::ReleaseSocket(
-    const std::string& group_name,
-    scoped_ptr<StreamSocket> socket,
-    int id) {
+void TransportClientSocketPool::ReleaseSocket(const std::string& group_name,
+                                              scoped_ptr<StreamSocket> socket,
+                                              int id) {
   base_.ReleaseSocket(group_name, socket.Pass(), id);
 }
 
@@ -501,7 +504,8 @@ int TransportClientSocketPool::IdleSocketCountInGroup(
 }
 
 LoadState TransportClientSocketPool::GetLoadState(
-    const std::string& group_name, const ClientSocketHandle* handle) const {
+    const std::string& group_name,
+    const ClientSocketHandle* handle) const {
   return base_.GetLoadState(group_name, handle);
 }