predictors: Add Manifest table to ResourcePrefetchPredictor.

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 <limits>
+
 #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,
@@ skipping 20 matching lines @@
                             const std::string& url,
                             int number_of_hits,
                             int number_of_misses,
                             int consecutive_misses) {
   redirect->set_url(url);
   redirect->set_number_of_hits(number_of_hits);
   redirect->set_number_of_misses(number_of_misses);
   redirect->set_consecutive_misses(consecutive_misses);
 }
 
+void InitializePrecacheResource(precache::PrecacheResource* resource,
+                                const std::string& url,
+                                double weight_ratio) {
+  resource->set_url(url);
+  resource->set_weight_ratio(weight_ratio);
+}
+
 PrefetchData CreatePrefetchData(const std::string& primary_key,
                                 uint64_t last_visit_time) {
   PrefetchData data;
   data.set_primary_key(primary_key);
   data.set_last_visit_time(last_visit_time);
   return data;
 }
 
 RedirectData CreateRedirectData(const std::string& primary_key,
                                 uint64_t last_visit_time) {
@@ skipping 156 matching lines @@
          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
+
+namespace precache {
+
+std::ostream& operator<<(std::ostream& os, const PrecacheManifest& manifest) {
+  os << "[" << manifest.id().id() << "]" << std::endl;
+  for (const PrecacheResource& resource : manifest.resource())
+    os << "\t\t" << resource << std::endl;
+  return os;
+}
+
+std::ostream& operator<<(std::ostream& os, const PrecacheResource& resource) {
+  return os << "[" << resource.url() << "," << resource.top_host_name() << ","
+            << resource.weight_ratio() << "," << resource.weight() << "]";
+}
+
+bool operator==(const PrecacheManifest& lhs, const PrecacheManifest& rhs) {
+  bool equal = lhs.id().id() == rhs.id().id() &&
+               lhs.resource_size() == rhs.resource_size();
+
+  if (!equal)
+    return false;
+
+  for (int i = 0; i < lhs.resource_size(); ++i)
+    equal = equal && lhs.resource(i) == rhs.resource(i);
+
+  return equal;
+}
+
+bool operator==(const PrecacheResource& lhs, const PrecacheResource& rhs) {
+  return lhs.url() == rhs.url() &&
+         std::fabs(lhs.weight_ratio() - rhs.weight_ratio()) <
+             std::numeric_limits<double>::epsilon();
+}
+
+}  // namespace precache