Avoid preconnect (and pre-resolution) when proxy MIGHT be present

This change detects if there is a chance that a proxy MIGHT
be used to perform a connection, and if so, it avoids doing
any speculative preconnections, or speculative DNS
pre-resolution.

For testing purposes, a flag is provided to avoid this
probe for proxy status.  If you enable --preconnect-despite-proxy
then preconnection will take place (as appropriate) even
if there is a chance that a proxy might be used
for connections to some hosts.

BUG=47906
r=eroman
Review URL: http://codereview.chromium.org/2871038

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@52016 0039d316-1c4b-4281-b951-d872f2087c98

7 files changed, 62 insertions, 4 deletions

diff --git a/chrome/browser/browser_main.cc b/chrome/browser/browser_main.cc
index 4ba9615..3d6f110 100644
--- a/chrome/browser/browser_main.cc
+++ b/chrome/browser/browser_main.cc
@@ -1091,7 +1091,8 @@ int BrowserMain(const MainFunctionParams& parameters) {
   chrome_browser_net::PredictorInit dns_prefetch(
       user_prefs,
       local_state,
-      parsed_command_line.HasSwitch(switches::kEnablePreconnect));
+      parsed_command_line.HasSwitch(switches::kEnablePreconnect),
+      parsed_command_line.HasSwitch(switches::kPreconnectDespiteProxy));
 
 #if defined(OS_WIN)
   win_util::ScopedCOMInitializer com_initializer;
diff --git a/chrome/browser/net/preconnect.cc b/chrome/browser/net/preconnect.cc
index a669232..d829c77 100644
--- a/chrome/browser/net/preconnect.cc
+++ b/chrome/browser/net/preconnect.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/net/preconnect.h"
 
+#include "base/histogram.h"
 #include "base/logging.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/chrome_thread.h"
@@ -11,10 +12,14 @@
 #include "net/base/host_port_pair.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_transaction_factory.h"
