predictors: move ResourcePrefetcher handling to LoadingPredictor.

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>
 #include <memory>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/scoped_observer.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "chrome/browser/predictors/glowplug_key_value_data.h"
 #include "chrome/browser/predictors/loading_predictor_config.h"
 #include "chrome/browser/predictors/resource_prefetch_common.h"
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 #include "chrome/browser/predictors/resource_prefetcher.h"
-#include "chrome/browser/predictors/resource_prefetcher_manager.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/history_service_observer.h"
 #include "components/history/core/browser/history_types.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/precache/content/precache_manager.h"
 #include "content/public/common/resource_type.h"
 #include "url/gurl.h"
 
 class PredictorsHandler;
 class Profile;
@@ skipping 55 matching lines @@
 //   LoadingDataCollector 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 LoadingPredictorObserver and persists
 //   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(zhenw): Currently only main frame requests/redirects/responses are
-// recorded. Consider recording sub-frame responses independently or together
-// with main frame.
 class ResourcePrefetchPredictor
     : public history::HistoryServiceObserver,
       public precache::PrecacheManager::Delegate {
  public:
   // Data collected for origin-based prediction, for a single origin during a
   // page load (see PageRequestSummary).
   struct OriginRequestSummary {
     OriginRequestSummary();
     OriginRequestSummary(const OriginRequestSummary& other);
     ~OriginRequestSummary();
@@ skipping 103 matching lines @@
   static content::ResourceType GetResourceType(
       content::ResourceType resource_type,
       const std::string& mime_type);
 
   // Determines the ResourceType from the mime type, defaulting to the
   // |fallback| if the ResourceType could not be determined.
   static content::ResourceType GetResourceTypeFromMimeType(
       const std::string& mime_type,
       content::ResourceType fallback);
 
-  // Called when ResourcePrefetcher is finished, i.e. there is nothing pending
-  // in flight.
-  void OnPrefetchingFinished(
-      const GURL& main_frame_url,
-      std::unique_ptr<ResourcePrefetcher::PrefetcherStats> stats);
-
   // Returns true if prefetching data exists for the |main_frame_url|.
   virtual bool IsUrlPrefetchable(const GURL& main_frame_url) const;
 
   // Returns true iff |resource| has sufficient confidence level and required
   // number of hits.
   bool IsResourcePrefetchable(const ResourceData& resource) const;
 
   // precache::PrecacheManager::Delegate:
   void OnManifestFetched(const std::string& host,
                          const precache::PrecacheManifest& manifest) override;
@@ skipping 12 matching lines @@
   virtual bool GetPrefetchData(const GURL& main_frame_url,
                                Prediction* prediction) const;
 
   // Returns true iff there is OriginData that can be used for a |url| and fills
   // |prediction| with origins and hosts that need to be preconnected and
   // preresolved respectively.
   virtual bool PredictPreconnectOrigins(const GURL& url,
                                         PreconnectPrediction* prediction) const;
 
  private:
-  // 'LoadingPredictorObserver' calls the below functions to inform the
+  // 'ResourcePrefetchPredictorObserver' calls the below functions to inform the

[alexilin, 2017/07/03 14:55:02]

s/ResourcePrefetchPredictorObserver/LoadingPredictorObserver

[Benoit L, 2017/07/03 15:43:15]

Oops, bad rebase.
Thanks!

Done.

   // 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 after the main frame's first contentful paint.
   void RecordFirstContentfulPaint(
       const NavigationID& navigation_id,
       const base::TimeTicks& first_contentful_paint);
 
-  // Starts prefetching for |main_frame_url| from a |prediction|.
-  void StartPrefetching(const GURL& main_frame_url,
-                        const Prediction& prediction);
-
-  // Stops prefetching that may be in progress corresponding to
-  // |main_frame_url|.
-  void StopPrefetching(const GURL& main_frame_url);
-
-  friend class LoadingPredictor;
   friend class ::PredictorsHandler;
   friend class LoadingDataCollector;
   friend class ResourcePrefetchPredictorTest;
   friend class ResourcePrefetchPredictorBrowserTest;
 
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, DeleteUrls);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            LazilyInitializeEmpty);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            LazilyInitializeWithData);
@@ skipping 137 matching lines @@
 
   // Used to connect to HistoryService or register for service loaded
   // notificatioan.
   void ConnectToHistoryService();
 
   // Used for testing to inject mock tables.
   void set_mock_tables(scoped_refptr<ResourcePrefetchPredictorTables> tables) {
     tables_ = tables;
   }
 
-  // For testing.
-  void set_mock_resource_prefetcher_manager(
-      scoped_refptr<ResourcePrefetcherManager> prefetch_manager) {
-    prefetch_manager_ = prefetch_manager;
-  }
-
   Profile* const profile_;
   TestObserver* observer_;
   LoadingStatsCollector* stats_collector_;
   const LoadingPredictorConfig config_;
   InitializationState initialization_state_;
   scoped_refptr<ResourcePrefetchPredictorTables> tables_;
-  scoped_refptr<ResourcePrefetcherManager> prefetch_manager_;
   base::CancelableTaskTracker history_lookup_consumer_;
 
   std::unique_ptr<PrefetchDataMap> url_resource_data_;
   std::unique_ptr<PrefetchDataMap> host_resource_data_;
   std::unique_ptr<RedirectDataMap> url_redirect_data_;
   std::unique_ptr<RedirectDataMap> host_redirect_data_;
   std::unique_ptr<ManifestDataMap> manifest_data_;
   std::unique_ptr<OriginDataMap> origin_data_;
 
   NavigationMap inflight_navigations_;
@@ skipping 12 matching lines @@
  public:
   // De-registers itself from |predictor_| on destruction.
   virtual ~TestObserver();
 
   virtual void OnPredictorInitialized() {}
 
   virtual void OnNavigationLearned(
       size_t url_visit_count,
       const ResourcePrefetchPredictor::PageRequestSummary& summary) {}
 
-  virtual void OnPrefetchingStarted(const GURL& main_frame_url) {}
-
-  virtual void OnPrefetchingStopped(const GURL& main_frame_url) {}
-
-  virtual void OnPrefetchingFinished(const GURL& main_frame_url) {}
-
  protected:
   // |predictor| must be non-NULL and has to outlive the TestObserver.
   // Also the predictor must not have a TestObserver set.
   explicit TestObserver(ResourcePrefetchPredictor* predictor);
 
  private:
   ResourcePrefetchPredictor* predictor_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 }  // namespace predictors
 
 #endif  // CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_