net: Use stl utilities from the base namespace

net/spdy/spdy_session_pool.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/spdy/spdy_session_pool.h"
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 176 matching lines @@
 
     AvailableSessionMap::iterator available_session_it =
         LookupAvailableSessionByKey(alias_key);
     if (available_session_it == available_sessions_.end()) {
       NOTREACHED();  // It shouldn't be in the aliases table if we can't get it!
       continue;
     }
 
     const base::WeakPtr<SpdySession>& available_session =
         available_session_it->second;
-    DCHECK(ContainsKey(sessions_, available_session.get()));
+    DCHECK(base::ContainsKey(sessions_, available_session.get()));
     // If the session is a secure one, we need to verify that the
     // server is authenticated to serve traffic for |host_port_proxy_pair| too.
     if (!available_session->VerifyDomainAuthentication(
             key.host_port_pair().host())) {
       UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 0, 2);
       continue;
     }
 
     UMA_HISTOGRAM_ENUMERATION("Net.SpdyIPPoolDomainMatch", 1, 2);
     UMA_HISTOGRAM_ENUMERATION("Net.SpdySessionGet",
@@ skipping 58 matching lines @@
     CloseCurrentSessionsHelper(ERR_ABORTED, "Closing all sessions.",
                                false /* idle_only */);
   }
 }
 
 void SpdySessionPool::RegisterUnclaimedPushedStream(
     GURL url,
     base::WeakPtr<SpdySession> spdy_session) {
   DCHECK(!url.is_empty());
   // This SpdySessionPool  must own |spdy_session|.
-  DCHECK(ContainsKey(sessions_, spdy_session.get()));
+  DCHECK(base::ContainsKey(sessions_, spdy_session.get()));
   UnclaimedPushedStreamMap::iterator url_it =
       unclaimed_pushed_streams_.lower_bound(url);
   if (url_it == unclaimed_pushed_streams_.end() || url_it->first != url) {
     WeakSessionList list;
     list.push_back(std::move(spdy_session));
     UnclaimedPushedStreamMap::value_type value(std::move(url), std::move(list));
     unclaimed_pushed_streams_.insert(url_it, std::move(value));
     return;
   }
   url_it->second.push_back(spdy_session);
@@ skipping 90 matching lines @@
        it != available_sessions_.end(); ++it) {
     if (it->second.get() == session.get())
       return true;
   }
   return false;
 }
 
 void SpdySessionPool::MapKeyToAvailableSession(
     const SpdySessionKey& key,
     const base::WeakPtr<SpdySession>& session) {
-  DCHECK(ContainsKey(sessions_, session.get()));
+  DCHECK(base::ContainsKey(sessions_, session.get()));
   std::pair<AvailableSessionMap::iterator, bool> result =
       available_sessions_.insert(std::make_pair(key, session));
   CHECK(result.second);
 }
 
 SpdySessionPool::AvailableSessionMap::iterator
 SpdySessionPool::LookupAvailableSessionByKey(
     const SpdySessionKey& key) {
   return available_sessions_.find(key);
 }
@@ skipping 39 matching lines @@
 
     if (idle_only && (*it)->is_active())
       continue;
 
     (*it)->CloseSessionOnError(error, description);
     DCHECK(!IsSessionAvailable(*it));
   }
 }
 
 }  // namespace net