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

chrome/browser/net/predictor.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 "chrome/browser/net/predictor.h"
 
 #include <algorithm>
 #include <cmath>
 #include <set>
 #include <sstream>
@@ skipping 142 matching lines @@
 void Predictor::InitNetworkPredictor(PrefService* user_prefs,
                                      IOThread* io_thread,
                                      net::URLRequestContextGetter* getter,
                                      ProfileIOData* profile_io_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   user_prefs_ = user_prefs;
   url_request_context_getter_ = getter;
 
   // Gather the list of hostnames to prefetch on startup.
-  UrlList urls = GetPredictedUrlListAtStartup(user_prefs);
+  std::vector<GURL> urls = GetPredictedUrlListAtStartup(user_prefs);
 
   base::ListValue* referral_list =
       static_cast<base::ListValue*>(user_prefs->GetList(
           prefs::kDnsPrefetchingHostReferralList)->DeepCopy());
 
   // Now that we have the statistics in memory, wipe them from the Preferences
   // file. They will be serialized back on a clean shutdown. This way we only
   // have to worry about clearing our in-memory state when Clearing Browsing
   // Data.
   user_prefs->ClearPref(prefs::kDnsPrefetchingStartupList);
@@ skipping 95 matching lines @@
   if (!CanPreresolveAndPreconnect())
     return;
 
   UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
   const int kConnectionsNeeded = 1;
   PreconnectUrl(CanonicalizeUrl(url), first_party_for_cookies, motivation,
                 kConnectionsNeeded, kAllowCredentialsOnPreconnectByDefault);
   PredictFrameSubresources(url.GetWithEmptyPath(), first_party_for_cookies);
 }
 
-UrlList Predictor::GetPredictedUrlListAtStartup(PrefService* user_prefs) {
+std::vector<GURL> Predictor::GetPredictedUrlListAtStartup(
+    PrefService* user_prefs) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  UrlList urls;
+  std::vector<GURL> urls;
   // Recall list of URLs we learned about during last session.
   // This may catch secondary hostnames, pulled in by the homepages.  It will
   // also catch more of the "primary" home pages, since that was (presumably)
   // rendered first (and will be rendered first this time too).
   const base::ListValue* startup_list =
       user_prefs->GetList(prefs::kDnsPrefetchingStartupList);
 
   if (startup_list) {
     base::ListValue::const_iterator it = startup_list->begin();
     int format_version = -1;
@@ skipping 99 matching lines @@
          assignees.size() <= max_concurrent_dns_lookups_);
   results_.clear();
   // Put back in the names being worked on.
   for (Results::iterator it = assignees.begin(); assignees.end() != it; ++it) {
     DCHECK(it->second.is_marked_to_delete());
     results_[it->first] = it->second;
   }
 }
 
 // Overloaded Resolve() to take a vector of names.
-void Predictor::ResolveList(const UrlList& urls,
+void Predictor::ResolveList(const std::vector<GURL>& urls,
                             UrlInfo::ResolutionMotivation motivation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  for (UrlList::const_iterator it = urls.begin(); it < urls.end(); ++it) {
+  for (std::vector<GURL>::const_iterator it = urls.begin(); it < urls.end();
+       ++it) {
     AppendToResolutionQueue(*it, motivation);
   }
 }
 
 // Basic Resolve() takes an invidual name, and adds it
 // to the queue.
 void Predictor::Resolve(const GURL& url,
                         UrlInfo::ResolutionMotivation motivation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!url.has_host())
@@ skipping 220 matching lines @@
   delete referral_list;
 }
 
 void Predictor::DiscardInitialNavigationHistory() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (initial_observer_.get())
     initial_observer_->DiscardInitialNavigationHistory();
 }
 
 void Predictor::FinalizeInitializationOnIOThread(
-    const UrlList& startup_urls,
+    const std::vector<GURL>& startup_urls,
     base::ListValue* referral_list,
     IOThread* io_thread,
     ProfileIOData* profile_io_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   profile_io_data_ = profile_io_data;
   initial_observer_.reset(new InitialObserver());
 
   net::URLRequestContext* context =
       url_request_context_getter_->GetURLRequestContext();
@@ skipping 27 matching lines @@
       !CanPreresolveAndPreconnect()) {
     return;
   }
   initial_observer_->Append(url, this);
 }
 
 // This API is only used in the browser process.
 // It is called from an IPC message originating in the renderer.  It currently
 // includes both Page-Scan, and Link-Hover prefetching.
 // TODO(jar): Separate out link-hover prefetching, and page-scan results.
-void Predictor::DnsPrefetchList(const NameList& hostnames) {
+void Predictor::DnsPrefetchList(const std::vector<std::string>& hostnames) {
   // TODO(jar): Push GURL transport further back into renderer, but this will
   // require a Webkit change in the observer :-/.
-  UrlList urls;
-  for (NameList::const_iterator it = hostnames.begin();
-       it < hostnames.end();
-       ++it) {
+  std::vector<GURL> urls;
+  for (std::vector<std::string>::const_iterator it = hostnames.begin();
+       it < hostnames.end(); ++it) {
     urls.push_back(GURL("http://" + *it + ":80"));
   }
 
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DnsPrefetchMotivatedList(urls, UrlInfo::PAGE_SCAN_MOTIVATED);
 }
 
 void Predictor::DnsPrefetchMotivatedList(
-    const UrlList& urls,
+    const std::vector<GURL>& urls,
     UrlInfo::ResolutionMotivation motivation) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_)
     return;
   if (!CanPreresolveAndPreconnect())
     return;
 
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     ResolveList(urls, motivation);
@@ skipping 593 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net