Add a Dns preresolve interface in //content

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 86 matching lines @@
 
 static int g_max_queueing_delay_ms =
     Predictor::kMaxSpeculativeResolveQueueDelayMs;
 static size_t g_max_parallel_resolves =
     Predictor::kMaxSpeculativeParallelResolves;
 
 // A version number for prefs that are saved. This should be incremented when
 // we change the format so that we discard old data.
 static const int kPredictorStartupFormatVersion = 1;
 
-class Predictor::LookupRequest {
- public:
-  LookupRequest(Predictor* predictor,
-                net::HostResolver* host_resolver,
-                const GURL& url)
-      : predictor_(predictor),
-        url_(url),
-        resolver_(host_resolver) {
-  }
-
-  // Return underlying network resolver status.
-  // net::OK ==> Host was found synchronously.
-  // net:ERR_IO_PENDING ==> Network will callback later with result.
-  // anything else ==> Host was not found synchronously.
-  int Start() {
-    net::HostResolver::RequestInfo resolve_info(
-        net::HostPortPair::FromURL(url_));
-
-    // Make a note that this is a speculative resolve request. This allows us
-    // to separate it from real navigations in the observer's callback, and
-    // lets the HostResolver know it can de-prioritize it.
-    resolve_info.set_is_speculative(true);
-    return resolver_.Resolve(
-        resolve_info,
-        net::DEFAULT_PRIORITY,
-        &addresses_,
-        base::Bind(&LookupRequest::OnLookupFinished, base::Unretained(this)),
-        net::BoundNetLog());
-  }
-
- private:
-  void OnLookupFinished(int result) {
-    predictor_->OnLookupFinished(this, url_, result == net::OK);
-  }
-
-  Predictor* predictor_;  // The predictor which started us.
-
-  const GURL url_;  // Hostname to resolve.
-  net::SingleRequestHostResolver resolver_;
-  net::AddressList addresses_;
-
-  DISALLOW_COPY_AND_ASSIGN(LookupRequest);
-};
-
 Predictor::Predictor(bool preconnect_enabled, bool predictor_enabled)
-    : url_request_context_getter_(NULL),
+    : url_request_context_getter_(nullptr),
       predictor_enabled_(predictor_enabled),
-      user_prefs_(NULL),
-      profile_io_data_(NULL),
+      user_prefs_(nullptr),
+      profile_io_data_(nullptr),
+      num_pending_lookups_(0),
       peak_pending_lookups_(0),
       shutdown_(false),
       max_concurrent_dns_lookups_(g_max_parallel_resolves),
       max_dns_queue_delay_(
           TimeDelta::FromMilliseconds(g_max_queueing_delay_ms)),
-      host_resolver_(NULL),
-      transport_security_state_(NULL),
-      ssl_config_service_(NULL),
-      proxy_service_(NULL),
+      transport_security_state_(nullptr),
+      ssl_config_service_(nullptr),
+      proxy_service_(nullptr),
       preconnect_enabled_(preconnect_enabled),
       consecutive_omnibox_preconnect_count_(0),
       next_trim_time_(base::TimeTicks::Now() +
                       TimeDelta::FromHours(kDurationBetweenTrimmingsHours)),
-      observer_(NULL) {
+      observer_(nullptr) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 Predictor::~Predictor() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(shutdown_);
 }
 
 // static
 Predictor* Predictor::CreatePredictor(bool preconnect_enabled,
@@ skipping 211 matching lines @@
 }
 
 // ---------------------- End UI methods. -------------------------------------
 
 // --------------------- Start IO methods. ------------------------------------
 
 void Predictor::Shutdown() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(!shutdown_);
   shutdown_ = true;
-
-  STLDeleteElements(&pending_lookups_);
 }
 
 void Predictor::DiscardAllResults() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   // Delete anything listed so far in this session that shows in about:dns.
   referrers_.clear();
 
 
   // Try to delete anything in our work queue.
   while (!work_queue_.IsEmpty()) {
     // Emulate processing cycle as though host was not found.
     GURL url = work_queue_.Pop();
     UrlInfo* info = &results_[url];
     DCHECK(info->HasUrl(url));
     info->SetAssignedState();
     info->SetNoSuchNameState();
   }
