Reland 54771 (and 54795) To enable TCP Preconnection by default...

chrome/browser/net/preconnect.cc

 // Copyright (c) 2010 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/preconnect.h"
 
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/common/net/url_request_context_getter.h"
 #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
-Preconnect* Preconnect::callback_instance_;
+
+Preconnect::~Preconnect() {
+  if (!handle_.is_initialized())
+    return;
+  DCHECK(motivation_ == UrlInfo::LEARNED_REFERAL_MOTIVATED ||
+         motivation_ == UrlInfo::OMNIBOX_MOTIVATED);
+  if (motivation_ == UrlInfo::OMNIBOX_MOTIVATED)
+    handle_.socket()->SetOmniboxSpeculation();
+  else
+    handle_.socket()->SetSubresourceSpeculation();
+  handle_.Reset();
+}
 
 // static
 void Preconnect::PreconnectOnUIThread(const GURL& url,
     UrlInfo::ResolutionMotivation motivation) {
-  // Try to do connection warming for this search provider.
-  URLRequestContextGetter* getter = Profile::GetDefaultRequestContext();
-  if (!getter)
-    return;
   // Prewarm connection to Search URL.
   ChromeThread::PostTask(
       ChromeThread::IO,
       FROM_HERE,
       NewRunnableFunction(Preconnect::PreconnectOnIOThread, url, motivation));
   return;
 }
 
 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,
     UrlInfo::ResolutionMotivation motivation) {
+  scoped_refptr<Preconnect> preconnect = new Preconnect(motivation);
+  // TODO(jar): Should I use PostTask for LearnedSubresources to delay the
+  // preconnection a tad?
+  preconnect->Connect(url);
+}
+
+void Preconnect::Connect(const GURL& url) {
   URLRequestContextGetter* getter = Profile::GetDefaultRequestContext();
   if (!getter)
     return;
   if (!ChromeThread::CurrentlyOn(ChromeThread::IO)) {
     LOG(DFATAL) << "This must be run only on the IO thread.";
     return;
   }
+
+  AddRef();  // Stay alive until socket is available.
+
   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);
     }
   }
 
-  UMA_HISTOGRAM_ENUMERATION("Net.PreconnectMotivation", motivation,
+  UMA_HISTOGRAM_ENUMERATION("Net.PreconnectMotivation", motivation_,
                             UrlInfo::MAX_MOTIVATED);
 
   net::HttpTransactionFactory* factory = context->http_transaction_factory();
   net::HttpNetworkSession* session = factory->GetSession();
 
-  net::ClientSocketHandle handle;
-  if (!callback_instance_)
-    callback_instance_ = new Preconnect;
-
   scoped_refptr<net::TCPSocketParams> tcp_params =
       new net::TCPSocketParams(url.host(), url.EffectiveIntPort(), net::LOW,
                                GURL(), false);
 
   net::HostPortPair endpoint(url.host(), url.EffectiveIntPort());
   std::string group_name = endpoint.ToString();
 
+  // It almost doesn't matter whether we use net::LOWEST or net::HIGHEST
+  // priority here, as we won't make a request, and will surrender the created
+  // socket to the pool as soon as we can.  However, we would like to mark the
+  // speculative socket as such, and IF we use a net::LOWEST priority, and if
+  // a navigation asked for a socket (after us) then it would get our socket,
+  // and we'd get its later-arriving socket, which might make us record that
+  // the speculation didn't help :-/.  By using net::HIGHEST, we ensure that
+  // a socket is given to us if "we asked first" and this allows us to mark it
+  // as speculative, and better detect stats (if it gets used).
+  // TODO(jar): histogram to see how often we accidentally use a previously-
+  // unused socket, when a previously used socket was available.
+  net::RequestPriority priority = net::HIGHEST;
+
   if (url.SchemeIs("https")) {
     group_name = StringPrintf("ssl/%s", group_name.c_str());
 
     net::SSLConfig ssl_config;
     session->ssl_config_service()->GetSSLConfig(&ssl_config);
     // All preconnects should be for main pages.
     ssl_config.verify_ev_cert = true;
 
     scoped_refptr<net::SSLSocketParams> ssl_params =
         new net::SSLSocketParams(tcp_params, NULL, NULL,
                                  net::ProxyServer::SCHEME_DIRECT,
                                  url.HostNoBrackets(), ssl_config,
                                  0, false, false);
 
     const scoped_refptr<net::SSLClientSocketPool>& pool =
         session->ssl_socket_pool();
 
-    handle.Init(group_name, ssl_params, net::LOWEST, callback_instance_, pool,
-                net::BoundNetLog());
-    handle.Reset();
+    handle_.Init(group_name, ssl_params, priority, this, pool,
+                 net::BoundNetLog());
     return;
   }
 
   const scoped_refptr<net::TCPClientSocketPool>& pool =
       session->tcp_socket_pool();
-  handle.Init(group_name, tcp_params, net::LOWEST, callback_instance_, pool,
-              net::BoundNetLog());
-  handle.Reset();
+  handle_.Init(group_name, tcp_params, priority, this, pool,
+               net::BoundNetLog());
 }
 
 void Preconnect::RunWithParams(const Tuple1<int>& params) {
-  // This will rarely be called, as we reset the connection just after creating.
-  NOTREACHED();
+  if (params.a < 0 && handle_.socket())
+    handle_.socket()->Disconnect();
+  Release();
 }
 }  // chrome_browser_net