predictors: Move more methods from ResourcePrefetchPredictor into LoadingDataCollector.

chrome/browser/predictors/resource_prefetch_predictor_unittest.cc

 // Copyright 2014 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.h"
 
 #include <iostream>
 #include <memory>
 #include <utility>
 
@@ skipping 17 matching lines @@
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_job.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::StrictMock;
 using testing::UnorderedElementsAre;
 
 namespace predictors {
 
-using URLRequestSummary = ResourcePrefetchPredictor::URLRequestSummary;
-using PageRequestSummary = ResourcePrefetchPredictor::PageRequestSummary;
 using PrefetchDataMap = std::map<std::string, PrefetchData>;
 using RedirectDataMap = std::map<std::string, RedirectData>;
 using OriginDataMap = std::map<std::string, OriginData>;
 using ManifestDataMap = std::map<std::string, precache::PrecacheManifest>;
 
-template <typename T>
-class FakeGlowplugKeyValueTable : public GlowplugKeyValueTable<T> {
- public:
-  FakeGlowplugKeyValueTable() : GlowplugKeyValueTable<T>("") {}
-  void GetAllData(std::map<std::string, T>* data_map,
-                  sql::Connection* db) const override {
-    *data_map = data_;
-  }
-  void UpdateData(const std::string& key,
-                  const T& data,
-                  sql::Connection* db) override {
-    data_[key] = data;
-  }
-  void DeleteData(const std::vector<std::string>& keys,
-                  sql::Connection* db) override {
-    for (const auto& key : keys)
-      data_.erase(key);
-  }
-  void DeleteAllData(sql::Connection* db) override { data_.clear(); }
-
-  std::map<std::string, T> data_;
-};
-
-class MockResourcePrefetchPredictorTables
-    : public ResourcePrefetchPredictorTables {
- public:
-  MockResourcePrefetchPredictorTables() = default;
-
-  void ScheduleDBTask(const tracked_objects::Location& from_here,
-                      DBTask task) override {
-    ExecuteDBTaskOnDBThread(std::move(task));
-  }
-
-  void ExecuteDBTaskOnDBThread(DBTask task) override {
-    std::move(task).Run(nullptr);
-  }
-
-  GlowplugKeyValueTable<PrefetchData>* url_resource_table() override {
-    return &url_resource_table_;
-  }
-
-  GlowplugKeyValueTable<RedirectData>* url_redirect_table() override {
-    return &url_redirect_table_;
-  }
-
-  GlowplugKeyValueTable<PrefetchData>* host_resource_table() override {
-    return &host_resource_table_;
-  }
-
-  GlowplugKeyValueTable<RedirectData>* host_redirect_table() override {
-    return &host_redirect_table_;
-  }
-
-  GlowplugKeyValueTable<precache::PrecacheManifest>* manifest_table() override {
-    return &manifest_table_;
-  }
-
-  GlowplugKeyValueTable<OriginData>* origin_table() override {
-    return &origin_table_;
-  }
-
-  FakeGlowplugKeyValueTable<PrefetchData> url_resource_table_;
-  FakeGlowplugKeyValueTable<RedirectData> url_redirect_table_;
-  FakeGlowplugKeyValueTable<PrefetchData> host_resource_table_;
-  FakeGlowplugKeyValueTable<RedirectData> host_redirect_table_;
-  FakeGlowplugKeyValueTable<precache::PrecacheManifest> manifest_table_;
-  FakeGlowplugKeyValueTable<OriginData> origin_table_;
-
- protected:
-  ~MockResourcePrefetchPredictorTables() override = default;
-};
-
-class MockResourcePrefetchPredictorObserver : public TestObserver {
- public:
-  explicit MockResourcePrefetchPredictorObserver(
-      ResourcePrefetchPredictor* predictor)
-      : TestObserver(predictor) {}
-
-  MOCK_METHOD2(
-      OnNavigationLearned,
-      void(size_t url_visit_count,
-           const ResourcePrefetchPredictor::PageRequestSummary& summary));
-};
-
 class ResourcePrefetchPredictorTest : public testing::Test {
  public:
   ResourcePrefetchPredictorTest();
   ~ResourcePrefetchPredictorTest() override;
   void SetUp() override;
   void TearDown() override;
 
  protected:
-  void AddUrlToHistory(const std::string& url, int visit_count) {
-    HistoryServiceFactory::GetForProfile(profile_.get(),
-                                         ServiceAccessType::EXPLICIT_ACCESS)->
-        AddPageWithDetails(
-            GURL(url),
-            base::string16(),
-            visit_count,
-            0,
-            base::Time::Now(),
-            false,
-            history::SOURCE_BROWSED);
-    profile_->BlockUntilHistoryProcessesPendingRequests();
-  }
-
-  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;
-  }
-
   void InitializePredictor() {
     loading_predictor_->StartInitialization();
     base::RunLoop loop;
     loop.RunUntilIdle();  // Runs the DB lookup.
     profile_->BlockUntilHistoryProcessesPendingRequests();
   }
 
   void ResetPredictor(bool small_db = true) {
     LoadingPredictorConfig config;
     PopulateTestConfig(&config, small_db);
@@ skipping 254 matching lines @@
   InitializePredictor();
 
   // Test that the internal variables correctly initialized.
   EXPECT_EQ(predictor_->initialization_state_,
             ResourcePrefetchPredictor::INITIALIZED);
   EXPECT_TRUE(predictor_->inflight_navigations_.empty());
 
   // Integrity of the cache and the backend storage is checked on TearDown.
 }
 
+/*
 // Single navigation but history count is low, so should not record url data.
 TEST_F(ResourcePrefetchPredictorTest, NavigationLowHistoryCount) {
   const int kVisitCount = 1;
   AddUrlToHistory("https://www.google.com", kVisitCount);
 
   URLRequestSummary main_frame =
       CreateURLRequestSummary(1, "http://www.google.com");
   predictor_->RecordURLRequest(main_frame);
   EXPECT_EQ(1U, predictor_->inflight_navigations_.size());
 
@@ skipping 477 matching lines @@
   RedirectData host_redirect_data = CreateRedirectData("fb.com");
   InitializeRedirectStat(host_redirect_data.add_redirect_endpoints(),
                          "facebook.com", 1, 0, 0);
   RedirectDataMap expected_host_redirect_data = test_host_redirect_data_;
   expected_host_redirect_data.erase("bbc.com");
   expected_host_redirect_data[host_redirect_data.primary_key()] =
       host_redirect_data;
   EXPECT_EQ(mock_tables_->host_redirect_table_.data_,
             expected_host_redirect_data);
 }
+*/
 
 TEST_F(ResourcePrefetchPredictorTest, ManifestHostNotInDB) {
   precache::PrecacheManifest manifest =
       CreateManifestData(base::Time::Now().ToDoubleT());
   InitializePrecacheResource(manifest.add_resource(),
                              "http://cdn.google.com/script.js", 0.9,
                              precache::PrecacheResource::RESOURCE_TYPE_SCRIPT);
   InitializePrecacheResource(
       manifest.add_resource(), "http://cdn.google.com/style.css", 0.75,
       precache::PrecacheResource::RESOURCE_TYPE_STYLESHEET);
@@ skipping 202 matching lines @@
   EXPECT_EQ(mock_tables_->manifest_table_.data_, manifests);
 
   predictor_->DeleteAllUrls();
   EXPECT_TRUE(mock_tables_->url_resource_table_.data_.empty());
   EXPECT_TRUE(mock_tables_->host_resource_table_.data_.empty());
   EXPECT_TRUE(mock_tables_->url_redirect_table_.data_.empty());
   EXPECT_TRUE(mock_tables_->host_redirect_table_.data_.empty());
   EXPECT_TRUE(mock_tables_->manifest_table_.data_.empty());
 }
 
+/*
 TEST_F(ResourcePrefetchPredictorTest, OnMainFrameRequest) {
   URLRequestSummary summary1 = CreateURLRequestSummary(
       1, "http://www.google.com", "http://www.google.com",
       content::RESOURCE_TYPE_MAIN_FRAME, net::MEDIUM, std::string(), false);
   URLRequestSummary summary2 = CreateURLRequestSummary(
       2, "http://www.google.com", "http://www.google.com",
       content::RESOURCE_TYPE_MAIN_FRAME, net::MEDIUM, std::string(), false);
   URLRequestSummary summary3 = CreateURLRequestSummary(
       3, "http://www.yahoo.com", "http://www.yahoo.com",
       content::RESOURCE_TYPE_MAIN_FRAME, net::MEDIUM, std::string(), false);
@@ skipping 142 matching lines @@
   EXPECT_EQ(resource1,
             predictor_->inflight_navigations_[main_frame1.navigation_id]
                 ->subresource_requests[0]);
   EXPECT_EQ(resource2,
             predictor_->inflight_navigations_[main_frame1.navigation_id]
                 ->subresource_requests[1]);
   EXPECT_EQ(resource3,
             predictor_->inflight_navigations_[main_frame1.navigation_id]
                 ->subresource_requests[2]);
 }
+*/
 
 TEST_F(ResourcePrefetchPredictorTest, SummarizeResponse) {
   net::HttpResponseInfo response_info;
   response_info.headers =
       MakeResponseHeaders("HTTP/1.1 200 OK\n\nSome: Headers\n");
   response_info.was_cached = true;
   url_request_job_factory_.set_response_info(response_info);
 
   GURL url("http://www.google.com/cat.png");
   std::unique_ptr<net::URLRequest> request =
@@ skipping 297 matching lines @@
                          content::RESOURCE_TYPE_FONT_RESOURCE, 10, 0, 1, 2.1,
                          net::MEDIUM, false, false);
   predictor_->url_resource_data_->UpdateData(www_google_url.primary_key(),
                                              www_google_url);
 
   urls.clear();
   EXPECT_TRUE(predictor_->GetPrefetchData(main_frame_url, &prediction));
   EXPECT_THAT(urls, UnorderedElementsAre(GURL(font_url)));
 }
 