-  // Now every result_ is either resolved, or is being resolved
-  // (see LookupRequest).
+  // Now every result_ is either resolved, or is being resolved.
 
   // Step through result_, recording names of all hosts that can't be erased.
   // We can't erase anything being worked on.
   Results assignees;
   for (Results::iterator it = results_.begin(); results_.end() != it; ++it) {
     GURL url(it->first);
     UrlInfo* info = &it->second;
     DCHECK(info->HasUrl(url));
     if (info->is_assigned()) {
       info->SetPendingDeleteState();
@@ skipping 254 matching lines @@
 
 void Predictor::FinalizeInitializationOnIOThread(
     const UrlList& 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());
-  host_resolver_ = io_thread->globals()->host_resolver.get();
 
   net::URLRequestContext* context =
       url_request_context_getter_->GetURLRequestContext();
   transport_security_state_ = context->transport_security_state();
   ssl_config_service_ = context->ssl_config_service();
   proxy_service_ = context->proxy_service();
 
   // base::WeakPtrFactory instances need to be created and destroyed
   // on the same thread. The predictor lives on the IO thread and will die
   // from there so now that we're on the IO thread we need to properly
   // initialize the base::WeakPtrFactory.
   // TODO(groby): Check if WeakPtrFactory has the same constraint.
   weak_factory_.reset(new base::WeakPtrFactory<Predictor>(this));
 
   // Prefetch these hostnames on startup.
   DnsPrefetchMotivatedList(startup_urls, UrlInfo::STARTUP_LIST_MOTIVATED);
 
   DeserializeReferrersThenDelete(referral_list);
 }
 
 //-----------------------------------------------------------------------------
 // This section intermingles prefetch results with actual browser HTTP
 // network activity.  It supports calculating of the benefit of a prefetch, as
 // well as recording what prefetched hostname resolutions might be potentially
 // helpful during the next chrome-startup.
 //-----------------------------------------------------------------------------
 
 void Predictor::LearnAboutInitialNavigation(const GURL& url) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (!predictor_enabled_ || NULL == initial_observer_.get() ||
+  if (!predictor_enabled_ || nullptr == initial_observer_.get() ||
       !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.
@@ skipping 36 matching lines @@
 // Functions to handle saving of hostnames from one session to the next, to
 // expedite startup times.
 
 static void SaveDnsPrefetchStateForNextStartupAndTrimOnIOThread(
     base::ListValue* startup_list,
     base::ListValue* referral_list,
     base::WaitableEvent* completion,
     Predictor* predictor) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  if (NULL == predictor) {
+  if (nullptr == predictor) {
     completion->Signal();
     return;
   }
   predictor->SaveDnsPrefetchStateForNextStartupAndTrim(
       startup_list, referral_list, completion);
 }
 
 void Predictor::SaveStateForNextStartupAndTrim() {
   if (!predictor_enabled_)
     return;
@@ skipping 75 matching lines @@
 void Predictor::PreconnectUrlOnIOThread(
     const GURL& original_url,
     const GURL& first_party_for_cookies,
     UrlInfo::ResolutionMotivation motivation,
     bool allow_credentials,
     int count) {
   // Skip the HSTS redirect.
   GURL url = GetHSTSRedirectOnIOThread(original_url);
 
   // TODO(csharrison): The observer should only be notified after the null check
-  // for the URLRequestContextGetter. The predictor tests should be fixed to
-  // allow for this, as they currently expect a callback with no getter.
-  // URLRequestContextGetter is null. Tests rely on this behavior.
+  // for the ProfileIOData. The predictor tests should be fixed to allow for
+  // this, as they currently expect a callback with no getter.
   if (observer_) {
     observer_->OnPreconnectUrl(
         url, first_party_for_cookies, motivation, count);
   }
 
-  net::URLRequestContextGetter* getter = url_request_context_getter_.get();
-  if (!getter)
+  if (!profile_io_data_)
     return;
 
   // Translate the motivation from UrlRequest motivations to HttpRequest
   // motivations.
   net::HttpRequestInfo::RequestMotivation request_motivation =
       net::HttpRequestInfo::NORMAL_MOTIVATION;
   switch (motivation) {
     case UrlInfo::OMNIBOX_MOTIVATED:
       request_motivation = net::HttpRequestInfo::OMNIBOX_MOTIVATED;
       break;
     case UrlInfo::LEARNED_REFERAL_MOTIVATED:
       request_motivation = net::HttpRequestInfo::PRECONNECT_MOTIVATED;
       break;
     case UrlInfo::MOUSE_OVER_MOTIVATED:
     case UrlInfo::SELF_REFERAL_MOTIVATED:
     case UrlInfo::EARLY_LOAD_MOTIVATED:
       request_motivation = net::HttpRequestInfo::EARLY_LOAD_MOTIVATED;
       break;
     default:
       // Other motivations should never happen here.
       NOTREACHED();
       break;
   }
   UMA_HISTOGRAM_ENUMERATION("Net.PreconnectMotivation", motivation,
                             UrlInfo::MAX_MOTIVATED);
-  content::PreconnectUrl(getter, url, first_party_for_cookies, count,
-                         allow_credentials, request_motivation);
+  content::PreconnectUrl(profile_io_data_->GetResourceContext(), url,
+                         first_party_for_cookies, count, allow_credentials,
+                         request_motivation);
 }
 
 void Predictor::PredictFrameSubresources(const GURL& url,
                                          const GURL& first_party_for_cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_)
     return;
   if (!CanPreresolveAndPreconnect())
     return;
@@ skipping 90 matching lines @@
       UrlInfo* queued_info = AppendToResolutionQueue(future_url->first,
                                                      motivation);
       if (queued_info)
         queued_info->SetReferringHostname(url);
     }
     UMA_HISTOGRAM_ENUMERATION("Net.PreconnectSubresourceEval", evalution,
                               SUBRESOURCE_VALUE_MAX);
   }
 }
 
-void Predictor::OnLookupFinished(LookupRequest* request, const GURL& url,
-                                 bool found) {
+void Predictor::OnLookupFinished(const GURL& url, int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  LookupFinished(request, url, found);
-  pending_lookups_.erase(request);
-  delete request;
-
+  LookupFinished(url, result == net::OK);
+  DCHECK_GT(num_pending_lookups_, 0u);
+  num_pending_lookups_--;
   StartSomeQueuedResolutions();
 }
 
-void Predictor::LookupFinished(LookupRequest* request, const GURL& url,
-                               bool found) {
+void Predictor::LookupFinished(const GURL& url, bool found) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   UrlInfo* info = &results_[url];
   DCHECK(info->HasUrl(url));
   if (info->is_marked_to_delete()) {
     results_.erase(url);
   } else {
     if (found)
       info->SetFoundState();
     else
       info->SetNoSuchNameState();
   }
 }
 
 bool Predictor::WouldLikelyProxyURL(const GURL& url) {
   if (!proxy_service_)
     return false;
 
   net::ProxyInfo info;
   bool synchronous_success = proxy_service_->TryResolveProxySynchronously(
-      url, std::string(), net::LOAD_NORMAL, &info, NULL, net::BoundNetLog());
+      url, std::string(), net::LOAD_NORMAL, &info, nullptr, net::BoundNetLog());
 
   return synchronous_success && !info.is_direct();
 }
 
 UrlInfo* Predictor::AppendToResolutionQueue(
     const GURL& url,
     UrlInfo::ResolutionMotivation motivation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(url.has_host());
 
   if (shutdown_)
-    return NULL;
+    return nullptr;
 
   UrlInfo* info = &results_[url];
   info->SetUrl(url);  // Initialize or DCHECK.
   // TODO(jar):  I need to discard names that have long since expired.
   // Currently we only add to the domain map :-/
 
   DCHECK(info->HasUrl(url));
 
   if (!info->NeedsDnsUpdate()) {
     info->DLogResultsStats("DNS PrefetchNotUpdated");
-    return NULL;
+    return nullptr;
   }
 
   if (WouldLikelyProxyURL(url)) {
     info->DLogResultsStats("DNS PrefetchForProxiedRequest");
-    return NULL;
+    return nullptr;
   }
 
   info->SetQueuedState(motivation);
   work_queue_.Push(url, motivation);
 
   StartSomeQueuedResolutions();
   return info;
 }
 
 bool Predictor::CongestionControlPerformed(UrlInfo* info) {
@@ skipping 11 matching lines @@
       break;
     info = &results_[work_queue_.Pop()];
     info->SetAssignedState();
   }
   return true;
 }
 
 void Predictor::StartSomeQueuedResolutions() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
