predictors: Refactor the prefetcher in resource_prefetch_predictor.

chrome/browser/predictors/resource_prefetch_predictor.h

 // Copyright 2014 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 <stddef.h>
 
 #include <map>
@@ skipping 113 matching lines @@
   // 'ResourcePrefetchPredictorObserver' calls the below functions to inform the
   // predictor of main frame and resource requests. Should only be called if the
   // corresponding Should* functions return true.
   void RecordURLRequest(const URLRequestSummary& request);
   void RecordURLResponse(const URLRequestSummary& response);
   void RecordURLRedirect(const URLRequestSummary& response);
 
   // Called when the main frame of a page completes loading.
   void RecordMainFrameLoadComplete(const NavigationID& navigation_id);
 
-  // Called by ResourcePrefetcherManager to notify that prefetching has finished
-  // for a navigation. Should take ownership of |requests|.
-  virtual void FinishedPrefetchForNavigation(
-      const NavigationID& navigation_id,
-      PrefetchKeyType key_type,
-      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,
                            NavigationNotRecorded);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, NavigationUrlInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, NavigationUrlNotInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            NavigationUrlNotInDBAndDBFull);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, OnMainFrameRequest);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, OnMainFrameRedirect);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            OnSubresourceResponse);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, GetCorrectPLT);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, HandledResourceTypes);
 
   enum InitializationState {
     NOT_INITIALIZED = 0,
     INITIALIZING = 1,
     INITIALIZED = 2
   };
 
-  // Stores prefetching results.
-  struct Result {
-    // Takes ownership of requests.
-    Result(PrefetchKeyType key_type,
-           ResourcePrefetcher::RequestVector* requests);
-    ~Result();
-
-    PrefetchKeyType key_type;
-    std::unique_ptr<ResourcePrefetcher::RequestVector> requests;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Result);
-  };
-
   typedef ResourcePrefetchPredictorTables::ResourceRow ResourceRow;
   typedef ResourcePrefetchPredictorTables::ResourceRows ResourceRows;
   typedef ResourcePrefetchPredictorTables::PrefetchData PrefetchData;
   typedef ResourcePrefetchPredictorTables::PrefetchDataMap PrefetchDataMap;
   typedef std::map<NavigationID, linked_ptr<std::vector<URLRequestSummary> > >
       NavigationMap;
-  typedef std::map<NavigationID, std::unique_ptr<Result>> ResultsMap;
 
   // Returns true if the main page request is supported for prediction.
   static bool IsHandledMainPage(net::URLRequest* request);
 
   // Returns true if the subresource request is supported for prediction.
   static bool IsHandledSubresource(net::URLRequest* request,
                                    content::ResourceType resource_type);
 
   // Returns true if the subresource has a supported type.
   static bool IsHandledResourceType(content::ResourceType resource_type,
@@ skipping 14 matching lines @@
 
   // Called when onload completes for a navigation. We treat this point as the
   // "completion" of the navigation. The resources requested by the page up to
   // this point are the only ones considered for prefetching.
   void OnNavigationComplete(const NavigationID& nav_id_without_timing_info);
 
   // Returns true if there is PrefetchData that can be used for the
   // navigation and fills in the |prefetch_data| to resources that need to be
   // prefetched.
   bool GetPrefetchData(const NavigationID& navigation_id,
-                       ResourcePrefetcher::RequestVector* prefetch_requests,
+                       std::vector<GURL>* urls,
                        PrefetchKeyType* key_type);
 
-  // Converts a PrefetchData into a ResourcePrefetcher::RequestVector.
+  // Converts a PrefetchData into a list of URLs.
   void PopulatePrefetcherRequest(const PrefetchData& data,
-                                 ResourcePrefetcher::RequestVector* requests);
+                                 std::vector<GURL>* urls);
 
   // Starts prefetching if it is enabled and prefetching data exists for the
   // NavigationID either at the URL or at the host level.
   void StartPrefetching(const NavigationID& navigation_id);
 
   // Stops prefetching that may be in progress corresponding to |navigation_id|.
   void StopPrefetching(const NavigationID& navigation_id);
 
   // Starts initialization by posting a task to the DB thread to read the
   // predictor database.
   void StartInitialization();
 
   // Callback for task to read predictor database. Takes ownership of
   // |url_data_map| and |host_data_map|.
   void CreateCaches(std::unique_ptr<PrefetchDataMap> url_data_map,
                     std::unique_ptr<PrefetchDataMap> host_data_map);
 
   // Called during initialization when history is read and the predictor
   // database has been read.
   void OnHistoryAndCacheLoaded();
 
   // Removes data for navigations where the onload never fired. Will cleanup
-  // inflight_navigations_ and results_map_.
+  // inflight_navigations_.
   void CleanupAbandonedNavigations(const NavigationID& navigation_id);
 
   // Deletes all URLs from the predictor database, the caches and removes all
   // inflight navigations.
   void DeleteAllUrls();
 
   // Deletes data for the input |urls| and their corresponding hosts from the
   // predictor database and caches.
   void DeleteUrls(const history::URLRows& urls);
 
@@ skipping 18 matching lines @@
   // Reports overall page load time.
   void ReportPageLoadTimeStats(base::TimeDelta plt) const;
 
   // Reports page load time for prefetched and not prefetched pages
   void ReportPageLoadTimePrefetchStats(
       base::TimeDelta plt,
       bool prefetched,
       base::Callback<void(int)> report_network_type_callback,
       PrefetchKeyType key_type) const;
 
-  // Reports accuracy by comparing prefetched resources with resources that are
-  // actually used by the page.
-  void ReportAccuracyStats(PrefetchKeyType key_type,
-                           const std::vector<URLRequestSummary>& actual,
-                           ResourcePrefetcher::RequestVector* prefetched) const;
-
-  // Reports predicted accuracy i.e. by comparing resources that are actually
-  // used by the page with those that may have been prefetched.
-  void ReportPredictedAccuracyStats(
-      PrefetchKeyType key_type,
-      const std::vector<URLRequestSummary>& actual,
-      const ResourcePrefetcher::RequestVector& predicted) const;
-  void ReportPredictedAccuracyStatsHelper(
-      PrefetchKeyType key_type,
-      const ResourcePrefetcher::RequestVector& predicted,
-      const std::map<GURL, bool>& actual,
-      size_t total_resources_fetched_from_network,
-      size_t max_assumed_prefetched) const;
-
   // history::HistoryServiceObserver:
   void OnURLsDeleted(history::HistoryService* history_service,
                      bool all_history,
                      bool expired,
                      const history::URLRows& deleted_rows,
                      const std::set<GURL>& favicon_urls) override;
   void OnHistoryServiceLoaded(
       history::HistoryService* history_service) override;
 
   // Used to connect to HistoryService or register for service loaded
@@ skipping 12 matching lines @@
   scoped_refptr<ResourcePrefetcherManager> prefetch_manager_;
   base::CancelableTaskTracker history_lookup_consumer_;
 
   // Map of all the navigations in flight to their resource requests.
   NavigationMap inflight_navigations_;
 
   // Copy of the data in the predictor tables.
   std::unique_ptr<PrefetchDataMap> url_table_cache_;
   std::unique_ptr<PrefetchDataMap> host_table_cache_;
 
-  ResultsMap results_map_;
-
   ScopedObserver<history::HistoryService, history::HistoryServiceObserver>
       history_service_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourcePrefetchPredictor);
 };
 
 }  // namespace predictors
 
 #endif  // CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_