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

chrome/browser/net/resource_prefetch_predictor_observer.cc

 // 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.
 
 #include "chrome/browser/net/resource_prefetch_predictor_observer.h"
 
 #include <memory>
 #include <string>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "net/url_request/url_request.h"
 #include "url/gurl.h"
 
 namespace content {
 class WebContents;
 }
 
 using content::BrowserThread;
-using predictors::ResourcePrefetchPredictor;
 using URLRequestSummary =
     predictors::ResourcePrefetchPredictor::URLRequestSummary;
 
 namespace {
 
 // Enum for measuring statistics pertaining to observed request, responses and
 // redirects.
 enum RequestStats {
   REQUEST_STATS_TOTAL_RESPONSES = 0,
   REQUEST_STATS_TOTAL_PROCESSED_RESPONSES = 1,
@@ skipping 39 matching lines @@
   // A WebContents might be associated with something that is not a tab.
   // In this case tab_id will be -1 and is_valid() will return false.
   return navigation_id->is_valid();
 }
 
 }  // namespace
 
 namespace chrome_browser_net {
 
 ResourcePrefetchPredictorObserver::ResourcePrefetchPredictorObserver(
-    ResourcePrefetchPredictor* predictor)
-    : predictor_(predictor->AsWeakPtr()) {
+    predictors::GlowplugCollector* collector)
+    : collector_(collector->AsWeakPtr()) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 }
 
 ResourcePrefetchPredictorObserver::~ResourcePrefetchPredictorObserver() {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
         BrowserThread::CurrentlyOn(BrowserThread::IO));
 }
 
 void ResourcePrefetchPredictorObserver::OnRequestStarted(
     net::URLRequest* request,
     content::ResourceType resource_type,
     const content::ResourceRequestInfo::WebContentsGetter&
         web_contents_getter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME)
     ReportMainFrameRequestStats(MAIN_FRAME_REQUEST_STATS_TOTAL_REQUESTS);
 
-  if (!ResourcePrefetchPredictor::ShouldRecordRequest(request, resource_type))
+  if (!predictors::GlowplugCollector::ShouldRecordRequest(request,

[Benoit L, 2017/05/22 13:37:16]

nit: why not
"using predictors::LoadingDataCollector"
at the top of this file?

Then you can keep the code as it was, with the name change. 

[trevordixon, 2017/05/23 13:05:15]

Done.

+                                                          resource_type))
     return;
 
   auto summary = base::MakeUnique<URLRequestSummary>();
   summary->resource_url = request->original_url();
   summary->resource_type = resource_type;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(
           &ResourcePrefetchPredictorObserver::OnRequestStartedOnUIThread,
@@ skipping 12 matching lines @@
         web_contents_getter) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(request);
   if (request_info &&
       request_info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME) {
     ReportMainFrameRequestStats(MAIN_FRAME_REQUEST_STATS_TOTAL_REDIRECTS);
   }
 
-  if (!ResourcePrefetchPredictor::ShouldRecordRedirect(request))
+  if (!predictors::GlowplugCollector::ShouldRecordRedirect(request))

[Benoit L, 2017/05/22 13:37:16]

nit: ditto.

[trevordixon, 2017/05/23 13:05:15]

Done.

     return;
 
   auto summary = base::MakeUnique<URLRequestSummary>();
-  if (!ResourcePrefetchPredictor::URLRequestSummary::SummarizeResponse(
-          *request, summary.get())) {
+  if (!URLRequestSummary::SummarizeResponse(*request, summary.get())) {
     return;
   }
   summary->redirect_url = redirect_url;
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(
           &ResourcePrefetchPredictorObserver::OnRequestRedirectedOnUIThread,
           base::Unretained(this), base::Passed(std::move(summary)),
           web_contents_getter, request->first_party_for_cookies(),
@@ skipping 13 matching lines @@
 
   ReportRequestStats(REQUEST_STATS_TOTAL_RESPONSES);
 
   const content::ResourceRequestInfo* request_info =
       content::ResourceRequestInfo::ForRequest(request);
   if (request_info &&
       request_info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME) {
     ReportMainFrameRequestStats(MAIN_FRAME_REQUEST_STATS_TOTAL_RESPONSES);
   }
 
-  if (!ResourcePrefetchPredictor::ShouldRecordResponse(request))
+  if (!predictors::GlowplugCollector::ShouldRecordResponse(request))
     return;
   auto summary = base::MakeUnique<URLRequestSummary>();
-  if (!ResourcePrefetchPredictor::URLRequestSummary::SummarizeResponse(
-          *request, summary.get())) {
+  if (!URLRequestSummary::SummarizeResponse(*request, summary.get())) {
     return;
   }
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::BindOnce(
           &ResourcePrefetchPredictorObserver::OnResponseStartedOnUIThread,
           base::Unretained(this), base::Passed(std::move(summary)),
           web_contents_getter, request->first_party_for_cookies(),
           request->creation_time()));
 
   ReportRequestStats(REQUEST_STATS_TOTAL_PROCESSED_RESPONSES);
   if (request_info &&
       request_info->GetResourceType() == content::RESOURCE_TYPE_MAIN_FRAME) {
     ReportMainFrameRequestStats(MAIN_FRAME_REQUEST_STATS_PROCESSED_RESPONSES);
   }
 }
 
 void ResourcePrefetchPredictorObserver::OnRequestStartedOnUIThread(
     std::unique_ptr<URLRequestSummary> summary,
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const GURL& main_frame_url,
     const base::TimeTicks& creation_time) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!TryToFillNavigationID(&summary->navigation_id, web_contents_getter,
                              main_frame_url, creation_time)) {
     return;
   }
-  predictor_->RecordURLRequest(*summary);
+  collector_->RecordURLRequest(*summary);
 }
 
 void ResourcePrefetchPredictorObserver::OnRequestRedirectedOnUIThread(
     std::unique_ptr<URLRequestSummary> summary,
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const GURL& main_frame_url,
     const base::TimeTicks& creation_time) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!TryToFillNavigationID(&summary->navigation_id, web_contents_getter,
                              main_frame_url, creation_time)) {
     return;
   }
-  predictor_->RecordURLRedirect(*summary);
+  collector_->RecordURLRedirect(*summary);
 }
 
 void ResourcePrefetchPredictorObserver::OnResponseStartedOnUIThread(
     std::unique_ptr<URLRequestSummary> summary,
     const content::ResourceRequestInfo::WebContentsGetter& web_contents_getter,
     const GURL& main_frame_url,
     const base::TimeTicks& creation_time) const {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (!TryToFillNavigationID(&summary->navigation_id, web_contents_getter,
                              main_frame_url, creation_time)) {
     return;
   }
-  predictor_->RecordURLResponse(*summary);
+  collector_->RecordURLResponse(*summary);
 }
 
 }  // namespace chrome_browser_net