predictors: Add Manifest table to ResourcePrefetchPredictor.

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 23 matching lines @@
 using testing::SetArgPointee;
 using testing::StrictMock;
 using testing::UnorderedElementsAre;
 
 namespace predictors {
 
 using URLRequestSummary = ResourcePrefetchPredictor::URLRequestSummary;
 using PageRequestSummary = ResourcePrefetchPredictor::PageRequestSummary;
 using PrefetchDataMap = ResourcePrefetchPredictorTables::PrefetchDataMap;
 using RedirectDataMap = ResourcePrefetchPredictorTables::RedirectDataMap;
+using ManifestDataMap = ResourcePrefetchPredictorTables::ManifestDataMap;
 
 scoped_refptr<net::HttpResponseHeaders> MakeResponseHeaders(
     const char* headers) {
   return make_scoped_refptr(new net::HttpResponseHeaders(
       net::HttpUtil::AssembleRawHeaders(headers, strlen(headers))));
 }
 
 class EmptyURLRequestDelegate : public net::URLRequest::Delegate {
   void OnResponseStarted(net::URLRequest* request, int net_error) override {}
   void OnReadCompleted(net::URLRequest* request, int bytes_read) override {}
@@ skipping 69 matching lines @@
  private:
   net::HttpResponseInfo response_info_;
   std::string mime_type_;
 };
 
 class MockResourcePrefetchPredictorTables
     : public ResourcePrefetchPredictorTables {
  public:
   MockResourcePrefetchPredictorTables() { }
 
-  MOCK_METHOD4(GetAllData,
+  MOCK_METHOD5(GetAllData,
                void(PrefetchDataMap* url_data_map,
                     PrefetchDataMap* host_data_map,
                     RedirectDataMap* url_redirect_data_map,
-                    RedirectDataMap* host_redirect_data_map));
+                    RedirectDataMap* host_redirect_data_map,
+                    ManifestDataMap* manifest_data_map));
   MOCK_METHOD4(UpdateData,
                void(const PrefetchData& url_data,
                     const PrefetchData& host_data,
                     const RedirectData& url_redirect_data,
                     const RedirectData& host_redirect_data));
   MOCK_METHOD2(DeleteResourceData,
                void(const std::vector<std::string>& urls,
                     const std::vector<std::string>& hosts));
   MOCK_METHOD2(DeleteSingleResourceDataPoint,
                void(const std::string& key, PrefetchKeyType key_type));
@@ skipping 102 matching lines @@
   std::unique_ptr<TestingProfile> profile_;
   net::TestURLRequestContext url_request_context_;
 
   std::unique_ptr<ResourcePrefetchPredictor> predictor_;
   scoped_refptr<StrictMock<MockResourcePrefetchPredictorTables>> mock_tables_;
 
   PrefetchDataMap test_url_data_;
   PrefetchDataMap test_host_data_;
   RedirectDataMap test_url_redirect_data_;
   RedirectDataMap test_host_redirect_data_;
+  ManifestDataMap test_manifest_data_;
   PrefetchData empty_resource_data_;
   RedirectData empty_redirect_data_;
 
   MockURLRequestJobFactory url_request_job_factory_;
   EmptyURLRequestDelegate url_request_delegate_;
 
   std::unique_ptr<base::HistogramTester> histogram_tester_;
 };
 
 ResourcePrefetchPredictorTest::ResourcePrefetchPredictorTest()
@@ skipping 16 matching lines @@
   EXPECT_TRUE(HistoryServiceFactory::GetForProfile(
       profile_.get(), ServiceAccessType::EXPLICIT_ACCESS));
   // Initialize the predictor with empty data.
   ResetPredictor();
   EXPECT_EQ(predictor_->initialization_state_,
             ResourcePrefetchPredictor::NOT_INITIALIZED);
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))));
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))));
   InitializePredictor();
   EXPECT_TRUE(predictor_->inflight_navigations_.empty());
   EXPECT_EQ(predictor_->initialization_state_,
             ResourcePrefetchPredictor::INITIALIZED);
 
   url_request_context_.set_job_factory(&url_request_job_factory_);
 
   histogram_tester_.reset(new base::HistogramTester());
 }
 
