predictors: Move more methods from ResourcePrefetchPredictor into LoadingDataCollector.

chrome/browser/predictors/loading_test_util.cc

 // Copyright 2016 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_test_util.h"
 
 #include <cmath>
 #include <memory>
+#include <utility>
 
 #include "content/public/browser/resource_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request_test_util.h"
 
 namespace {
 
 class EmptyURLRequestDelegate : public net::URLRequest::Delegate {
   void OnResponseStarted(net::URLRequest* request, int net_error) override {}
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override {}
 };
 
 EmptyURLRequestDelegate g_empty_url_request_delegate;
 
 bool AlmostEqual(const double x, const double y) {
   return std::fabs(x - y) <= 1e-6;  // Arbitrary but close enough.
 }
 
 }  // namespace
 
 namespace predictors {
 
-using URLRequestSummary = ResourcePrefetchPredictor::URLRequestSummary;
-using PageRequestSummary = ResourcePrefetchPredictor::PageRequestSummary;
 using Prediction = ResourcePrefetchPredictor::Prediction;
 
 MockResourcePrefetchPredictor::MockResourcePrefetchPredictor(
     const LoadingPredictorConfig& config,
     Profile* profile)
     : ResourcePrefetchPredictor(config, profile) {}
 
 MockResourcePrefetchPredictor::~MockResourcePrefetchPredictor() = default;
 
 void InitializeResourceData(ResourceData* resource,
@@ skipping 80 matching lines @@
 }
 
 PageRequestSummary CreatePageRequestSummary(
     const std::string& main_frame_url,
     const std::string& initial_url,
     const std::vector<URLRequestSummary>& subresource_requests) {
   GURL main_frame_gurl(main_frame_url);
   PageRequestSummary summary(main_frame_gurl);
   summary.initial_url = GURL(initial_url);
   summary.subresource_requests = subresource_requests;
+  for (auto& request_summary : subresource_requests)
+    summary.UpdateOrAddToOrigins(request_summary);
   return summary;
 }
 
 URLRequestSummary CreateURLRequestSummary(SessionID::id_type tab_id,
                                           const std::string& main_frame_url,
                                           const std::string& resource_url,
                                           content::ResourceType resource_type,
                                           net::RequestPriority priority,
                                           const std::string& mime_type,
                                           bool was_cached,
@@ skipping 12 matching lines @@
   summary.was_cached = was_cached;
   if (!redirect_url.empty())
     summary.redirect_url = GURL(redirect_url);
   summary.has_validators = has_validators;
   summary.always_revalidate = always_revalidate;
   summary.is_no_store = false;
   summary.network_accessed = true;
   return summary;
 }
 
+URLRequestSummary CreateRedirectRequestSummary(
+    SessionID::id_type session_id,
+    const std::string& main_frame_url,
+    const std::string& redirect_url) {
+  URLRequestSummary summary =
+      CreateURLRequestSummary(session_id, main_frame_url);
+  summary.redirect_url = GURL(redirect_url);
+  return summary;
+}
+
 ResourcePrefetchPredictor::Prediction CreatePrediction(
     const std::string& main_frame_key,
     std::vector<GURL> subresource_urls) {
   Prediction prediction;
   prediction.main_frame_key = main_frame_key;
   prediction.subresource_urls = subresource_urls;
   prediction.is_host = true;
   prediction.is_redirected = false;
   return prediction;
 }
@@ skipping 148 matching lines @@
 }
 
 std::ostream& operator<<(std::ostream& os, const OriginStat& origin) {
   return os << "[" << origin.origin() << "," << origin.number_of_hits() << ","
             << origin.number_of_misses() << "," << origin.consecutive_misses()
             << "," << origin.average_position() << ","
             << origin.always_access_network() << ","
             << origin.accessed_network() << "]";
 }
 
+std::ostream& operator<<(std::ostream& os,
+                         const OriginRequestSummary& summary) {
+  return os << "[" << summary.origin << "," << summary.always_access_network
+            << "," << summary.accessed_network << ","
+            << summary.first_occurrence << "]";
+}
+
 std::ostream& operator<<(std::ostream& os, const PageRequestSummary& summary) {
   os << "[" << summary.main_frame_url << "," << summary.initial_url << "]"
      << std::endl;
   for (const auto& request : summary.subresource_requests)
     os << "\t\t" << request << std::endl;
+  for (const auto& pair : summary.origins)
+    os << "\t\t" << pair.first << ":" << pair.second << std::endl;
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const URLRequestSummary& summary) {
   return os << "[" << summary.navigation_id << "," << summary.resource_url
             << "," << summary.resource_type << "," << summary.priority << ","
             << summary.before_first_contentful_paint << "," << summary.mime_type
             << "," << summary.was_cached << "," << summary.redirect_url << ","
             << summary.has_validators << "," << summary.always_revalidate
             << "]";
@@ skipping 61 matching lines @@
 bool operator==(const RedirectStat& lhs, const RedirectStat& rhs) {
   return lhs.url() == rhs.url() &&
          lhs.number_of_hits() == rhs.number_of_hits() &&
          lhs.number_of_misses() == rhs.number_of_misses() &&
          lhs.consecutive_misses() == rhs.consecutive_misses();
 }
 
 bool operator==(const PageRequestSummary& lhs, const PageRequestSummary& rhs) {
   return lhs.main_frame_url == rhs.main_frame_url &&
          lhs.initial_url == rhs.initial_url &&
-         lhs.subresource_requests == rhs.subresource_requests;
+         lhs.subresource_requests == rhs.subresource_requests &&
+         lhs.origins == rhs.origins;
 }
 
 bool operator==(const URLRequestSummary& lhs, const URLRequestSummary& rhs) {
   return lhs.navigation_id == rhs.navigation_id &&
          lhs.resource_url == rhs.resource_url &&
          lhs.resource_type == rhs.resource_type &&
          lhs.priority == rhs.priority && lhs.mime_type == rhs.mime_type &&
          lhs.before_first_contentful_paint ==
              rhs.before_first_contentful_paint &&
          lhs.was_cached == rhs.was_cached &&
          lhs.redirect_url == rhs.redirect_url &&
          lhs.has_validators == rhs.has_validators &&
          lhs.always_revalidate == rhs.always_revalidate;
 }
 
+bool operator==(const OriginRequestSummary& lhs,
+                const OriginRequestSummary& rhs) {
+  return lhs.origin == rhs.origin &&
+         lhs.always_access_network == rhs.always_access_network &&
+         lhs.accessed_network == rhs.accessed_network &&
+         lhs.first_occurrence == rhs.first_occurrence;
+}
+
 bool operator==(const OriginData& lhs, const OriginData& rhs) {
   bool equal =
       lhs.host() == rhs.host() && lhs.origins_size() == rhs.origins_size();
   if (!equal)
     return false;
 
   for (int i = 0; i < lhs.origins_size(); ++i)
     equal = equal && lhs.origins(i) == rhs.origins(i);
 
   return equal;
@@ skipping 10 matching lines @@
 }
 
 bool operator==(const PreconnectPrediction& lhs,
                 const PreconnectPrediction& rhs) {
   return lhs.is_redirected == rhs.is_redirected && lhs.host == rhs.host &&
          lhs.preconnect_origins == rhs.preconnect_origins &&
          lhs.preresolve_hosts == rhs.preresolve_hosts;
 }
 
 }  // namespace predictors