Enable TCP preconnect and DNS preresolve on cellular.

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 211 matching lines @@
       FROM_HERE,
       base::Bind(
           &Predictor::FinalizeInitializationOnIOThread,
           base::Unretained(this),
           urls, referral_list,
           io_thread, profile_io_data));
 }
 
 void Predictor::AnticipateOmniboxUrl(const GURL& url, bool preconnectable) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  if (!predictor_enabled_)
+  if (!preconnect_enabled_ || !CanPreresolveAndPreconnectUI())

[mmenke, 2014/08/12 17:38:10]

I think !preconnect_enabled_ should go down to where preconnectable is?  At
least I don't believe it should disable presresolve as well, if we want to keep
the old behavior.

[Bence, 2014/08/12 20:21:56]

Done.

     return;
   if (!url.is_valid() || !url.has_host())
     return;
-  if (!CanPredictNetworkActionsUI())
-    return;
 
   std::string host = url.HostNoBrackets();
   bool is_new_host_request = (host != last_omnibox_host_);
   last_omnibox_host_ = host;
 
   UrlInfo::ResolutionMotivation motivation(UrlInfo::OMNIBOX_MOTIVATED);
   base::TimeTicks now = base::TimeTicks::Now();
 
-  if (preconnect_enabled_) {
-    if (preconnectable && !is_new_host_request) {
-      ++consecutive_omnibox_preconnect_count_;
-      // The omnibox suggests a search URL (for which we can preconnect) after
-      // one or two characters are typed, even though such typing often (1 in
-      // 3?) becomes a real URL.  This code waits till is has more evidence of a
-      // preconnectable URL (search URL) before forming a preconnection, so as
-      // to reduce the useless preconnect rate.
-      // Perchance this logic should be pushed back into the omnibox, where the
-      // actual characters typed, such as a space, can better forcast whether
-      // we need to search/preconnect or not.  By waiting for at least 4
-      // characters in a row that have lead to a search proposal, we avoid
-      // preconnections for a prefix like "www." and we also wait until we have
-      // at least a 4 letter word to search for.
-      // Each character typed appears to induce 2 calls to
-      // AnticipateOmniboxUrl(), so we double 4 characters and limit at 8
-      // requests.
-      // TODO(jar): Use an A/B test to optimize this.
-      const int kMinConsecutiveRequests = 8;
-      if (consecutive_omnibox_preconnect_count_ >= kMinConsecutiveRequests) {
-        // TODO(jar): Perhaps we should do a GET to leave the socket open in the
-        // pool.  Currently, we just do a connect, which MAY be reset if we
-        // don't use it in 10 secondes!!!  As a result, we may do more
-        // connections, and actually cost the server more than if we did a real
-        // get with a fake request (/gen_204 might be the good path on Google).
-        const int kMaxSearchKeepaliveSeconds(10);
-        if ((now - last_omnibox_preconnect_).InSeconds() <
-             kMaxSearchKeepaliveSeconds)
-          return;  // We've done a preconnect recently.
-        last_omnibox_preconnect_ = now;
-        const int kConnectionsNeeded = 1;
-        PreconnectUrl(CanonicalizeUrl(url), GURL(), motivation,
-                      kConnectionsNeeded);
-        return;  // Skip pre-resolution, since we'll open a connection.
-      }
-    } else {
-      consecutive_omnibox_preconnect_count_ = 0;
+  if (preconnectable && !is_new_host_request) {
+    ++consecutive_omnibox_preconnect_count_;
+    // The omnibox suggests a search URL (for which we can preconnect) after
+    // one or two characters are typed, even though such typing often (1 in
+    // 3?) becomes a real URL.  This code waits till is has more evidence of a
+    // preconnectable URL (search URL) before forming a preconnection, so as
+    // to reduce the useless preconnect rate.
+    // Perchance this logic should be pushed back into the omnibox, where the
+    // actual characters typed, such as a space, can better forcast whether
+    // we need to search/preconnect or not.  By waiting for at least 4
+    // characters in a row that have lead to a search proposal, we avoid
+    // preconnections for a prefix like "www." and we also wait until we have
+    // at least a 4 letter word to search for.
+    // Each character typed appears to induce 2 calls to
+    // AnticipateOmniboxUrl(), so we double 4 characters and limit at 8
+    // requests.
+    // TODO(jar): Use an A/B test to optimize this.
+    const int kMinConsecutiveRequests = 8;
+    if (consecutive_omnibox_preconnect_count_ >= kMinConsecutiveRequests) {
+      // TODO(jar): Perhaps we should do a GET to leave the socket open in the
+      // pool.  Currently, we just do a connect, which MAY be reset if we
+      // don't use it in 10 secondes!!!  As a result, we may do more
+      // connections, and actually cost the server more than if we did a real
+      // get with a fake request (/gen_204 might be the good path on Google).
+      const int kMaxSearchKeepaliveSeconds(10);
+      if ((now - last_omnibox_preconnect_).InSeconds() <
+          kMaxSearchKeepaliveSeconds)
+        return;  // We've done a preconnect recently.
+      last_omnibox_preconnect_ = now;
+      const int kConnectionsNeeded = 1;
+      PreconnectUrl(
+          CanonicalizeUrl(url), GURL(), motivation, kConnectionsNeeded);
+      return;  // Skip pre-resolution, since we'll open a connection.
     }
+  } else {
+    consecutive_omnibox_preconnect_count_ = 0;
   }
 
   // Fall through and consider pre-resolution.
 
   // Omnibox tends to call in pairs (just a few milliseconds apart), and we
   // really don't need to keep resolving a name that often.
   // TODO(jar): A/B tests could check for perf impact of the early returns.
   if (!is_new_host_request) {
     const int kMinPreresolveSeconds(10);
     if (kMinPreresolveSeconds > (now - last_omnibox_preresolve_).InSeconds())
@@ skipping 10 matching lines @@
 
 void Predictor::PreconnectUrlAndSubresources(const GURL& url,
     const GURL& first_party_for_cookies) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_ || !preconnect_enabled_ ||
       !url.is_valid() || !url.has_host())
     return;
 
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    if (!CanPredictNetworkActionsUI())
+    if (!CanPreresolveAndPreconnectUI())
       return;
   } else {
-    if (!CanPredictNetworkActionsIO())
+    if (!CanPreresolveAndPreconnectIO())
       return;
   }
 
   UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
   const int kConnectionsNeeded = 1;
   PreconnectUrl(CanonicalizeUrl(url), first_party_for_cookies,
                 motivation, kConnectionsNeeded);
   PredictFrameSubresources(url.GetWithEmptyPath(), first_party_for_cookies);
 }
 
