Add the UMA recording recall of URLRequests preconnected.

chrome/browser/net/predictor.h

 // 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.
 
 // A Predictor object is instantiated once in the browser process, and manages
 // both preresolution of hostnames, as well as TCP/IP preconnection to expected
 // subresources.
 // Most hostname lists are provided by the renderer processes, and include URLs
 // that *might* be used in the near future by the browsing user.  One goal of
 // this class is to cause the underlying DNS structure to lookup a hostname
@@ skipping 11 matching lines @@
 #include <map>
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "chrome/browser/net/referrer.h"
+#include "chrome/browser/net/timed_cache.h"
 #include "chrome/browser/net/url_info.h"
 #include "chrome/common/net/predictor_common.h"
 #include "net/base/host_port_pair.h"
 
 class IOThread;
 class PrefService;
 class Profile;
 
 namespace base {
 class ListValue;
@@ skipping 42 matching lines @@
   // In those odd cases, we may discard some of the later speculative requests
   // mistakenly assuming that the resolutions took too long.
   static const int kTypicalSpeculativeGroupSize;
 
   // The next constant specifies an amount of queueing delay that is
   // "too large," and indicative of problems with resolutions (perhaps due to
   // an overloaded router, or such).  When we exceed this delay, congestion
   // avoidance will kick in and all speculations in the queue will be discarded.
   static const int kMaxSpeculativeResolveQueueDelayMs;
 
+  // We don't bother learning to preconnect via a GET if the original URL
+  // navigation was so long ago, that a preconnection would have been dropped
+  // anyway.  We believe most servers will drop the connection in 10 seconds, so
+  // we currently estimate this time-till-drop at 10 seconds.
+  // TODO(jar): We should do a persistent field trial to validate/optimize this.
+  static const int kMaxUnusedSocketLifetimeSecondsWithoutAGet;
+
   // |max_concurrent| specifies how many concurrent (parallel) prefetches will
   // be performed. Host lookups will be issued through |host_resolver|.
   explicit Predictor(bool preconnect_enabled);
 
   virtual ~Predictor();
 
   // This function is used to create a predictor. For testing, we can create
   // a version which does a simpler shutdown.
   static Predictor* CreatePredictor(bool preconnect_enabled,
                                     bool simple_shutdown);
@@ skipping 109 matching lines @@
       base::ListValue* startup_list,
       base::ListValue* referral_list,
       base::WaitableEvent* completion);
 
   // May be called from either the IO or UI thread and will PostTask
   // to the IO thread if necessary.
   void EnablePredictor(bool enable);
 
   void EnablePredictorOnIOThread(bool enable);
 
+  // May be called from either the IO or UI thread and will PostTask
+  // to the IO thread if necessary.
+  void PreconnectUrl(const GURL& url, const GURL& first_party_for_cookies,
+                     UrlInfo::ResolutionMotivation motivation, int count);
+
+  void PreconnectUrlOnIOThread(const GURL& url,
+                               const GURL& first_party_for_cookies,
+                               UrlInfo::ResolutionMotivation motivation,
+                               int count);
+
+  void RecordPreconnectNavigationStats(const GURL& url);
+
   // ------------- End IO thread methods.
 
   // The following methods may be called on either the IO or UI threads.
 
   // Instigate pre-connection to any URLs, or pre-resolution of related host,
   // that we predict will be needed after this navigation (typically
   // more-embedded resources on a page).  This method will actually post a task
   // to do the actual work, so as not to jump ahead of the frame navigation that
   // instigated this activity.
   void PredictFrameSubresources(const GURL& url,
@@ skipping 249 matching lines @@
   // The time when the last preresolve was done for last_omnibox_host_.
   base::TimeTicks last_omnibox_preresolve_;
 
   // The number of consecutive requests to AnticipateOmniboxUrl() that suggested
   // preconnecting (because it was to a search service).
   int consecutive_omnibox_preconnect_count_;
 
   // The time when the last preconnection was requested to a search service.
   base::TimeTicks last_omnibox_preconnect_;
 
+  TimedCache recent_preconnects_;
+
   // For each URL that we might navigate to (that we've "learned about")
   // we have a Referrer list. Each Referrer list has all hostnames we might
   // need to pre-resolve or pre-connect to when there is a navigation to the
   // orginial hostname.
   Referrers referrers_;
 
   // List of URLs in referrers_ currently being trimmed (scaled down to
   // eventually be aged out of use).
   std::vector<GURL> urls_being_trimmed_;
 
@@ skipping 15 matching lines @@
       PrefService* user_prefs,
       PrefService* local_state,
       IOThread* io_thread,
       net::URLRequestContextGetter* getter) OVERRIDE;
   virtual void ShutdownOnUIThread(PrefService* user_prefs) OVERRIDE;
 };
 
 }  // namespace chrome_browser_net
 
 #endif  // CHROME_BROWSER_NET_PREDICTOR_H_