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 215 matching lines @@
           urls, referral_list,
           io_thread, profile_io_data));
 }
 
 void Predictor::AnticipateOmniboxUrl(const GURL& url, bool preconnectable) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!predictor_enabled_)
     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 (preconnect_enabled_ && CanPreconnectUI()) {
     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
@@ skipping 47 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 (!CanPreconnectUI())
       return;
   } else {
-    if (!CanPredictNetworkActionsIO())
+    if (!CanPreconnectIO())
       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 621 matching lines @@
 }
 
 bool Predictor::CanPredictNetworkActionsUI() {
   return chrome_browser_net::CanPredictNetworkActionsUI(user_prefs_);
 }
 
 bool Predictor::CanPredictNetworkActionsIO() {
   return chrome_browser_net::CanPredictNetworkActionsIO(profile_io_data_);
 }
 
+bool Predictor::CanPreconnectUI() {
+  return chrome_browser_net::CanPreconnectUI(user_prefs_);
+}
+
+bool Predictor::CanPreconnectIO() {
+  return chrome_browser_net::CanPreconnectIO(profile_io_data_);
+}
+
 enum SubresourceValue {
   PRECONNECTION,
   PRERESOLUTION,
   TOO_NEW,
   SUBRESOURCE_VALUE_MAX
 };
 
 void Predictor::PrepareFrameSubresources(const GURL& original_url,
                                          const GURL& first_party_for_cookies) {
   // Apply HSTS redirect early so it is taken into account when looking up
@@ skipping 371 matching lines @@
     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::CanPreconnectUI() { return true; }
+bool SimplePredictor::CanPreconnectIO() { return true; }
 
 }  // namespace chrome_browser_net