@@ skipping 138 matching lines @@
                         UrlInfo::ResolutionMotivation motivation) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!url.has_host())
     return;
   AppendToResolutionQueue(url, motivation);
 }
 
 void Predictor::LearnFromNavigation(const GURL& referring_url,
                                     const GURL& target_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
-  if (!predictor_enabled_ || !CanPredictNetworkActionsIO())
+  if (!predictor_enabled_ || !CanPrefetchAndPrerenderIO())
     return;
   DCHECK_EQ(referring_url, Predictor::CanonicalizeUrl(referring_url));
   DCHECK_NE(referring_url, GURL::EmptyGURL());
   DCHECK_EQ(target_url, Predictor::CanonicalizeUrl(target_url));
   DCHECK_NE(target_url, GURL::EmptyGURL());
 
   referrers_[referring_url].SuggestHost(target_url);
   // Possibly do some referrer trimming.
   TrimReferrers();
 }
 
 //-----------------------------------------------------------------------------
 // This section supports the about:dns page.
 
 void Predictor::PredictorGetHtmlInfo(Predictor* predictor,
                                      std::string* output) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   output->append("<html><head><title>About DNS</title>"
                  // We'd like the following no-cache... but it doesn't work.
                  // "<META HTTP-EQUIV=\"Pragma\" CONTENT=\"no-cache\">"
                  "</head><body>");
   if (predictor && predictor->predictor_enabled() &&
-      predictor->CanPredictNetworkActionsIO()) {
+      predictor->CanPrefetchAndPrerenderIO()) {
     predictor->GetHtmlInfo(output);
   } else {
     output->append("DNS pre-resolution and TCP pre-connection is disabled.");
   }
   output->append("</body></html>");
 }
 
 // Provide sort order so all .com's are together, etc.
 struct RightToLeftStringSorter {
   bool operator()(const GURL& left, const GURL& right) const {
@@ skipping 210 matching lines @@
 //-----------------------------------------------------------------------------
 // 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(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_ || NULL == initial_observer_.get() ||
-      !CanPredictNetworkActionsIO())
+      !CanPrefetchAndPrerenderIO())
     return;

[mmenke, 2014/08/12 17:38:10]

nit:  While you're here, mind adding braces?

[Bence, 2014/08/12 20:21:56]

