Clang format slam.

net/socket/client_socket_pool_base.cc

 // Copyright (c) 2012 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/client_socket_pool_base.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 109 matching lines @@
   // Make sure the socket is NULL before calling into |delegate|.
   SetSocket(scoped_ptr<StreamSocket>());
 
   net_log_.AddEvent(NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT);
 
   NotifyDelegateOfCompletion(ERR_TIMED_OUT);
 }
 
 namespace internal {
 
-ClientSocketPoolBaseHelper::Request::Request(
-    ClientSocketHandle* handle,
-    const CompletionCallback& callback,
-    RequestPriority priority,
-    bool ignore_limits,
-    Flags flags,
-    const BoundNetLog& net_log)
+ClientSocketPoolBaseHelper::Request::Request(ClientSocketHandle* handle,
+                                             const CompletionCallback& callback,
+                                             RequestPriority priority,
+                                             bool ignore_limits,
+                                             Flags flags,
+                                             const BoundNetLog& net_log)
     : handle_(handle),
       callback_(callback),
       priority_(priority),
       ignore_limits_(ignore_limits),
       flags_(flags),
       net_log_(net_log) {
   if (ignore_limits_)
     DCHECK_EQ(priority_, MAXIMUM_PRIORITY);
 }
 
-ClientSocketPoolBaseHelper::Request::~Request() {}
+ClientSocketPoolBaseHelper::Request::~Request() {
+}
 
 ClientSocketPoolBaseHelper::ClientSocketPoolBaseHelper(
     HigherLayeredPool* pool,
     int max_sockets,
     int max_sockets_per_group,
     base::TimeDelta unused_idle_socket_timeout,
     base::TimeDelta used_idle_socket_timeout,
     ConnectJobFactory* connect_job_factory)
     : idle_socket_count_(0),
       connecting_socket_count_(0),
@@ skipping 32 matching lines @@
        ++it) {
     (*it)->RemoveHigherLayeredPool(pool_);
   }
 }
 
 ClientSocketPoolBaseHelper::CallbackResultPair::CallbackResultPair()
     : result(OK) {
 }
 
 ClientSocketPoolBaseHelper::CallbackResultPair::CallbackResultPair(
-    const CompletionCallback& callback_in, int result_in)
-    : callback(callback_in),
-      result(result_in) {
+    const CompletionCallback& callback_in,
+    int result_in)
+    : callback(callback_in), result(result_in) {
 }
 
-ClientSocketPoolBaseHelper::CallbackResultPair::~CallbackResultPair() {}
+ClientSocketPoolBaseHelper::CallbackResultPair::~CallbackResultPair() {
+}
 
 bool ClientSocketPoolBaseHelper::IsStalled() const {
   // If a lower layer pool is stalled, consider |this| stalled as well.
   for (std::set<LowerLayeredPool*>::const_iterator it = lower_pools_.begin();
        it != lower_pools_.end();
        ++it) {
     if ((*it)->IsStalled())
       return true;
   }
 
   // If fewer than |max_sockets_| are in use, then clearly |this| is not
   // stalled.
   if ((handed_out_socket_count_ + connecting_socket_count_) < max_sockets_)
     return false;
   // So in order to be stalled, |this| must be using at least |max_sockets_| AND
   // |this| must have a request that is actually stalled on the global socket
   // limit.  To find such a request, look for a group that has more requests
   // than jobs AND where the number of sockets is less than
   // |max_sockets_per_group_|.  (If the number of sockets is equal to
   // |max_sockets_per_group_|, then the request is stalled on the group limit,
   // which does not count.)
-  for (GroupMap::const_iterator it = group_map_.begin();
-       it != group_map_.end(); ++it) {
+  for (GroupMap::const_iterator it = group_map_.begin(); it != group_map_.end();
+       ++it) {
     if (it->second->IsStalledOnPoolMaxSockets(max_sockets_per_group_))
       return true;
   }
   return false;
 }
 
 void ClientSocketPoolBaseHelper::AddLowerLayeredPool(
     LowerLayeredPool* lower_pool) {
   DCHECK(pool_);
   CHECK(!ContainsKey(lower_pools_, lower_pool));
@@ skipping 43 matching lines @@
       base::MessageLoop::current()->PostTask(
           FROM_HERE,
           base::Bind(
               &ClientSocketPoolBaseHelper::TryToCloseSocketsInLayeredPools,
               weak_factory_.GetWeakPtr()));
     }
   }
   return rv;
 }
 
