chrome: Use stl utilities from the base namespace

chrome/browser/net/predictor_browsertest.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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <set>
@@ skipping 384 matching lines @@
       DCHECK(!dns_run_loop_);
       waiting_on_dns_ = url;
       dns_run_loop_ = &run_loop;
       CheckForWaitingLoop();
     }
     run_loop.Run();
   }
 
   bool HasHostBeenLookedUpLocked(const GURL& url) {
     lock_.AssertAcquired();
-    return ContainsKey(successful_dns_lookups_, url) ||
-           ContainsKey(unsuccessful_dns_lookups_, url);
+    return base::ContainsKey(successful_dns_lookups_, url) ||
+           base::ContainsKey(unsuccessful_dns_lookups_, url);
   }
 
   bool HasHostBeenLookedUp(const GURL& url) {
     base::AutoLock lock(lock_);
     return HasHostBeenLookedUpLocked(url);
   }
 
   void CheckForWaitingLoop() {
     lock_.AssertAcquired();
     if (waiting_on_dns_.is_empty())
@@ skipping 10 matching lines @@
   size_t TotalHostsLookedUp() {
     base::AutoLock lock(lock_);
     return successful_dns_lookups_.size() + unsuccessful_dns_lookups_.size();
   }
 
   // Note: this method expects the URL to have been looked up.
   bool HostFound(const GURL& url) {
     base::AutoLock lock(lock_);
     EXPECT_TRUE(HasHostBeenLookedUpLocked(url)) << "Expected to have looked up "
                                                 << url.spec();
-    return ContainsKey(successful_dns_lookups_, url);
+    return base::ContainsKey(successful_dns_lookups_, url);
   }
 
   void set_task_runner(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
     task_runner_.swap(task_runner);
   }
 
   // Optionally allows the object to observe preconnects / learning from other
   // hosts.
   void SetStrict(bool strict) {
@@ skipping 271 matching lines @@
   // attached.
   void ExpectUrlRequestedFromPredictorOnUIThread(const GURL& url) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PredictorBrowserTest::ExpectUrlRequestedFromPredictor,
                    base::Unretained(this), url));
   }
 
   void ExpectUrlRequestedFromPredictor(const GURL& url) {
-    EXPECT_TRUE(ContainsKey(predictor()->results_, url));
+    EXPECT_TRUE(base::ContainsKey(predictor()->results_, url));
   }
 
   void DiscardAllResultsOnUIThread() {
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::Bind(&Predictor::DiscardAllResults,
                                        base::Unretained(predictor())));
   }
 
   void ExpectValidPeakPendingLookupsOnUI(size_t num_names_requested) {
     BrowserThread::PostTask(
@@ skipping 821 matching lines @@
   // Second navigation to content with an img.
   std::string img_content =
       "<img src=\"" + preconnect_url.spec() + "test.gif\">";
   NavigateToDataURLWithContent(img_content);
   connection_listener_->WaitUntilFirstConnectionRead();
   EXPECT_EQ(2u, connection_listener_->GetAcceptedSocketCount());
   EXPECT_EQ(1u, connection_listener_->GetReadSocketCount());
 }
 
 }  // namespace chrome_browser_net