Done.

   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) {
   // TODO(jar): Push GURL transport further back into renderer, but this will
   // require a Webkit change in the observer :-/.
@@ skipping 10 matching lines @@
 
 void Predictor::DnsPrefetchMotivatedList(
     const UrlList& urls,
     UrlInfo::ResolutionMotivation motivation) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!predictor_enabled_)
     return;
 
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    if (!CanPredictNetworkActionsUI())
+    if (!CanPrefetchAndPrerenderUI())
       return;
   } else {
-    if (!CanPredictNetworkActionsIO())
+    if (!CanPrefetchAndPrerenderIO())
       return;
   }
 
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     ResolveList(urls, motivation);
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&Predictor::ResolveList, base::Unretained(this),
@@ skipping 18 matching lines @@
   }
   predictor->SaveDnsPrefetchStateForNextStartupAndTrim(
       startup_list, referral_list, completion);
 }
 
 void Predictor::SaveStateForNextStartupAndTrim() {
   if (!predictor_enabled_)
     return;
 
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    if (!CanPredictNetworkActionsUI())
+    if (!CanPrefetchAndPrerenderUI())
       return;
   } else {
-    if (!CanPredictNetworkActionsIO())
+    if (!CanPrefetchAndPrerenderIO())
       return;
   }
 
   base::WaitableEvent completion(true, false);
 
   ListPrefUpdate update_startup_list(user_prefs_,
                                      prefs::kDnsPrefetchingStartupList);
   ListPrefUpdate update_referral_list(user_prefs_,
                                       prefs::kDnsPrefetchingHostReferralList);
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
@@ skipping 82 matching lines @@
 }
 
 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 (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    if (!CanPredictNetworkActionsUI())
+    if (!CanPrefetchAndPrerenderUI())
       return;
   } else {
-    if (!CanPredictNetworkActionsIO())
+    if (!CanPrefetchAndPrerenderIO())
       return;
   }
   DCHECK_EQ(url.GetWithEmptyPath(), url);
   // Add one pass through the message loop to allow current navigation to
   // proceed.
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     PrepareFrameSubresources(url, first_party_for_cookies);
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO,
@@ skipping 16 matching lines @@
     AdviseProxyOnIOThread(url, motivation, is_preconnect);
   } else {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(&Predictor::AdviseProxyOnIOThread,
                    base::Unretained(this), url, motivation, is_preconnect));
   }
 }
 
-bool Predictor::CanPredictNetworkActionsUI() {
-  return chrome_browser_net::CanPredictNetworkActionsUI(user_prefs_);
+bool Predictor::CanPrefetchAndPrerenderUI() const {

[mmenke, 2014/08/12 17:38:10]

Suggest adding DCHECKs for which thread we're on in these functions.

[mmenke, 2014/08/12 17:38:10]

optional:  It's marginally slower, but you might want to merge these into a
single function that both figures out what thread it's on, and then calls it,
and completely get rid of the thread-dependent versions.  we're doing the checks
half the time, anyways, and I don't think we're making calls often enough for
the performance to matter.

[Bence, 2014/08/12 20:21:55]

Done.

[Bence, 2014/08/12 20:21:56]

Done.

+  return chrome_browser_net::CanPrefetchAndPrerenderUI(user_prefs_);
 }
 
-bool Predictor::CanPredictNetworkActionsIO() {
-  return chrome_browser_net::CanPredictNetworkActionsIO(profile_io_data_);
+bool Predictor::CanPrefetchAndPrerenderIO() const {
+  return chrome_browser_net::CanPrefetchAndPrerenderIO(profile_io_data_);
+}
+
+bool Predictor::CanPreresolveAndPreconnectUI() const {
+  return chrome_browser_net::CanPreresolveAndPreconnectUI(user_prefs_);
+}
+
+bool Predictor::CanPreresolveAndPreconnectIO() const {
+  return chrome_browser_net::CanPreresolveAndPreconnectIO(profile_io_data_);
 }
 
 enum SubresourceValue {
   PRECONNECTION,
   PRERESOLUTION,
   TOO_NEW,
   SUBRESOURCE_VALUE_MAX
 };
 
 void Predictor::PrepareFrameSubresources(const GURL& original_url,
@@ skipping 371 matching lines @@
     IOThread* io_thread,
     net::URLRequestContextGetter* getter,
     ProfileIOData* profile_io_data) {
   // Empty function for unittests.
 }
 
 void SimplePredictor::ShutdownOnUIThread() {
   SetShutdown(true);
 }
 
-bool SimplePredictor::CanPredictNetworkActionsUI() { return true; }
-bool SimplePredictor::CanPredictNetworkActionsIO() { return true; }
+bool SimplePredictor::CanPrefetchAndPrerenderUI() const { return true; }
+bool SimplePredictor::CanPrefetchAndPrerenderIO() const { return true; }
+bool SimplePredictor::CanPreresolveAndPreconnectUI() const { return true; }
+bool SimplePredictor::CanPreresolveAndPreconnectIO() const { return true; }
 
 }  // namespace chrome_browser_net