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;
 
+MockResourcePrefetchPredictorTables::MockResourcePrefetchPredictorTables() =
+    default;
+
+void MockResourcePrefetchPredictorTables::ScheduleDBTask(
+    const tracked_objects::Location& from_here,
+    DBTask task) {
+  ExecuteDBTaskOnDBThread(std::move(task));
+}
+
+void MockResourcePrefetchPredictorTables::ExecuteDBTaskOnDBThread(DBTask task) {
+  std::move(task).Run(nullptr);
+}
+
+GlowplugKeyValueTable<PrefetchData>*
+MockResourcePrefetchPredictorTables::url_resource_table() {
+  return &url_resource_table_;
+}
+
+GlowplugKeyValueTable<RedirectData>*
+MockResourcePrefetchPredictorTables::url_redirect_table() {
+  return &url_redirect_table_;
+}
+
+GlowplugKeyValueTable<PrefetchData>*
+MockResourcePrefetchPredictorTables::host_resource_table() {
+  return &host_resource_table_;
+}
+
+GlowplugKeyValueTable<RedirectData>*
+MockResourcePrefetchPredictorTables::host_redirect_table() {
+  return &host_redirect_table_;
+}
+
+GlowplugKeyValueTable<precache::PrecacheManifest>*
+MockResourcePrefetchPredictorTables::manifest_table() {
+  return &manifest_table_;
+}
+
+GlowplugKeyValueTable<OriginData>*
+MockResourcePrefetchPredictorTables::origin_table() {
+  return &origin_table_;
+}
+
+MockResourcePrefetchPredictorTables::~MockResourcePrefetchPredictorTables() =
+    default;
+
+MockResourcePrefetchPredictorObserver::MockResourcePrefetchPredictorObserver(
+    ResourcePrefetchPredictor* predictor)
+    : TestObserver(predictor) {}
+
+MockResourcePrefetchPredictorObserver::
+    ~MockResourcePrefetchPredictorObserver() {}
+
 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 105 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 206 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;

[alexilin, 2017/06/23 16:55:05]

It's seems like we need to compare lhs.origins and rhs.origins here.

[trevordixon, 2017/06/27 21:28:55]

Done.

 }
 
 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 &&
@@ skipping 52 matching lines @@
 
   return equal;
 }
 
 bool operator==(const PrecacheResource& lhs, const PrecacheResource& rhs) {
   return lhs.url() == rhs.url() &&
          AlmostEqual(lhs.weight_ratio(), rhs.weight_ratio());
 }
 
 }  // namespace precache