Add the UMA recording recall of URLRequests preconnected.

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 46 matching lines @@
 // connections.  Once this falls below kDiscardableExpectedValue the referrer
 // will be discarded.
 // TODO(jar): Measure size of referrer lists in the field.  Consider an adaptive
 // system that uses a higher trim ratio when the list is large.
 // static
 const double Predictor::kReferrerTrimRatio = 0.97153;
 const int64 Predictor::kDurationBetweenTrimmingsHours = 1;
 const int64 Predictor::kDurationBetweenTrimmingIncrementsSeconds = 15;
 const size_t Predictor::kUrlsTrimmedPerIncrement = 5u;
 const size_t Predictor::kMaxSpeculativeParallelResolves = 3;
+const int Predictor::kMaxUnusedSocketLifetimeSecondsWithoutAGet = 10;
 // To control our congestion avoidance system, which discards a queue when
 // resolutions are "taking too long," we need an expected resolution time.
 // Common average is in the range of 300-500ms.
 const int kExpectedResolutionTimeMs = 500;
 const int Predictor::kTypicalSpeculativeGroupSize = 8;
 const int Predictor::kMaxSpeculativeResolveQueueDelayMs =
     (kExpectedResolutionTimeMs * Predictor::kTypicalSpeculativeGroupSize) /
     Predictor::kMaxSpeculativeParallelResolves;
 
 static int g_max_queueing_delay_ms =
@@ skipping 52 matching lines @@
       url_request_context_getter_(NULL),
       predictor_enabled_(true),
       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),
       preconnect_enabled_(preconnect_enabled),
       consecutive_omnibox_preconnect_count_(0),
+      recent_preconnects_(
+          TimeDelta::FromSeconds(kMaxUnusedSocketLifetimeSecondsWithoutAGet)),
       next_trim_time_(base::TimeTicks::Now() +
                       TimeDelta::FromHours(kDurationBetweenTrimmingsHours)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 Predictor::~Predictor() {
   // TODO(rlp): Add DCHECK for CurrentlyOn(BrowserThread::IO) when the
   // ProfileManagerTest has been updated with a mock profile.
   DCHECK(shutdown_);
 }
@@ skipping 87 matching lines @@
         // 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;
-        PreconnectOnUIThread(CanonicalizeUrl(url), GURL(), motivation,
-                             kConnectionsNeeded,
-                             url_request_context_getter_);
+        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
@@ skipping 18 matching lines @@
     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;
 
   std::string host = url.HostNoBrackets();
   UrlInfo::ResolutionMotivation motivation(UrlInfo::EARLY_LOAD_MOTIVATED);
   const int kConnectionsNeeded = 1;
-  if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    PreconnectOnUIThread(CanonicalizeUrl(url), first_party_for_cookies,
-                         motivation, kConnectionsNeeded,
-                         url_request_context_getter_);
-  } else {
-    PreconnectOnIOThread(CanonicalizeUrl(url), first_party_for_cookies,
-                         motivation, kConnectionsNeeded,
-                         url_request_context_getter_);
-  }
+  PreconnectUrl(CanonicalizeUrl(url), first_party_for_cookies,
+                motivation, kConnectionsNeeded);
   PredictFrameSubresources(url.GetWithEmptyPath(), first_party_for_cookies);
 }
 
 UrlList Predictor::GetPredictedUrlListAtStartup(
     PrefService* user_prefs,
     PrefService* local_state) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   UrlList urls;
   // Recall list of URLs we learned about during last session.
   // This may catch secondary hostnames, pulled in by the homepages.  It will
@@ skipping 516 matching lines @@
         base::Bind(&Predictor::EnablePredictorOnIOThread,
                    base::Unretained(this), enable));
   }
 }
 
 void Predictor::EnablePredictorOnIOThread(bool enable) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   predictor_enabled_ = enable;
 }
 
