Remove references to network_hints::UrlList and network_hints::NameList

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 606 matching lines @@
   }
 
   void GetListFromPrefsAsString(const char* list_path,
                                 std::string* value_as_string) const {
     PrefService* prefs = browser()->profile()->GetPrefs();
     const base::ListValue* list_value = prefs->GetList(list_path);
     JSONStringValueSerializer serializer(value_as_string);
     serializer.Serialize(*list_value);
   }
 
-  void WaitUntilHostsLookedUp(const network_hints::UrlList& names) {
+  void WaitUntilHostsLookedUp(const std::vector<GURL>& names) {
     for (const GURL& url : names)
       observer()->WaitUntilHostLookedUp(url);
   }
 
-  void FloodResolveRequestsOnUIThread(const network_hints::UrlList& names) {
+  void FloodResolveRequestsOnUIThread(const std::vector<GURL>& names) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&PredictorBrowserTest::FloodResolveRequests, this, names));
   }
 
-  void FloodResolveRequests(const network_hints::UrlList& names) {
+  void FloodResolveRequests(const std::vector<GURL>& names) {
     DCHECK_CURRENTLY_ON(BrowserThread::IO);
     for (int i = 0; i < 10; i++) {
       predictor()->DnsPrefetchMotivatedList(names,
                                             UrlInfo::PAGE_SCAN_MOTIVATED);
     }
   }
 
   net::EmbeddedTestServer* cross_site_test_server() {
     return cross_site_test_server_.get();
   }
@@ skipping 43 matching lines @@
     run_loop.Run();
   }
 
   void FlushServerSocketsOnUIThread(net::EmbeddedTestServer* test_server) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     EXPECT_TRUE(test_server->FlushAllSocketsAndConnectionsOnUIThread());
   }
 
   // Note this method also expects that all the urls (found or not) were looked
   // up.
-  void ExpectFoundUrls(
-      const network_hints::UrlList& found_names,
-      const network_hints::UrlList& not_found_names) {
+  void ExpectFoundUrls(const std::vector<GURL>& found_names,
+                       const std::vector<GURL>& not_found_names) {
     for (const auto& name : found_names) {
       EXPECT_TRUE(observer()->HostFound(name)) << "Expected to have found "
                                                << name.spec();
     }
     for (const auto& name : not_found_names) {
       EXPECT_FALSE(observer()->HostFound(name)) << "Did not expect to find "
                                                 << name.spec();
     }
   }
 
@@ skipping 68 matching lines @@
   std::unique_ptr<net::EmbeddedTestServer> cross_site_test_server_;
   std::unique_ptr<CrossSitePredictorObserver> observer_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 };
 
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, SingleLookupTest) {
   DiscardAllResultsOnUIThread();
   GURL url("http://www.example.test/");
 
   // Try to flood the predictor with many concurrent requests.
-  network_hints::UrlList names{url};
+  std::vector<GURL> names{url};
   FloodResolveRequestsOnUIThread(names);
   observer()->WaitUntilHostLookedUp(url);
   EXPECT_TRUE(observer()->HostFound(url));
   ExpectValidPeakPendingLookupsOnUI(1u);
 }
 
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, ConcurrentLookupTest) {
   DiscardAllResultsOnUIThread();
   GURL url("http://www.example.test"), goog2("http://gmail.google.com"),
       goog3("http://mail.google.com"), goog4("http://gmail.com");
   GURL bad1("http://bad1.notfound"), bad2("http://bad2.notfound");
 
-  UrlList found_names{url, goog3, goog2, goog4};
-  UrlList not_found_names{bad1, bad2};
+  std::vector<GURL> found_names{url, goog3, goog2, goog4};
+  std::vector<GURL> not_found_names{bad1, bad2};
   FloodResolveRequestsOnUIThread(found_names);
   FloodResolveRequestsOnUIThread(not_found_names);
 
   WaitUntilHostsLookedUp(found_names);
   WaitUntilHostsLookedUp(not_found_names);
   ExpectFoundUrls(found_names, not_found_names);
   ExpectValidPeakPendingLookupsOnUI(found_names.size() +
                                     not_found_names.size());
 }
 
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest, MassiveConcurrentLookupTest) {
   DiscardAllResultsOnUIThread();
-  UrlList not_found_names;
+  std::vector<GURL> not_found_names;
   for (int i = 0; i < 100; i++) {
     not_found_names.push_back(
         GURL(base::StringPrintf("http://host%d.notfound:80", i)));
   }
   FloodResolveRequestsOnUIThread(not_found_names);
 
   WaitUntilHostsLookedUp(not_found_names);
-  ExpectFoundUrls(network_hints::UrlList(), not_found_names);
+  ExpectFoundUrls(std::vector<GURL>(), not_found_names);
   ExpectValidPeakPendingLookupsOnUI(not_found_names.size());
 }
 
 IN_PROC_BROWSER_TEST_F(PredictorBrowserTest,
                        ShutdownWhenResolutionIsPendingTest) {
   GURL delayed_url("http://delay.google.com:80");
-  UrlList names{delayed_url};
+  std::vector<GURL> names{delayed_url};
 
   // Flood with delayed requests, then wait.
   FloodResolveRequestsOnUIThread(names);
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::MessageLoop::QuitWhenIdleClosure(),
       base::TimeDelta::FromMilliseconds(500));
   base::MessageLoop::current()->Run();
 
   ExpectUrlRequestedFromPredictor(delayed_url);
   EXPECT_FALSE(observer()->HasHostBeenLookedUp(delayed_url));
@@ skipping 656 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