+#include "net/proxy/proxy_service.h"
 #include "net/url_request/url_request_context.h"
 
 namespace chrome_browser_net {
 
+// static
+bool Preconnect::preconnect_despite_proxy_ = false;
+
 // We will deliberately leak this singular instance, which is used only for
 // callbacks.
 // static
@@ -34,6 +39,19 @@ bool Preconnect::PreconnectOnUIThread(const GURL& url) {
   return true;
 }
 
+enum ProxyStatus {
+  PROXY_STATUS_IGNORED,
+  PROXY_UNINITIALIZED,
+  PROXY_NOT_USED,
+  PROXY_PAC_RESOLVER,
+  PROXY_HAS_RULES,
+  PROXY_MAX,
+};
+
+static void HistogramPreconnectStatus(ProxyStatus status) {
+  UMA_HISTOGRAM_ENUMERATION("Net.PreconnectProxyStatus", status, PROXY_MAX);
+}
+
 // static
 void Preconnect::PreconnectOnIOThread(const GURL& url) {
   URLRequestContextGetter* getter = Profile::GetDefaultRequestContext();
@@ -44,6 +62,27 @@ void Preconnect::PreconnectOnIOThread(const GURL& url) {
     return;
   }
   URLRequestContext* context = getter->GetURLRequestContext();
+
+  if (preconnect_despite_proxy_) {
+    HistogramPreconnectStatus(PROXY_STATUS_IGNORED);
+  } else {
+    // Currently we avoid all preconnects if there is a proxy configuration.
+    net::ProxyService* proxy_service = context->proxy_service();
+    if (!proxy_service->config_has_been_initialized()) {
+      HistogramPreconnectStatus(PROXY_UNINITIALIZED);
+    } else {
+      if (proxy_service->config().MayRequirePACResolver()) {
+        HistogramPreconnectStatus(PROXY_PAC_RESOLVER);
+        return;
+      }
+      if (!proxy_service->config().proxy_rules().empty()) {
+        HistogramPreconnectStatus(PROXY_HAS_RULES);
+        return;
+      }
+      HistogramPreconnectStatus(PROXY_NOT_USED);
+    }
+  }
+
   net::HttpTransactionFactory* factory = context->http_transaction_factory();
   net::HttpNetworkSession* session = factory->GetSession();
   scoped_refptr<net::TCPClientSocketPool> pool = session->tcp_socket_pool();
diff --git a/chrome/browser/net/preconnect.h b/chrome/browser/net/preconnect.h
index 5251c05..8289625 100644
--- a/chrome/browser/net/preconnect.h
+++ b/chrome/browser/net/preconnect.h
@@ -23,6 +23,10 @@ class Preconnect : public net::CompletionCallback {
 
   static void PreconnectOnIOThread(const GURL& url);
 
+  static void SetPreconnectDespiteProxy(bool status) {
+    preconnect_despite_proxy_ = status;
+  }
+
  private:
   Preconnect() {}
 
@@ -33,6 +37,12 @@ class Preconnect : public net::CompletionCallback {
   // IO Callback which whould be performed when the connection is established.
   virtual void RunWithParams(const Tuple1<int>& params);
 
+  // Preconnections are currently conservative, and do nothing if there is a
+  // chance that a proxy may be used.  This boolean allows proxy settings to
+  // be ignored (presumably because a user knows that the proxy won't be doing
+  // much work anway).
+  static bool preconnect_despite_proxy_;
+
   DISALLOW_COPY_AND_ASSIGN(Preconnect);
 };
 }  // chrome_browser_net
diff --git a/chrome/browser/net/predictor_api.cc b/chrome/browser/net/predictor_api.cc
index 06b7a9d..d5f661dc 100644
--- a/chrome/browser/net/predictor_api.cc
+++ b/chrome/browser/net/predictor_api.cc
@@ -669,7 +669,8 @@ static UrlList GetPredictedUrlListAtStartup(PrefService* user_prefs,
 
 PredictorInit::PredictorInit(PrefService* user_prefs,
                              PrefService* local_state,
-                             bool preconnect_enabled) {
+                             bool preconnect_enabled,
+                             bool proconnect_despite_proxy) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
   // Set up a field trial to see what disabling DNS pre-resolution does to
   // latency of page loads.
@@ -746,6 +747,8 @@ PredictorInit::PredictorInit(PrefService* user_prefs,
     TimeDelta max_queueing_delay(
         TimeDelta::FromMilliseconds(max_queueing_delay_ms));
 
+    Preconnect::SetPreconnectDespiteProxy(proconnect_despite_proxy);
+
     DCHECK(!predictor);
     InitNetworkPredictor(max_queueing_delay, max_concurrent, user_prefs,
                          local_state, preconnect_enabled);
diff --git a/chrome/browser/net/predictor_api.h b/chrome/browser/net/predictor_api.h
index 0992fc3..204afd9 100644
--- a/chrome/browser/net/predictor_api.h
+++ b/chrome/browser/net/predictor_api.h
@@ -88,7 +88,7 @@ class PredictorInit {
   static const int kMaxPrefetchQueueingDelayMs;
 
   PredictorInit(PrefService* user_prefs, PrefService* local_state,
-                bool preconnect_enabled);
+                bool preconnect_enabled, bool preconnect_despite_proxy);
 
  private:
   // Maintain a field trial instance when we do A/B testing.
diff --git a/chrome/common/chrome_switches.cc b/chrome/common/chrome_switches.cc
index c940f29..365016b 100644
--- a/chrome/common/chrome_switches.cc
+++ b/chrome/common/chrome_switches.cc
@@ -666,8 +666,12 @@ const char kPluginProcess[]                 = "plugin";
 // Causes the plugin process to display a dialog on launch.
 const char kPluginStartupDialog[]           = "plugin-startup-dialog";
 
+// Enable TCP/IP preconnection, and DNS preresolution, even if a proxy might
+// possibly be used for connections.
+const char kPreconnectDespiteProxy[]        = "preconnect-despite-proxy";
+
 // Prints the pages on the screen.
-const char kPrint[] = "print";
+const char kPrint[]                         = "print";
 
 // Runs a single process for each site (i.e., group of pages from the same
 // registered domain) the user visits.  We default to using a renderer process
diff --git a/chrome/common/chrome_switches.h b/chrome/common/chrome_switches.h
index 8430862..71367dd 100644
--- a/chrome/common/chrome_switches.h
+++ b/chrome/common/chrome_switches.h
@@ -198,6 +198,7 @@ extern const char kPluginLauncher[];
 extern const char kPluginPath[];
 extern const char kPluginProcess[];
 extern const char kPluginStartupDialog[];
+extern const char kPreconnectDespiteProxy[];
 extern const char kPrint[];
 extern const char kProcessPerSite[];
 extern const char kProcessPerTab[];