predictors: Move more methods from ResourcePrefetchPredictor into LoadingDataCollector.

chrome/browser/predictors/loading_stats_collector.cc

 // Copyright 2017 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/predictors/loading_stats_collector.h"
 
 #include <set>
 #include <vector>
 
 #include "base/metrics/histogram_macros.h"
+#include "chrome/browser/predictors/loading_data_collector.h"
 
 namespace predictors {
 
 namespace {
 
 void ReportPredictionAccuracy(
     const ResourcePrefetchPredictor::Prediction& prediction,
-    const ResourcePrefetchPredictor::PageRequestSummary& summary) {
+    const PageRequestSummary& summary) {
   const std::vector<GURL>& predicted_urls = prediction.subresource_urls;
   if (predicted_urls.empty() || summary.subresource_requests.empty())
     return;
 
   std::set<GURL> predicted_urls_set(predicted_urls.begin(),
                                     predicted_urls.end());
   std::set<GURL> actual_urls_set;
   for (const auto& request_summary : summary.subresource_requests)
     actual_urls_set.emplace(request_summary.resource_url);
 
@@ skipping 33 matching lines @@
       precision_percentage);
   UMA_HISTOGRAM_PERCENTAGE(internal::kResourcePrefetchPredictorRecallHistogram,
                            recall_percentage);
   UMA_HISTOGRAM_COUNTS_100(internal::kResourcePrefetchPredictorCountHistogram,
                            predicted_urls.size());
   UMA_HISTOGRAM_ENUMERATION(
       internal::kResourcePrefetchPredictorRedirectStatusHistogram,
       static_cast<int>(redirect_status), static_cast<int>(RedirectStatus::MAX));
 }
 
-void ReportPrefetchAccuracy(
-    const ResourcePrefetcher::PrefetcherStats& stats,
-    const std::vector<ResourcePrefetchPredictor::URLRequestSummary>& requests) {
+void ReportPrefetchAccuracy(const ResourcePrefetcher::PrefetcherStats& stats,
+                            const std::vector<URLRequestSummary>& requests) {
   if (stats.requests_stats.empty())
     return;
 
   std::set<GURL> urls;
   for (const auto& request : requests)
     urls.emplace(request.resource_url);
 
   int cached_misses_count = 0;
   int not_cached_misses_count = 0;
   int cached_hits_count = 0;
@@ skipping 43 matching lines @@
           config.max_navigation_lifetime_seconds)) {}
 
 LoadingStatsCollector::~LoadingStatsCollector() = default;
 
 void LoadingStatsCollector::RecordPrefetcherStats(
     std::unique_ptr<ResourcePrefetcher::PrefetcherStats> stats) {
   const GURL main_frame_url = stats->url;
   auto it = prefetcher_stats_.find(main_frame_url);
   if (it != prefetcher_stats_.end()) {
     // No requests -> everything is a miss.
-    ReportPrefetchAccuracy(
-        *it->second,
-        std::vector<ResourcePrefetchPredictor::URLRequestSummary>());
+    ReportPrefetchAccuracy(*it->second, std::vector<URLRequestSummary>());
     prefetcher_stats_.erase(it);
   }
 
   prefetcher_stats_.emplace(main_frame_url, std::move(stats));
 }
 
 void LoadingStatsCollector::RecordPageRequestSummary(
-    const ResourcePrefetchPredictor::PageRequestSummary& summary) {
+    const PageRequestSummary& summary) {
   const GURL& initial_url = summary.initial_url;
 
   ResourcePrefetchPredictor::Prediction prediction;
   if (predictor_->GetPrefetchData(initial_url, &prediction))
     ReportPredictionAccuracy(prediction, summary);
 
   auto it = prefetcher_stats_.find(initial_url);
   if (it != prefetcher_stats_.end()) {
     ReportPrefetchAccuracy(*it->second, summary.subresource_requests);
     prefetcher_stats_.erase(it);
   }
 }
 
 void LoadingStatsCollector::CleanupAbandonedStats() {
   base::TimeTicks time_now = base::TimeTicks::Now();
   for (auto it = prefetcher_stats_.begin(); it != prefetcher_stats_.end();) {
     if (time_now - it->second->start_time > max_stats_age_) {
       // No requests -> everything is a miss.
-      ReportPrefetchAccuracy(
-          *it->second,
-          std::vector<ResourcePrefetchPredictor::URLRequestSummary>());
+      ReportPrefetchAccuracy(*it->second, std::vector<URLRequestSummary>());
       it = prefetcher_stats_.erase(it);
     } else {
       ++it;
     }
   }
 }
 
 }  // namespace predictors