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 436 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