+void Predictor::PreconnectUrl(const GURL& url,
+                              const GURL& first_party_for_cookies,
+                              UrlInfo::ResolutionMotivation motivation,
+                              int count) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
+         BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    PreconnectUrlOnIOThread(url, first_party_for_cookies, motivation, count);
+  } else {
+    BrowserThread::PostTask(
+        BrowserThread::IO,
+        FROM_HERE,
+        base::Bind(&Predictor::PreconnectUrlOnIOThread,
+                   base::Unretained(this), url, first_party_for_cookies,
+                   motivation, count));
+  }
+}
+
+void Predictor::PreconnectUrlOnIOThread(
+    const GURL& url, const GURL& first_party_for_cookies,
+    UrlInfo::ResolutionMotivation motivation, int count) {
+  GURL canonical_url(CanonicalizeUrl(url));
+  recent_preconnects_.SetRecentlySeen(canonical_url);
+
+  PreconnectOnIOThread(url, first_party_for_cookies, motivation, count,
+                       url_request_context_getter_);
+}
+
+void Predictor::RecordPreconnectNavigationStats(const GURL& url) {
+  UMA_HISTOGRAM_BOOLEAN(
+      "Net.PreconnectedNavigation",
+      recent_preconnects_.WasRecentlySeen(url));
+}
+
 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;
   DCHECK_EQ(url.GetWithEmptyPath(), url);
   // Add one pass through the message loop to allow current navigation to
   // proceed.
   if (BrowserThread::CurrentlyOn(BrowserThread::IO)) {
@@ skipping 20 matching lines @@
   DCHECK_EQ(url.GetWithEmptyPath(), url);
   Referrers::iterator it = referrers_.find(url);
   if (referrers_.end() == it) {
     // Only when we don't know anything about this url, make 2 connections
     // available.  We could do this completely via learning (by prepopulating
     // the referrer_ list with this expected value), but it would swell the
     // size of the list with all the "Leaf" nodes in the tree (nodes that don't
     // load any subresources).  If we learn about this resource, we will instead
     // provide a more carefully estimated preconnection count.
     if (preconnect_enabled_) {
-      PreconnectOnIOThread(url, first_party_for_cookies,
-                           UrlInfo::SELF_REFERAL_MOTIVATED, 2,
-                           url_request_context_getter_);
+      PreconnectUrlOnIOThread(url, first_party_for_cookies,
+                              UrlInfo::SELF_REFERAL_MOTIVATED, 2);
     }
     return;
   }
 
   Referrer* referrer = &(it->second);
   referrer->IncrementUseCount();
   const UrlInfo::ResolutionMotivation motivation =
       UrlInfo::LEARNED_REFERAL_MOTIVATED;
   for (Referrer::iterator future_url = referrer->begin();
        future_url != referrer->end(); ++future_url) {
     SubresourceValue evalution(TOO_NEW);
     double connection_expectation = future_url->second.subresource_use_rate();
     UMA_HISTOGRAM_CUSTOM_COUNTS("Net.PreconnectSubresourceExpectation",
                                 static_cast<int>(connection_expectation * 100),
                                 10, 5000, 50);
     future_url->second.ReferrerWasObserved();
     if (preconnect_enabled_ &&
         connection_expectation > kPreconnectWorthyExpectedValue) {
       evalution = PRECONNECTION;
       future_url->second.IncrementPreconnectionCount();
       int count = static_cast<int>(std::ceil(connection_expectation));
       if (url.host() == future_url->first.host())
         ++count;
-      PreconnectOnIOThread(future_url->first, first_party_for_cookies,
-                           motivation, count, url_request_context_getter_);
+      PreconnectUrlOnIOThread(future_url->first, first_party_for_cookies,
+                              motivation, count);
     } else if (connection_expectation > kDNSPreresolutionWorthyExpectedValue) {
       evalution = PRERESOLUTION;
       future_url->second.preresolution_increment();
       UrlInfo* queued_info = AppendToResolutionQueue(future_url->first,
                                                      motivation);
       if (queued_info)
         queued_info->SetReferringHostname(url);
     }
     UMA_HISTOGRAM_ENUMERATION("Net.PreconnectSubresourceEval", evalution,
                               SUBRESOURCE_VALUE_MAX);
@@ skipping 285 matching lines @@
     IOThread* io_thread,
     net::URLRequestContextGetter* getter) {
   // Empty function for unittests.
 }
 
 void SimplePredictor::ShutdownOnUIThread(PrefService* user_prefs) {
   SetShutdown(true);
 }
 
 }  // namespace chrome_browser_net