Create LoadingDataCollector class and have observers rely on it instead of ResourcePrefetchPredictor

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 77 matching lines @@
 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
+// * LoadingPredictorObserver - Listens for URL requests, responses and
 //   redirects (client-side redirects are not supported) on the IO thread (via
 //   ResourceDispatcherHostDelegate) and posts 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 persists
+//   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.
 //
@@ skipping 94 matching lines @@
 
   ResourcePrefetchPredictor(const LoadingPredictorConfig& config,
                             Profile* profile);
   ~ResourcePrefetchPredictor() override;
 
   // Starts initialization by posting a task to the DB thread to read the
   // predictor database. Virtual for testing.
   virtual void StartInitialization();
   virtual void Shutdown();
 
-  // Thread safe.
-  static bool ShouldRecordRequest(net::URLRequest* request,
-                                  content::ResourceType resource_type);
-  static bool ShouldRecordResponse(net::URLRequest* response);
-  static bool ShouldRecordRedirect(net::URLRequest* response);
-
   // Determines the resource type from the declared one, falling back to MIME
   // type detection when it is not explicit.
   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);
 
-  // '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 after the main frame's first contentful paint.
-  void RecordFirstContentfulPaint(
-      const NavigationID& navigation_id,
-      const base::TimeTicks& first_contentful_paint);
-
   // 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;
 
   // Sets the |observer| to be notified when the resource prefetch predictor
   // data changes. Previously registered observer will be discarded. Call
   // this with nullptr parameter to de-register observer.
   void SetObserverForTesting(TestObserver* observer);
 
  private:
+  // 'LoadingPredictorObserver' 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 after the main frame's first contentful paint.
+  void RecordFirstContentfulPaint(
+      const NavigationID& navigation_id,
+      const base::TimeTicks& first_contentful_paint);
+
   // Starts prefetching if it is enabled and prefetching data exists for the
   // |main_frame_url| either at the URL or at the host level.
   void StartPrefetching(const GURL& main_frame_url);
 
   // 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);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            NavigationLowHistoryCount);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, NavigationUrlInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, NavigationUrlNotInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            NavigationUrlNotInDBAndDBFull);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, RedirectUrlNotInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, RedirectUrlInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, ManifestHostNotInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, ManifestHostInDB);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            ManifestHostNotInDBAndDBFull);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            ManifestUnusedRemoved);
   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);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            PopulatePrefetcherRequest);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, PopulateFromManifest);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, GetRedirectEndpoint);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest, GetPrefetchData);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            TestPrecisionRecallHistograms);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            TestPrefetchingDurationHistogram);
   FRIEND_TEST_ALL_PREFIXES(ResourcePrefetchPredictorTest,
                            TestRecordFirstContentfulPaint);
 
   enum InitializationState {
     NOT_INITIALIZED = 0,
     INITIALIZING = 1,
     INITIALIZED = 2
   };
   typedef GlowplugKeyValueData<PrefetchData, internal::LastVisitTimeCompare>
       PrefetchDataMap;
   typedef GlowplugKeyValueData<RedirectData, internal::LastVisitTimeCompare>
       RedirectDataMap;
   typedef GlowplugKeyValueData<precache::PrecacheManifest,
                                internal::ManifestCompare>
       ManifestDataMap;
   typedef GlowplugKeyValueData<OriginData, internal::LastVisitTimeCompare>
       OriginDataMap;
   typedef std::map<NavigationID, std::unique_ptr<PageRequestSummary>>
       NavigationMap;
 
-  // 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,
-                                    const std::string& mime_type);
-
   // Returns true if the request (should have a response in it) is "no-store".
   static bool IsNoStore(const net::URLRequest& request);
 
-  static void SetAllowPortInUrlsForTesting(bool state);
-
   // Functions called on different network events pertaining to the loading of
   // main frame resource or sub resources.
   void OnMainFrameRequest(const URLRequestSummary& request);
   void OnMainFrameRedirect(const URLRequestSummary& response);
   void OnSubresourceResponse(const URLRequestSummary& response);
   void OnSubresourceRedirect(const URLRequestSummary& response);
 
   // 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.
@@ skipping 150 matching lines @@
 
  private:
   ResourcePrefetchPredictor* predictor_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 }  // namespace predictors
 
 #endif  // CHROME_BROWSER_PREDICTORS_RESOURCE_PREFETCH_PREDICTOR_H_