+/*
 TEST_F(ResourcePrefetchPredictorTest, TestRecordFirstContentfulPaint) {
   auto res1_time = base::TimeTicks::FromInternalValue(1);
   auto res2_time = base::TimeTicks::FromInternalValue(2);
   auto fcp_time = base::TimeTicks::FromInternalValue(3);
   auto res3_time = base::TimeTicks::FromInternalValue(4);
 
   URLRequestSummary main_frame =
       CreateURLRequestSummary(1, "http://www.google.com");
   predictor_->RecordURLRequest(main_frame);
   EXPECT_EQ(1U, predictor_->inflight_navigations_.size());
@@ skipping 19 matching lines @@
   predictor_->RecordMainFrameLoadComplete(main_frame.navigation_id);
   profile_->BlockUntilHistoryProcessesPendingRequests();
 
   PrefetchData host_data = CreatePrefetchData("www.google.com");
   InitializeResourceData(host_data.add_resources(),
                          "http://google.com/style1.css",
                          content::RESOURCE_TYPE_STYLESHEET, 1, 0, 0, 1.0,
                          net::MEDIUM, false, false);
   InitializeResourceData(
       host_data.add_resources(), "http://google.com/script1.js",
-      content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 2.0, net::MEDIUM, false, false);
+      content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 2.0, net::MEDIUM, false,
+      false);
   ResourceData* resource3_rd = host_data.add_resources();
   InitializeResourceData(resource3_rd, "http://google.com/script2.js",
                          content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 3.0,
                          net::MEDIUM, false, false);
   resource3_rd->set_before_first_contentful_paint(false);
   EXPECT_EQ(mock_tables_->host_resource_table_.data_,
             PrefetchDataMap({{host_data.primary_key(), host_data}}));
 }
+*/
 
 }  // namespace predictors