net: Use stl utilities from the base namespace

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 <algorithm>
 #include <utility>
 
 #include "base/compiler_specific.h"
@@ skipping 222 matching lines @@
        it != group_map_.end(); ++it) {
     if (it->second->CanUseAdditionalSocketSlot(max_sockets_per_group_))
       return true;
   }
   return false;
 }
 
 void ClientSocketPoolBaseHelper::AddLowerLayeredPool(
     LowerLayeredPool* lower_pool) {
   DCHECK(pool_);
-  CHECK(!ContainsKey(lower_pools_, lower_pool));
+  CHECK(!base::ContainsKey(lower_pools_, lower_pool));
   lower_pools_.insert(lower_pool);
   lower_pool->AddHigherLayeredPool(pool_);
 }
 
 void ClientSocketPoolBaseHelper::AddHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   CHECK(higher_pool);
-  CHECK(!ContainsKey(higher_pools_, higher_pool));
+  CHECK(!base::ContainsKey(higher_pools_, higher_pool));
   higher_pools_.insert(higher_pool);
 }
 
 void ClientSocketPoolBaseHelper::RemoveHigherLayeredPool(
     HigherLayeredPool* higher_pool) {
   CHECK(higher_pool);
-  CHECK(ContainsKey(higher_pools_, higher_pool));
+  CHECK(base::ContainsKey(higher_pools_, higher_pool));
   higher_pools_.erase(higher_pool);
 }
 
 int ClientSocketPoolBaseHelper::RequestSocket(
     const std::string& group_name,
     std::unique_ptr<const Request> request) {
   CHECK(!request->callback().is_null());
   CHECK(request->handle());
 
   // Cleanup any timed-out idle sockets.
@@ skipping 46 matching lines @@
   // 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--) {
     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))
+      if (!base::ContainsKey(group_map_, group_name))
         deleted_group = true;
       break;
     }
-    if (!ContainsKey(group_map_, group_name)) {
+    if (!base::ContainsKey(group_map_, group_name)) {
       // Unexpected.  The group should only be getting deleted on synchronous
       // error.
       NOTREACHED();
       deleted_group = true;
       break;
     }
   }
 
   if (!deleted_group && group->IsEmpty())
     RemoveGroup(group_name);
@@ skipping 175 matching lines @@
     pending_callback_map_.erase(callback_it);
     std::unique_ptr<StreamSocket> socket = handle->PassSocket();
     if (socket) {
       if (result != OK)
         socket->Disconnect();
       ReleaseSocket(handle->group_name(), std::move(socket), handle->id());
     }
     return;
   }
 
-  CHECK(ContainsKey(group_map_, group_name));
+  CHECK(base::ContainsKey(group_map_, group_name));
 
   Group* group = GetOrCreateGroup(group_name);
 
   // Search pending_requests for matching handle.
   std::unique_ptr<const Request> request =
       group->FindAndRemovePendingRequest(handle);
   if (request) {
     request->net_log().AddEvent(NetLog::TYPE_CANCELLED);
     request->net_log().EndEvent(NetLog::TYPE_SOCKET_POOL);
 
     // We let the job run, unless we're at the socket limit and there is
     // not another request waiting on the job.
     if (group->jobs().size() > group->pending_request_count() &&
         ReachedMaxSocketsLimit()) {
       RemoveConnectJob(*group->jobs().begin(), group);
       CheckForStalledSocketGroups();
     }
   }
 }
 
 bool ClientSocketPoolBaseHelper::HasGroup(const std::string& group_name) const {
-  return ContainsKey(group_map_, group_name);
+  return base::ContainsKey(group_map_, group_name);
 }
 
 void ClientSocketPoolBaseHelper::CloseIdleSockets() {
   CleanupIdleSockets(true);
   DCHECK_EQ(0, idle_socket_count_);
 }
 
 int ClientSocketPoolBaseHelper::IdleSocketCountInGroup(
     const std::string& group_name) const {
   GroupMap::const_iterator i = group_map_.find(group_name);
   CHECK(i != group_map_.end());
 
   return i->second->idle_sockets().size();
 }
 
 LoadState ClientSocketPoolBaseHelper::GetLoadState(
     const std::string& group_name,
     const ClientSocketHandle* handle) const {
-  if (ContainsKey(pending_callback_map_, handle))
+  if (base::ContainsKey(pending_callback_map_, handle))
     return LOAD_STATE_CONNECTING;
 
   GroupMap::const_iterator group_it = group_map_.find(group_name);
   if (group_it == group_map_.end()) {
     // TODO(mmenke):  This is actually reached in the wild, for unknown reasons.
     // Would be great to understand why, and if it's a bug, fix it.  If not,
     // should have a test for that case.
     NOTREACHED();
     return LOAD_STATE_IDLE;
   }
@@ skipping 344 matching lines @@
                                                   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) {
-  DCHECK(ContainsKey(group_map_, group_name));
+  DCHECK(base::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 Request* next_request = group->GetNextPendingRequest();
@@ skipping 161 matching lines @@
   for (std::set<HigherLayeredPool*>::const_iterator it = higher_pools_.begin();
        it != higher_pools_.end(); ++it) {
     if ((*it)->CloseOneIdleConnection())
       return true;
   }
   return false;
 }
 
 void ClientSocketPoolBaseHelper::InvokeUserCallbackLater(
     ClientSocketHandle* handle, const CompletionCallback& callback, int rv) {
-  CHECK(!ContainsKey(pending_callback_map_, handle));
+  CHECK(!base::ContainsKey(pending_callback_map_, handle));
   pending_callback_map_[handle] = CallbackResultPair(callback, rv);
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&ClientSocketPoolBaseHelper::InvokeUserCallback,
                             weak_factory_.GetWeakPtr(), handle));
 }
 
 void ClientSocketPoolBaseHelper::InvokeUserCallback(
     ClientSocketHandle* handle) {
   PendingCallbackMap::iterator it = pending_callback_map_.find(handle);
 
@@ skipping 115 matching lines @@
 }
 
 void ClientSocketPoolBaseHelper::Group::SanityCheck() {
   DCHECK_LE(unassigned_job_count_, jobs_.size());
 }
 
 void ClientSocketPoolBaseHelper::Group::RemoveAllJobs() {
   SanityCheck();
 
   // Delete active jobs.
-  STLDeleteElements(&jobs_);
+  base::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();
@@ skipping 60 matching lines @@
   // If there are no more requests, kill the backup timer.
   if (pending_requests_.empty())
     backup_job_timer_.Stop();
   request->CrashIfInvalid();
   return request;
 }
 
 }  // namespace internal
 
 }  // namespace net