Adds speculative prefetching of resources.

chrome/browser/predictors/resource_prefetch_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.
 
 #ifndef CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_
 #define CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "chrome/browser/history/history_types.h"
+#include "chrome/browser/predictors/resource_prefetcher.h"
 #include "chrome/browser/predictors/resource_prefetch_common.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "googleurl/src/gurl.h"
 #include "webkit/glue/resource_type.h"
 
 class PredictorsHandler;
 class Profile;
 
 namespace content {
 class WebContents;
 }
 
 namespace net {
 class URLRequest;
 }
 
 namespace predictors {
 
+class ResourcePrefetcherManager;
+
 // Contains logic for learning what can be prefetched and for kicking off
 // speculative prefetching.
 // - The class is a profile keyed service owned by the profile.
 // - All the non-static methods of this class need to be called on the UI
 //   thread.
 //
 // The overall flow of the resource prefetching algorithm is as follows:
 //
 // * ResourcePrefetchPredictorObserver - Listens for URL requests, responses and
 //   redirects on the IO thread(via RDHostDelegate) and post tasks to the
 //   ResourcePrefetchPredictor on the UI thread. This is owned by the
 //   ProfileIOData for the profile.
 // * ResourcePrefetchPredictorTables - Persists ResourcePrefetchPredictor data
 //   to a sql database. Runs entirely on the DB thread. Owned by the
 //   PredictorDatabase.
 // * ResourcePrefetchPredictor - Learns about resource requirements per URL in
 //   the UI thread through the ResourcePrefetchPredictorObserver and perisists
-//   it to disk in the DB thread through the ResourcePrefetchPredictorTables.
-//   Owned by profile.
+//   it to disk in the DB thread through the ResourcePrefetchPredictorTables. It
+//   initiates resource prefetching using the ResourcePrefetcherManager. Owned
+//   by profile.
+// * ResourcePrefetcherManager - Manages the ResourcePrefetchers that do the
+//   prefetching on the IO thread. The manager is owned by the
+//   ResourcePrefetchPredictor and interfaces between the predictor on the UI
+//   thread and the prefetchers on the IO thread.
+// * ResourcePrefetcher - Lives entirely on the IO thread, owned by the
+//   ResourcePrefetcherManager, and issues net::URLRequest to fetch resources.
 //
-// TODO(shishir): Implement the prefetching of resources.
 // TODO(shishir): Do speculative prefetching for https resources and/or https
 // main_frame urls.
 class ResourcePrefetchPredictor
     : public ProfileKeyedService,
       public content::NotificationObserver,
       public base::SupportsWeakPtr<ResourcePrefetchPredictor> {
  public:
-  // The following config allows us to change the predictor constants and run
-  // field trials with different constants.
-  struct Config {
-    // Initializes the config with default values.
-    Config();
-
-    // If a navigation hasn't seen a load complete event in this much time, it
-    // is considered abandoned.
-    int max_navigation_lifetime_seconds;  // Default 60
-    // Size of LRU caches for the Url data.
-    size_t max_urls_to_track;  // Default 500
-    // The number of times, we should have seen a visit to this Url in history
-    // to start tracking it. This is to ensure we dont bother with oneoff
-    // entries.
-    int min_url_visit_count;  // Default 3
-    // The maximum number of resources to store per entry.
-    int max_resources_per_entry;  // Default 50
-    // The number of consecutive misses after we stop tracking a resource Url.
-    int max_consecutive_misses;  // Default 3
-  };
-
   // Stores the data that we need to get from the URLRequest.
   struct URLRequestSummary {
     URLRequestSummary();
     URLRequestSummary(const URLRequestSummary& other);
     ~URLRequestSummary();
 
     NavigationID navigation_id;
     GURL resource_url;
     ResourceType::Type resource_type;
 
     // Only for responses.
     std::string mime_type;
     bool was_cached;
     GURL redirect_url;  // Empty unless request was redirected to a valid url.
   };
 
-  ResourcePrefetchPredictor(const Config& config, Profile* profile);
+  ResourcePrefetchPredictor(const ResourcePrefetchPredictorConfig& config,
+                            Profile* profile);
   virtual ~ResourcePrefetchPredictor();
 
   // Thread safe.
-  static bool IsEnabled(Profile* profile);
   static bool ShouldRecordRequest(net::URLRequest* request,
                                   ResourceType::Type resource_type);
   static bool ShouldRecordResponse(net::URLRequest* response);
   static bool ShouldRecordRedirect(net::URLRequest* response);
 
   static ResourceType::Type GetResourceTypeFromMimeType(
       const std::string& mime_type,
       ResourceType::Type fallback);
 
   void RecordURLRequest(const URLRequestSummary& request);
   void RecordUrlResponse(const URLRequestSummary& response);
   void RecordUrlRedirect(const URLRequestSummary& response);
 
+  // Called by ResourcePrefetcherManager to notify that prefetching has finished
+  // for a navigation. Takes ownership of |requests|.

[dominich, 2012/09/11 18:40:43]

I don't think the scoped_ptr necessarily suggests this. I'd prefer a raw
pointer, but I'll bow to the established wisdom of the Chromium code-base if
this is the Done Thing.

[Shishir, 2012/09/11 19:36:31]

Raw pointer it is. In this case the method is not called via a PostTask so using
a raw pointer works. Using the scoped pointer for the PostTask is the convention
I think.

+  virtual void FinishedPrefetchForNavigation(
+      const NavigationID& navigation_id,
+      scoped_ptr<ResourcePrefetcher::RequestVector> requests);
+
  private:
   friend class ::PredictorsHandler;
   friend class ResourcePrefetchPredictorTest;
 
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, DeleteUrls);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            LazilyInitializeEmpty);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            LazilyInitializeWithData);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
@@ skipping 20 matching lines @@
   struct UrlTableCacheValue {
     UrlTableCacheValue();
     ~UrlTableCacheValue();
 
     UrlTableRowVector rows;
     base::Time last_visit;
   };
 
   typedef std::map<NavigationID, std::vector<URLRequestSummary> > NavigationMap;
   typedef std::map<GURL, UrlTableCacheValue> UrlTableCacheMap;