@@ skipping 187 matching lines @@
 
 // Tests that the history and the db tables data are loaded correctly.
 TEST_F(ResourcePrefetchPredictorTest, LazilyInitializeWithData) {
   AddUrlToHistory("http://www.google.com/", 4);
   AddUrlToHistory("http://www.yahoo.com/", 2);
 
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
                       SetArgPointee<1>(test_host_data_),
                       SetArgPointee<2>(test_url_redirect_data_),
-                      SetArgPointee<3>(test_host_redirect_data_)));
+                      SetArgPointee<3>(test_host_redirect_data_),
+                      SetArgPointee<4>(test_manifest_data_)));
 
   ResetPredictor();
   InitializePredictor();
 
   // Test that the internal variables correctly initialized.
   EXPECT_EQ(predictor_->initialization_state_,
             ResourcePrefetchPredictor::INITIALIZED);
   EXPECT_TRUE(predictor_->inflight_navigations_.empty());
 
   EXPECT_EQ(test_url_data_, *predictor_->url_table_cache_);
   EXPECT_EQ(test_host_data_, *predictor_->host_table_cache_);
   EXPECT_EQ(test_url_redirect_data_, *predictor_->url_redirect_table_cache_);
   EXPECT_EQ(test_host_redirect_data_, *predictor_->host_redirect_table_cache_);
+  EXPECT_EQ(test_manifest_data_, *predictor_->manifest_table_cache_);
 }
 
 // Single navigation but history count is low, so should not record.
 TEST_F(ResourcePrefetchPredictorTest, NavigationNotRecorded) {
   const int kVisitCount = 1;
   AddUrlToHistory("https://www.google.com", kVisitCount);
 
   URLRequestSummary main_frame =
       CreateURLRequestSummary(1, "http://www.google.com");
   predictor_->RecordURLRequest(main_frame);
@@ skipping 128 matching lines @@
 // Tests that navigation is recorded correctly for URL already present in
 // the database cache.
 TEST_F(ResourcePrefetchPredictorTest, NavigationUrlInDB) {
   const int kVisitCount = 4;
   AddUrlToHistory("http://www.google.com", kVisitCount);
 
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
                       SetArgPointee<1>(test_host_data_)));
   ResetPredictor();
   InitializePredictor();
   EXPECT_EQ(3U, predictor_->url_table_cache_->size());
   EXPECT_EQ(2U, predictor_->host_table_cache_->size());
 
   URLRequestSummary main_frame = CreateURLRequestSummary(
       1, "http://www.google.com", "http://www.google.com",
       content::RESOURCE_TYPE_MAIN_FRAME, net::MEDIUM, std::string(), false);
@@ skipping 84 matching lines @@
 
 // Tests that a URL is deleted before another is added if the cache is full.
 TEST_F(ResourcePrefetchPredictorTest, NavigationUrlNotInDBAndDBFull) {
   const int kVisitCount = 4;
   AddUrlToHistory("http://www.nike.com/", kVisitCount);
 
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
                       SetArgPointee<1>(test_host_data_)));
   ResetPredictor();
   InitializePredictor();
   EXPECT_EQ(3U, predictor_->url_table_cache_->size());
   EXPECT_EQ(2U, predictor_->host_table_cache_->size());
 
   URLRequestSummary main_frame = CreateURLRequestSummary(
       1, "http://www.nike.com", "http://www.nike.com",
       content::RESOURCE_TYPE_MAIN_FRAME, net::MEDIUM, std::string(), false);
@@ skipping 99 matching lines @@
 // Tests that redirect is recorded correctly for URL already present in
 // the database cache.
 TEST_F(ResourcePrefetchPredictorTest, RedirectUrlInDB) {
   const int kVisitCount = 7;
   AddUrlToHistory("https://facebook.com/google", kVisitCount);
 
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(RedirectDataMap()))))
+                         Pointee(ContainerEq(RedirectDataMap())),
+                         Pointee(ContainerEq(ManifestDataMap()))))
       .WillOnce(DoAll(SetArgPointee<2>(test_url_redirect_data_),
                       SetArgPointee<3>(test_host_redirect_data_)));
   ResetPredictor();
   InitializePredictor();
   EXPECT_EQ(3U, predictor_->url_redirect_table_cache_->size());
   EXPECT_EQ(2U, predictor_->host_redirect_table_cache_->size());
 
   URLRequestSummary fb1 = CreateURLRequestSummary(1, "http://fb.com/google");
   predictor_->RecordURLRequest(fb1);
   EXPECT_EQ(1U, predictor_->inflight_navigations_.size());
@@ skipping 803 matching lines @@
   predictor_->host_table_cache_->insert(
       std::make_pair(google.primary_key(), google));
 
   predictor_->StartPrefetching(GURL(main_frame_url), PrefetchOrigin::EXTERNAL);
   predictor_->StopPrefetching(GURL(main_frame_url));
   histogram_tester_->ExpectTotalCount(
       internal::kResourcePrefetchPredictorPrefetchingDurationHistogram, 1);
 }
 
 }  // namespace predictors