-void ClientSocketPoolBaseHelper::RequestSockets(
-    const std::string& group_name,
-    const Request& request,
-    int num_sockets) {
+void ClientSocketPoolBaseHelper::RequestSockets(const std::string& group_name,
+                                                const Request& request,
+                                                int num_sockets) {
   DCHECK(request.callback().is_null());
   DCHECK(!request.handle());
 
   // Cleanup any timed out idle sockets if no timer is used.
   if (!use_cleanup_timer_)
     CleanupIdleSockets(false);
 
   if (num_sockets > max_sockets_per_group_) {
     num_sockets = max_sockets_per_group_;
   }
 
   request.net_log().BeginEvent(
       NetLog::TYPE_SOCKET_POOL_CONNECTING_N_SOCKETS,
       NetLog::IntegerCallback("num_sockets", num_sockets));
 
   Group* group = GetOrCreateGroup(group_name);
 
   // RequestSocketsInternal() may delete the group.
   bool deleted_group = false;
 
   int rv = OK;
   for (int num_iterations_left = num_sockets;
-       group->NumActiveSocketSlots() < num_sockets &&
-       num_iterations_left > 0 ; num_iterations_left--) {
+       group->NumActiveSocketSlots() < num_sockets && num_iterations_left > 0;
+       num_iterations_left--) {
     rv = RequestSocketInternal(group_name, request);
     if (rv < 0 && rv != ERR_IO_PENDING) {
       // We're encountering a synchronous error.  Give up.
       if (!ContainsKey(group_map_, group_name))
         deleted_group = true;
       break;
     }
     if (!ContainsKey(group_map_, group_name)) {
       // Unexpected.  The group should only be getting deleted on synchronous
       // error.
@@ skipping 63 matching lines @@
 
   // We couldn't find a socket to reuse, and there's space to allocate one,
   // so allocate and connect a new one.
   scoped_ptr<ConnectJob> connect_job(
       connect_job_factory_->NewConnectJob(group_name, request, this));
 
   int rv = connect_job->Connect();
   if (rv == OK) {
     LogBoundConnectJobToRequest(connect_job->net_log().source(), request);
     if (!preconnecting) {
-      HandOutSocket(connect_job->PassSocket(), ClientSocketHandle::UNUSED,
-                    connect_job->connect_timing(), handle, base::TimeDelta(),
-                    group, request.net_log());
+      HandOutSocket(connect_job->PassSocket(),
+                    ClientSocketHandle::UNUSED,
+                    connect_job->connect_timing(),
+                    handle,
+                    base::TimeDelta(),
+                    group,
+                    request.net_log());
     } else {
       AddIdleSocket(connect_job->PassSocket(), group);
     }
   } else if (rv == ERR_IO_PENDING) {
     // If we don't have any sockets in this group, set a timer for potentially
     // creating a new one.  If the SYN is lost, this backup socket may complete
     // before the slow socket, improving end user latency.
     if (connect_backup_jobs_enabled_ && group->IsEmpty()) {
       group->StartBackupJobTimer(group_name, this);
     }
 
     connecting_socket_count_++;
 
     group->AddJob(connect_job.Pass(), preconnecting);
   } else {
     LogBoundConnectJobToRequest(connect_job->net_log().source(), request);
     scoped_ptr<StreamSocket> error_socket;
     if (!preconnecting) {
       DCHECK(handle);
       connect_job->GetAdditionalErrorState(handle);
       error_socket = connect_job->PassSocket();
     }
     if (error_socket) {
-      HandOutSocket(error_socket.Pass(), ClientSocketHandle::UNUSED,
-                    connect_job->connect_timing(), handle, base::TimeDelta(),
-                    group, request.net_log());
+      HandOutSocket(error_socket.Pass(),
+                    ClientSocketHandle::UNUSED,
+                    connect_job->connect_timing(),
+                    handle,
+                    base::TimeDelta(),
+                    group,
+                    request.net_log());
     } else if (group->IsEmpty()) {
       RemoveGroup(group_name);
     }
   }
 
   return rv;
 }
 
 bool ClientSocketPoolBaseHelper::AssignIdleSocketToRequest(
-    const Request& request, Group* group) {
+    const Request& request,
+    Group* group) {
   std::list<IdleSocket>* idle_sockets = group->mutable_idle_sockets();
   std::list<IdleSocket>::iterator idle_socket_it = idle_sockets->end();
 
   // Iterate through the idle sockets forwards (oldest to newest)
   //   * Delete any disconnected ones.
   //   * If we find a used idle socket, assign to |idle_socket|.  At the end,
   //   the |idle_socket_it| will be set to the newest used idle socket.
   for (std::list<IdleSocket>::iterator it = idle_sockets->begin();
        it != idle_sockets->end();) {
     if (!it->IsUsable()) {
@@ skipping 20 matching lines @@
   if (idle_socket_it != idle_sockets->end()) {
     DecrementIdleCount();
     base::TimeDelta idle_time =
         base::TimeTicks::Now() - idle_socket_it->start_time;
     IdleSocket idle_socket = *idle_socket_it;
     idle_sockets->erase(idle_socket_it);
     // TODO(davidben): If |idle_time| is under some low watermark, consider
     // treating as UNUSED rather than UNUSED_IDLE. This will avoid
     // HttpNetworkTransaction retrying on some errors.
     ClientSocketHandle::SocketReuseType reuse_type =
-        idle_socket.socket->WasEverUsed() ?
-            ClientSocketHandle::REUSED_IDLE :
-            ClientSocketHandle::UNUSED_IDLE;
-    HandOutSocket(
-        scoped_ptr<StreamSocket>(idle_socket.socket),
-        reuse_type,
-        LoadTimingInfo::ConnectTiming(),
-        request.handle(),
-        idle_time,
-        group,
-        request.net_log());
+        idle_socket.socket->WasEverUsed() ? ClientSocketHandle::REUSED_IDLE
+                                          : ClientSocketHandle::UNUSED_IDLE;
+    HandOutSocket(scoped_ptr<StreamSocket>(idle_socket.socket),
+                  reuse_type,
+                  LoadTimingInfo::ConnectTiming(),
+                  request.handle(),
+                  idle_time,
+                  group,
+                  request.net_log());
     return true;
   }
 
   return false;
 }
 
 // static
 void ClientSocketPoolBaseHelper::LogBoundConnectJobToRequest(
-    const NetLog::Source& connect_job_source, const Request& request) {
+    const NetLog::Source& connect_job_source,
+    const Request& request) {
   request.net_log().AddEvent(NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
                              connect_job_source.ToEventParametersCallback());
 }
 
-void ClientSocketPoolBaseHelper::CancelRequest(
-    const std::string& group_name, ClientSocketHandle* handle) {
+void ClientSocketPoolBaseHelper::CancelRequest(const std::string& group_name,
+                                               ClientSocketHandle* handle) {
   PendingCallbackMap::iterator callback_it = pending_callback_map_.find(handle);
   if (callback_it != pending_callback_map_.end()) {
     int result = callback_it->second.result;
     pending_callback_map_.erase(callback_it);
     scoped_ptr<StreamSocket> socket = handle->PassSocket();
     if (socket) {
       if (result != OK)
         socket->Disconnect();
       ReleaseSocket(handle->group_name(), socket.Pass(), handle->id());
     }
@@ skipping 51 matching lines @@
   }
 
   // Can't use operator[] since it is non-const.
   const Group& group = *group_map_.find(group_name)->second;
 
   if (group.HasConnectJobForHandle(handle)) {
     // Just return the state  of the farthest along ConnectJob for the first
     // group.jobs().size() pending requests.
     LoadState max_state = LOAD_STATE_IDLE;
     for (ConnectJobSet::const_iterator job_it = group.jobs().begin();
-         job_it != group.jobs().end(); ++job_it) {
+         job_it != group.jobs().end();
+         ++job_it) {
       max_state = std::max(max_state, (*job_it)->GetLoadState());
     }
     return max_state;
   }
 
   if (group.IsStalledOnPoolMaxSockets(max_sockets_per_group_))
     return LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL;
   return LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET;
 }
 
 base::DictionaryValue* ClientSocketPoolBaseHelper::GetInfoAsValue(
-    const std::string& name, const std::string& type) const {
+    const std::string& name,
+    const std::string& type) const {
   base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("name", name);
   dict->SetString("type", type);
   dict->SetInteger("handed_out_socket_count", handed_out_socket_count_);
   dict->SetInteger("connecting_socket_count", connecting_socket_count_);
   dict->SetInteger("idle_socket_count", idle_socket_count_);
   dict->SetInteger("max_socket_count", max_sockets_);
   dict->SetInteger("max_sockets_per_group", max_sockets_per_group_);
   dict->SetInteger("pool_generation_number", pool_generation_number_);
 
   if (group_map_.empty())
     return dict;
 
   base::DictionaryValue* all_groups_dict = new base::DictionaryValue();
-  for (GroupMap::const_iterator it = group_map_.begin();
-       it != group_map_.end(); it++) {
+  for (GroupMap::const_iterator it = group_map_.begin(); it != group_map_.end();
+       it++) {
     const Group* group = it->second;
     base::DictionaryValue* group_dict = new base::DictionaryValue();
 
     group_dict->SetInteger("pending_request_count",
                            group->pending_request_count());
     if (group->has_pending_requests()) {
       group_dict->SetString(
           "top_pending_priority",
           RequestPriorityToString(group->TopPendingPriority()));
     }
@@ skipping 11 matching lines @@
     group_dict->Set("idle_sockets", idle_socket_list);
 
     base::ListValue* connect_jobs_list = new base::ListValue();
     std::set<ConnectJob*>::const_iterator job = group->jobs().begin();
     for (job = group->jobs().begin(); job != group->jobs().end(); job++) {
       int source_id = (*job)->net_log().source().id;
       connect_jobs_list->Append(new base::FundamentalValue(source_id));
     }
     group_dict->Set("connect_jobs", connect_jobs_list);
 
-    group_dict->SetBoolean("is_stalled",
-                           group->IsStalledOnPoolMaxSockets(
-                               max_sockets_per_group_));
+    group_dict->SetBoolean(
+        "is_stalled", group->IsStalledOnPoolMaxSockets(max_sockets_per_group_));
     group_dict->SetBoolean("backup_job_timer_is_running",
                            group->BackupJobTimerIsRunning());
 
     all_groups_dict->SetWithoutPathExpansion(it->first, group_dict);
   }
   dict->Set("groups", all_groups_dict);
   return dict;
 }
 
 bool ClientSocketPoolBaseHelper::IdleSocket::IsUsable() const {
@@ skipping 18 matching lines @@
   // Current time value. Retrieving it once at the function start rather than
   // inside the inner loop, since it shouldn't change by any meaningful amount.
   base::TimeTicks now = base::TimeTicks::Now();
 
   GroupMap::iterator i = group_map_.begin();
   while (i != group_map_.end()) {
     Group* group = i->second;
 
     std::list<IdleSocket>::iterator j = group->mutable_idle_sockets()->begin();
     while (j != group->idle_sockets().end()) {
-      base::TimeDelta timeout =
-          j->socket->WasEverUsed() ?
-          used_idle_socket_timeout_ : unused_idle_socket_timeout_;
+      base::TimeDelta timeout = j->socket->WasEverUsed()
+                                    ? used_idle_socket_timeout_
+                                    : unused_idle_socket_timeout_;
       if (force || j->ShouldCleanup(now, timeout)) {
         delete j->socket;
         j = group->mutable_idle_sockets()->erase(j);
         DecrementIdleCount();
       } else {
         ++j;
       }
     }
 
     // Delete group if no longer needed.
@@ skipping 59 matching lines @@
 }
 
 // static
 bool ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(bool enabled) {
   bool old_value = g_cleanup_timer_enabled;
   g_cleanup_timer_enabled = enabled;
   return old_value;
 }
 
 void ClientSocketPoolBaseHelper::StartIdleSocketTimer() {
-  timer_.Start(FROM_HERE, TimeDelta::FromSeconds(kCleanupInterval), this,
+  timer_.Start(FROM_HERE,
+               TimeDelta::FromSeconds(kCleanupInterval),
+               this,
                &ClientSocketPoolBaseHelper::OnCleanupTimerFired);
 }
 
 void ClientSocketPoolBaseHelper::ReleaseSocket(const std::string& group_name,
                                                scoped_ptr<StreamSocket> socket,
                                                int id) {
   GroupMap::iterator i = group_map_.find(group_name);
   CHECK(i != group_map_.end());
 
   Group* group = i->second;
 
   CHECK_GT(handed_out_socket_count_, 0);
   handed_out_socket_count_--;
 
   CHECK_GT(group->active_socket_count(), 0);
   group->DecrementActiveSocketCount();
 
-  const bool can_reuse = socket->IsConnectedAndIdle() &&
-      id == pool_generation_number_;
+  const bool can_reuse =
+      socket->IsConnectedAndIdle() && id == pool_generation_number_;
   if (can_reuse) {
     // Add it to the idle list.
     AddIdleSocket(socket.Pass(), group);
     OnAvailableSocketSlot(group_name, group);
   } else {
     socket.reset();
   }
 
   CheckForStalledSocketGroups();
 }
 
 void ClientSocketPoolBaseHelper::CheckForStalledSocketGroups() {
   // If we have idle sockets, see if we can give one to the top-stalled group.
   std::string top_group_name;
   Group* top_group = NULL;
   if (!FindTopStalledGroup(&top_group, &top_group_name)) {
     // There may still be a stalled group in a lower level pool.
     for (std::set<LowerLayeredPool*>::iterator it = lower_pools_.begin();
          it != lower_pools_.end();
          ++it) {
-       if ((*it)->IsStalled()) {
-         CloseOneIdleSocket();
-         break;
-       }
+      if ((*it)->IsStalled()) {
+        CloseOneIdleSocket();
+        break;
+      }
     }
     return;
   }
 
   if (ReachedMaxSocketsLimit()) {
     if (idle_socket_count() > 0) {
       CloseOneIdleSocket();
     } else {
       // We can't activate more sockets since we're already at our global
       // limit.
@@ skipping 12 matching lines @@
 // are not at the |max_sockets_per_group_| limit. Note: for requests with
 // the same priority, the winner is based on group hash ordering (and not
 // insertion order).
 bool ClientSocketPoolBaseHelper::FindTopStalledGroup(
     Group** group,
     std::string* group_name) const {
   CHECK((group && group_name) || (!group && !group_name));
   Group* top_group = NULL;
   const std::string* top_group_name = NULL;
   bool has_stalled_group = false;
-  for (GroupMap::const_iterator i = group_map_.begin();
-       i != group_map_.end(); ++i) {
+  for (GroupMap::const_iterator i = group_map_.begin(); i != group_map_.end();
+       ++i) {
     Group* curr_group = i->second;
     if (!curr_group->has_pending_requests())
       continue;
     if (curr_group->IsStalledOnPoolMaxSockets(max_sockets_per_group_)) {
       if (!group)
         return true;
       has_stalled_group = true;
-      bool has_higher_priority = !top_group ||
+      bool has_higher_priority =
+          !top_group ||
           curr_group->TopPendingPriority() > top_group->TopPendingPriority();
       if (has_higher_priority) {
         top_group = curr_group;
         top_group_name = &i->first;
       }
     }
   }
 
   if (top_group) {
     CHECK(group);
     *group = top_group;
     *group_name = *top_group_name;
   } else {
     CHECK(!has_stalled_group);
   }
   return has_stalled_group;
 }
 
-void ClientSocketPoolBaseHelper::OnConnectJobComplete(
-    int result, ConnectJob* job) {
+void ClientSocketPoolBaseHelper::OnConnectJobComplete(int result,
+                                                      ConnectJob* job) {
   DCHECK_NE(ERR_IO_PENDING, result);
   const std::string group_name = job->group_name();
   GroupMap::iterator group_it = group_map_.find(group_name);
   CHECK(group_it != group_map_.end());
   Group* group = group_it->second;
 
   scoped_ptr<StreamSocket> socket = job->PassSocket();
 
   // Copies of these are needed because |job| may be deleted before they are
   // accessed.
   BoundNetLog job_log = job->net_log();
   LoadTimingInfo::ConnectTiming connect_timing = job->connect_timing();
 
   // RemoveConnectJob(job, _) must be called by all branches below;
   // otherwise, |job| will be leaked.
 
   if (result == OK) {
     DCHECK(socket.get());
     RemoveConnectJob(job, group);
     scoped_ptr<const Request> request = group->PopNextPendingRequest();
     if (request) {
       LogBoundConnectJobToRequest(job_log.source(), *request);
-      HandOutSocket(
-          socket.Pass(), ClientSocketHandle::UNUSED, connect_timing,
-          request->handle(), base::TimeDelta(), group, request->net_log());
+      HandOutSocket(socket.Pass(),
+                    ClientSocketHandle::UNUSED,
+                    connect_timing,
+                    request->handle(),
+                    base::TimeDelta(),
+                    group,
+                    request->net_log());
       request->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL);
       InvokeUserCallbackLater(request->handle(), request->callback(), result);
     } else {
       AddIdleSocket(socket.Pass(), group);
       OnAvailableSocketSlot(group_name, group);
       CheckForStalledSocketGroups();
     }
   } else {
     // If we got a socket, it must contain error information so pass that
     // up so that the caller can retrieve it.
     bool handed_out_socket = false;
     scoped_ptr<const Request> request = group->PopNextPendingRequest();
     if (request) {
       LogBoundConnectJobToRequest(job_log.source(), *request);
       job->GetAdditionalErrorState(request->handle());
       RemoveConnectJob(job, group);
       if (socket.get()) {
         handed_out_socket = true;
-        HandOutSocket(socket.Pass(), ClientSocketHandle::UNUSED,
-                      connect_timing, request->handle(), base::TimeDelta(),
-                      group, request->net_log());
+        HandOutSocket(socket.Pass(),
+                      ClientSocketHandle::UNUSED,
+                      connect_timing,
+                      request->handle(),
+                      base::TimeDelta(),
+                      group,
+                      request->net_log());
       }
-      request->net_log().EndEventWithNetErrorCode(
-          NetLog::TYPE_SOCKET_POOL, result);
+      request->net_log().EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL,
+                                                  result);
       InvokeUserCallbackLater(request->handle(), request->callback(), result);
     } else {
       RemoveConnectJob(job, group);
     }
     if (!handed_out_socket) {
       OnAvailableSocketSlot(group_name, group);
       CheckForStalledSocketGroups();
     }
   }
 }
@@ skipping 12 matching lines @@
 void ClientSocketPoolBaseHelper::RemoveConnectJob(ConnectJob* job,
                                                   Group* group) {
   CHECK_GT(connecting_socket_count_, 0);
   connecting_socket_count_--;
 
   DCHECK(group);
   group->RemoveJob(job);
 }
 
 void ClientSocketPoolBaseHelper::OnAvailableSocketSlot(
-    const std::string& group_name, Group* group) {
+    const std::string& group_name,
+    Group* group) {
   DCHECK(ContainsKey(group_map_, group_name));
   if (group->IsEmpty()) {
     RemoveGroup(group_name);
   } else if (group->has_pending_requests()) {
     ProcessPendingRequest(group_name, group);
   }
 }
 
 void ClientSocketPoolBaseHelper::ProcessPendingRequest(
-    const std::string& group_name, Group* group) {
+    const std::string& group_name,
+    Group* group) {
   const Request* next_request = group->GetNextPendingRequest();
   DCHECK(next_request);
   int rv = RequestSocketInternal(group_name, *next_request);
   if (rv != ERR_IO_PENDING) {
     scoped_ptr<const Request> request = group->PopNextPendingRequest();
     DCHECK(request);
     if (group->IsEmpty())
       RemoveGroup(group_name);
 
     request->net_log().EndEventWithNetErrorCode(NetLog::TYPE_SOCKET_POOL, rv);
@@ skipping 12 matching lines @@
   DCHECK(socket);
   handle->SetSocket(socket.Pass());
   handle->set_reuse_type(reuse_type);
   handle->set_idle_time(idle_time);
   handle->set_pool_id(pool_generation_number_);
   handle->set_connect_timing(connect_timing);
 
   if (handle->is_reused()) {
     net_log.AddEvent(
         NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET,
-        NetLog::IntegerCallback(
-            "idle_ms", static_cast<int>(idle_time.InMilliseconds())));
+        NetLog::IntegerCallback("idle_ms",
+                                static_cast<int>(idle_time.InMilliseconds())));
   }
 
   net_log.AddEvent(
       NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
       handle->socket()->NetLog().source().ToEventParametersCallback());
 
   handed_out_socket_count_++;
   group->IncrementActiveSocketCount();
 }
 
-void ClientSocketPoolBaseHelper::AddIdleSocket(
-    scoped_ptr<StreamSocket> socket,
-    Group* group) {
+void ClientSocketPoolBaseHelper::AddIdleSocket(scoped_ptr<StreamSocket> socket,
+                                               Group* group) {
   DCHECK(socket);
   IdleSocket idle_socket;
   idle_socket.socket = socket.release();
   idle_socket.start_time = base::TimeTicks::Now();
 
   group->mutable_idle_sockets()->push_back(idle_socket);
   IncrementIdleCount();
 }
 
 void ClientSocketPoolBaseHelper::CancelAllConnectJobs() {
@@ skipping 33 matching lines @@
       // RemoveGroup() is called.
       RemoveGroup(i++);
     } else {
       ++i;
     }
   }
 }
 
 bool ClientSocketPoolBaseHelper::ReachedMaxSocketsLimit() const {
   // Each connecting socket will eventually connect and be handed out.
-  int total = handed_out_socket_count_ + connecting_socket_count_ +
-      idle_socket_count();
+  int total =
+      handed_out_socket_count_ + connecting_socket_count_ + idle_socket_count();
   // There can be more sockets than the limit since some requests can ignore
   // the limit
   if (total < max_sockets_)
     return false;
   return true;
 }
 
 bool ClientSocketPoolBaseHelper::CloseOneIdleSocket() {
   if (idle_socket_count() == 0)
     return false;
@@ skipping 22 matching lines @@
   }
 
   return false;
 }
 
 bool ClientSocketPoolBaseHelper::CloseOneIdleConnectionInHigherLayeredPool() {
   // This pool doesn't have any idle sockets. It's possible that a pool at a
   // higher layer is holding one of this sockets active, but it's actually idle.
   // Query the higher layers.
   for (std::set<HigherLayeredPool*>::const_iterator it = higher_pools_.begin();
-       it != higher_pools_.end(); ++it) {
+       it != higher_pools_.end();
+       ++it) {
     if ((*it)->CloseOneIdleConnection())
       return true;
   }
   return false;
 }
 
 void ClientSocketPoolBaseHelper::InvokeUserCallbackLater(
-    ClientSocketHandle* handle, const CompletionCallback& callback, int rv) {
+    ClientSocketHandle* handle,
+    const CompletionCallback& callback,
+    int rv) {
   CHECK(!ContainsKey(pending_callback_map_, handle));
   pending_callback_map_[handle] = CallbackResultPair(callback, rv);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ClientSocketPoolBaseHelper::InvokeUserCallback,
-                 weak_factory_.GetWeakPtr(), handle));
+                 weak_factory_.GetWeakPtr(),
+                 handle));
 }
 
 void ClientSocketPoolBaseHelper::InvokeUserCallback(
     ClientSocketHandle* handle) {
   PendingCallbackMap::iterator it = pending_callback_map_.find(handle);
 
   // Exit if the request has already been cancelled.
   if (it == pending_callback_map_.end())
     return;
 
   CHECK(!handle->is_initialized());
   CompletionCallback callback = it->second.callback;
   int result = it->second.result;
   pending_callback_map_.erase(it);
   callback.Run(result);
 }
 
 void ClientSocketPoolBaseHelper::TryToCloseSocketsInLayeredPools() {
   while (IsStalled()) {
     // Closing a socket will result in calling back into |this| to use the freed
     // socket slot, so nothing else is needed.
     if (!CloseOneIdleConnectionInHigherLayeredPool())
       return;
   }
 }
 
 ClientSocketPoolBaseHelper::Group::Group()
     : unassigned_job_count_(0),
       pending_requests_(NUM_PRIORITIES),
-      active_socket_count_(0) {}
+      active_socket_count_(0) {
+}
 
 ClientSocketPoolBaseHelper::Group::~Group() {
   DCHECK_EQ(0u, unassigned_job_count_);
 }
 
 void ClientSocketPoolBaseHelper::Group::StartBackupJobTimer(
     const std::string& group_name,
     ClientSocketPoolBaseHelper* pool) {
   // Only allow one timer to run at a time.
   if (BackupJobTimerIsRunning())
     return;
 
   // Unretained here is okay because |backup_job_timer_| is
   // automatically cancelled when it's destroyed.
-  backup_job_timer_.Start(
-      FROM_HERE, pool->ConnectRetryInterval(),
-      base::Bind(&Group::OnBackupJobTimerFired, base::Unretained(this),
-                 group_name, pool));
+  backup_job_timer_.Start(FROM_HERE,
+                          pool->ConnectRetryInterval(),
+                          base::Bind(&Group::OnBackupJobTimerFired,
+                                     base::Unretained(this),
+                                     group_name,
+                                     pool));
 }
 
 bool ClientSocketPoolBaseHelper::Group::BackupJobTimerIsRunning() const {
   return backup_job_timer_.IsRunning();
 }
 
 bool ClientSocketPoolBaseHelper::Group::TryToUseUnassignedConnectJob() {
   SanityCheck();
 
   if (unassigned_job_count_ == 0)
@@ skipping 46 matching lines @@
   if (pool->ReachedMaxSocketsLimit() ||
       !HasAvailableSocketSlot(pool->max_sockets_per_group_) ||
       (*jobs_.begin())->GetLoadState() == LOAD_STATE_RESOLVING_HOST) {
     StartBackupJobTimer(group_name, pool);
     return;
   }
 
   if (pending_requests_.empty())
     return;
 
-  scoped_ptr<ConnectJob> backup_job =
-      pool->connect_job_factory_->NewConnectJob(
-          group_name, *pending_requests_.FirstMax().value(), pool);
+  scoped_ptr<ConnectJob> backup_job = pool->connect_job_factory_->NewConnectJob(
+      group_name, *pending_requests_.FirstMax().value(), pool);
   backup_job->net_log().AddEvent(NetLog::TYPE_BACKUP_CONNECT_JOB_CREATED);
   SIMPLE_STATS_COUNTER("socket.backup_created");
   int rv = backup_job->Connect();
   pool->connecting_socket_count_++;
   ConnectJob* raw_backup_job = backup_job.get();
   AddJob(backup_job.Pass(), false);
   if (rv != ERR_IO_PENDING)
     pool->OnConnectJobComplete(rv, raw_backup_job);
 }
 
 void ClientSocketPoolBaseHelper::Group::SanityCheck() {
   DCHECK_LE(unassigned_job_count_, jobs_.size());
 }
 
 void ClientSocketPoolBaseHelper::Group::RemoveAllJobs() {
   SanityCheck();
 
   // Delete active jobs.
   STLDeleteElements(&jobs_);
   unassigned_job_count_ = 0;
 
   // Stop backup job timer.
   backup_job_timer_.Stop();
 }
 
 const ClientSocketPoolBaseHelper::Request*
 ClientSocketPoolBaseHelper::Group::GetNextPendingRequest() const {
-  return
-      pending_requests_.empty() ? NULL : pending_requests_.FirstMax().value();
+  return pending_requests_.empty() ? NULL
+                                   : pending_requests_.FirstMax().value();
 }
 
 bool ClientSocketPoolBaseHelper::Group::HasConnectJobForHandle(
     const ClientSocketHandle* handle) const {
   // Search the first |jobs_.size()| pending requests for |handle|.
   // If it's farther back in the deque than that, it doesn't have a
   // corresponding ConnectJob.
   size_t i = 0;
   for (RequestQueue::Pointer pointer = pending_requests_.FirstMax();
        !pointer.is_null() && i < jobs_.size();
@@ skipping 47 matching lines @@
   pending_requests_.Erase(pointer);
   // If there are no more requests, kill the backup timer.
   if (pending_requests_.empty())
     backup_job_timer_.Stop();
   return request.Pass();
 }
 
 }  // namespace internal
 
 }  // namespace net