+  typedef std::map<NavigationID, ResourcePrefetcher::RequestVector*> ResultsMap;
 
   // content::NotificationObserver methods OVERRIDE.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
+  // ProfileKeyedService methods OVERRIDE.
+  virtual void Shutdown() OVERRIDE;
+
   static bool IsHandledMainPage(net::URLRequest* request);
   static bool IsHandledSubresource(net::URLRequest* response);
   static bool IsCacheable(const net::URLRequest* response);
 
   // Deal with different kinds of requests.
   void OnMainFrameRequest(const URLRequestSummary& request);
   void OnMainFrameResponse(const URLRequestSummary& response);
   void OnMainFrameRedirect(const URLRequestSummary& response);
   void OnSubresourceResponse(const URLRequestSummary& response);
   void OnSubresourceLoadedFromMemory(const NavigationID& navigation_id,
                                      const GURL& resource_url,
                                      const std::string& mime_type,
                                      ResourceType::Type resource_type);
 
   // Initialization code.
   void LazilyInitialize();
   void OnHistoryAndCacheLoaded();
   void CreateCaches(std::vector<UrlTableRow>* url_rows);
 
   // Database and cache cleanup code.
   void RemoveAnEntryFromUrlDB();
   void DeleteAllUrls();
   void DeleteUrls(const history::URLRows& urls);
 
   bool ShouldTrackUrl(const GURL& url);
   void CleanupAbandonedNavigations(const NavigationID& navigation_id);
   void OnNavigationComplete(const NavigationID& navigation_id);
   void LearnUrlNavigation(const GURL& main_frame_url,
                           const std::vector<URLRequestSummary>& new_value);
-  void MaybeReportAccuracyStats(const NavigationID& navigation_id) const;
+  void MaybeReportAccuracyStats(const NavigationID& navigation_id);
+  void MaybeReportSimulatedAccuracyStats(
+      const NavigationID& navigation_id) const;
   void ReportAccuracyHistograms(const UrlTableRowVector& predicted,
                                 const std::map<GURL, bool>& actual_resources,
                                 int total_resources_fetched_from_network,
                                 int max_assumed_prefetched) const;
 
   void SetTablesForTesting(
       scoped_refptr<ResourcePrefetchPredictorTables> tables);
 
   Profile* const profile_;
-  Config config_;
+  ResourcePrefetchPredictorConfig const config_;
   InitializationState initialization_state_;
   scoped_refptr<ResourcePrefetchPredictorTables> tables_;
+  scoped_refptr<ResourcePrefetcherManager> prefetch_manager_;
   content::NotificationRegistrar notification_registrar_;
 
   NavigationMap inflight_navigations_;
   UrlTableCacheMap url_table_cache_;
+  ResultsMap results_map_;
+  STLValueDeleter<ResultsMap> results_map_deleter_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourcePrefetchPredictor);
 };
 
 }  // namespace predictors
 
 #endif  // CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_