-  // If the queue is disabled, just make LookupRequests for all entries.
+  // If the queue is disabled, just make requests for all entries.
   bool enable_queue = base::FeatureList::IsEnabled(kUsePredictorDNSQueue);
-  while (!work_queue_.IsEmpty() &&
-         (!enable_queue ||
-          pending_lookups_.size() < max_concurrent_dns_lookups_)) {
+  while (
+      !work_queue_.IsEmpty() &&
+      (!enable_queue || num_pending_lookups_ < max_concurrent_dns_lookups_)) {
     const GURL url(work_queue_.Pop());
     UrlInfo* info = &results_[url];
     DCHECK(info->HasUrl(url));
     info->SetAssignedState();
 
     // Only perform congestion control if the queue is enabled.
     if (enable_queue && CongestionControlPerformed(info)) {
       DCHECK(work_queue_.IsEmpty());
       return;
     }
 
-    LookupRequest* request = new LookupRequest(this, host_resolver_, url);
-
-    int status = request->Start();
+    int status =
+        content::PreresolveUrl(profile_io_data_->GetResourceContext(), url,
+                               base::Bind(&Predictor::OnLookupFinished,
+                                          weak_factory_->GetWeakPtr(), url));
     if (status == net::ERR_IO_PENDING) {
       // Will complete asynchronously.
-      pending_lookups_.insert(request);
-      peak_pending_lookups_ = std::max(peak_pending_lookups_,
-                                       pending_lookups_.size());
+      num_pending_lookups_++;
+      peak_pending_lookups_ =
+          std::max(peak_pending_lookups_, num_pending_lookups_);
     } else {
       // Completed synchronously (was already cached by HostResolver), or else
       // there was (equivalently) some network error that prevents us from
       // finding the name.  Status net::OK means it was "found."
-      LookupFinished(request, url, status == net::OK);
-      delete request;
+      LookupFinished(url, status == net::OK);
     }
   }
 }
 
 void Predictor::TrimReferrers() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (!urls_being_trimmed_.empty())
     return;   // There is incremental trimming in progress already.
 
   // Check to see if it is time to trim yet.
@@ skipping 111 matching lines @@
 }
 
 Predictor::InitialObserver::~InitialObserver() {
 }
 
 void Predictor::InitialObserver::Append(const GURL& url,
                                         Predictor* predictor) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // TODO(rlp): Do we really need the predictor check here?
-  if (NULL == predictor)
+  if (nullptr == predictor)
     return;
   if (kStartupResolutionCount <= first_navigations_.size())
     return;
 
   DCHECK(url.SchemeIsHTTPOrHTTPS());
   DCHECK_EQ(url, Predictor::CanonicalizeUrl(url));
   if (first_navigations_.find(url) == first_navigations_.end())
     first_navigations_[url] = base::TimeTicks::Now();
 }
 
@@ skipping 69 matching lines @@
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
 bool SimplePredictor::CanPrefetchAndPrerender() const { return true; }
 bool SimplePredictor::CanPreresolveAndPreconnect() const { return true; }
 
 }  // namespace chrome_browser_net