predictors: Make ResourcePrefetchPredictor observable.

chrome/browser/predictors/resource_prefetch_predictor_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/resource_prefetch_predictor_test_util.h"
 
 #include "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 
 namespace predictors {
 
+using URLRequestSummary = ResourcePrefetchPredictor::URLRequestSummary;
+using PageRequestSummary = ResourcePrefetchPredictor::PageRequestSummary;
+
 void InitializeResourceData(ResourceData* resource,
                             const std::string& resource_url,
                             content::ResourceType resource_type,
                             int number_of_hits,
                             int number_of_misses,
                             int consecutive_misses,
                             double average_position,
                             net::RequestPriority priority,
                             bool has_validators,
                             bool always_revalidate) {
@@ skipping 61 matching lines @@
     os << "\t\t" << redirect << std::endl;
   return os;
 }
 
 std::ostream& operator<<(std::ostream& os, const RedirectStat& redirect) {
   return os << "[" << redirect.url() << "," << redirect.number_of_hits() << ","
             << redirect.number_of_misses() << ","
             << redirect.consecutive_misses() << "]";
 }
 
+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;
+  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.mime_type << "," << summary.was_cached << ","
+            << summary.redirect_url << "," << summary.has_validators << ","
+            << summary.always_revalidate << "]";
+}
+
+std::ostream& operator<<(std::ostream& os, const NavigationID& navigation_id) {
+  return os << navigation_id.render_process_id << ","
+            << navigation_id.render_frame_id << ","
+            << navigation_id.main_frame_url;
+}
+
 bool operator==(const PrefetchData& lhs, const PrefetchData& rhs) {
   bool equal = lhs.primary_key() == rhs.primary_key() &&
                lhs.resources_size() == rhs.resources_size();
 
   if (!equal)
     return false;
 
   for (int i = 0; i < lhs.resources_size(); ++i)
     equal = equal && lhs.resources(i) == rhs.resources(i);
 
@@ skipping 25 matching lines @@
   return equal;
 }
 
 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;
+}
+
+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.was_cached == rhs.was_cached &&
+         lhs.redirect_url == rhs.redirect_url &&
+         lhs.has_validators == rhs.has_validators &&
+         lhs.always_revalidate == rhs.always_revalidate;
+}
+
 }  // namespace predictors