predictors: Add origin learning.

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 <cmath>
+
+namespace {
+
+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;
 
 void InitializeResourceData(ResourceData* resource,
                             const std::string& resource_url,
                             content::ResourceType resource_type,
                             int number_of_hits,
@@ skipping 26 matching lines @@
   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);
 }
 
+void InitializeOriginStat(OriginStat* origin_stat,
+                          const std::string& origin,
+                          int number_of_hits,
+                          int number_of_misses,
+                          int consecutive_misses,
+                          double average_position,
+                          bool always_access_network,
+                          bool accessed_network) {
+  origin_stat->set_origin(origin);
+  origin_stat->set_number_of_hits(number_of_hits);
+  origin_stat->set_number_of_misses(number_of_misses);
+  origin_stat->set_consecutive_misses(consecutive_misses);
+  origin_stat->set_average_position(average_position);
+  origin_stat->set_always_access_network(always_access_network);
+  origin_stat->set_accessed_network(accessed_network);
+}
+
 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) {
   RedirectData data;
   data.set_primary_key(primary_key);
   data.set_last_visit_time(last_visit_time);
   return data;
 }
 
 precache::PrecacheManifest CreateManifestData(uint64_t id) {
   precache::PrecacheManifestId* manifest_id =
       new precache::PrecacheManifestId();
   manifest_id->set_id(id);
   precache::PrecacheManifest manifest;
   manifest.set_allocated_id(manifest_id);
   return manifest;
 }
 
+OriginData CreateOriginData(const std::string& host, uint64_t last_visit_time) {
+  OriginData data;
+  data.set_host(host);
+  data.set_last_visit_time(last_visit_time);
+  return data;
+}
+
 NavigationID CreateNavigationID(SessionID::id_type tab_id,
                                 const std::string& main_frame_url) {
   NavigationID navigation_id;
   navigation_id.tab_id = tab_id;
   navigation_id.main_frame_url = GURL(main_frame_url);
   navigation_id.creation_time = base::TimeTicks::Now();
   return navigation_id;
 }
 
 PageRequestSummary CreatePageRequestSummary(
@@ skipping 14 matching lines @@
                                           net::RequestPriority priority,
                                           const std::string& mime_type,
                                           bool was_cached,
                                           const std::string& redirect_url,
                                           bool has_validators,
                                           bool always_revalidate) {
   URLRequestSummary summary;
   summary.navigation_id = CreateNavigationID(tab_id, main_frame_url);
   summary.resource_url =
       resource_url.empty() ? GURL(main_frame_url) : GURL(resource_url);
+  summary.request_url = summary.resource_url;
   summary.resource_type = resource_type;
   summary.priority = priority;
   summary.mime_type = mime_type;
   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;
 }
 
 std::ostream& operator<<(std::ostream& os, const PrefetchData& data) {
   os << "[" << data.primary_key() << "," << data.last_visit_time() << "]"
      << std::endl;
   for (const ResourceData& resource : data.resources())
     os << "\t\t" << resource << std::endl;
   return os;
 }
@@ skipping 15 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 OriginData& data) {
+  os << "[" << data.host() << "," << data.last_visit_time() << "]" << std::endl;
+  for (const OriginStat& origin : data.origins())
+    os << "\t\t" << origin << std::endl;
+  return os;
+}
+
+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 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
@@ skipping 19 matching lines @@
 
   return equal;
 }
 
 bool operator==(const ResourceData& lhs, const ResourceData& rhs) {
   return lhs.resource_url() == rhs.resource_url() &&
          lhs.resource_type() == rhs.resource_type() &&
          lhs.number_of_hits() == rhs.number_of_hits() &&
          lhs.number_of_misses() == rhs.number_of_misses() &&
          lhs.consecutive_misses() == rhs.consecutive_misses() &&
-         lhs.average_position() == rhs.average_position() &&
+         AlmostEqual(lhs.average_position(), rhs.average_position()) &&
          lhs.priority() == rhs.priority() &&
          lhs.has_validators() == rhs.has_validators() &&
          lhs.always_revalidate() == rhs.always_revalidate();
 }
 
 bool operator==(const RedirectData& lhs, const RedirectData& rhs) {
   bool equal = lhs.primary_key() == rhs.primary_key() &&
                lhs.redirect_endpoints_size() == rhs.redirect_endpoints_size();
 
   if (!equal)
@@ skipping 22 matching lines @@
   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;
 }
 
+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;
+}
+
+bool operator==(const OriginStat& lhs, const OriginStat& rhs) {
+  return lhs.origin() == rhs.origin() &&
+         lhs.number_of_hits() == rhs.number_of_hits() &&
+         lhs.number_of_misses() == rhs.number_of_misses() &&
+         lhs.consecutive_misses() == rhs.consecutive_misses() &&
+         AlmostEqual(lhs.average_position(), rhs.average_position()) &&
+         lhs.always_access_network() == rhs.always_access_network() &&
+         lhs.accessed_network() == rhs.accessed_network();
+}
+
 }  // 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;
 }
@@ skipping 11 matching lines @@
     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();
+         AlmostEqual(lhs.weight_ratio(), rhs.weight_ratio());
 }
 
 }  // namespace precache