predictors: Add origin learning.

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 24 matching lines @@
 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;
+using OriginDataMap = ResourcePrefetchPredictorTables::OriginDataMap;
 
 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 67 matching lines @@
  private:
   net::HttpResponseInfo response_info_;
   std::string mime_type_;
 };
 
 class MockResourcePrefetchPredictorTables
     : public ResourcePrefetchPredictorTables {
  public:
   MockResourcePrefetchPredictorTables() { }
 
-  MOCK_METHOD5(GetAllData,
+  MOCK_METHOD6(GetAllData,
                void(PrefetchDataMap* url_data_map,
                     PrefetchDataMap* host_data_map,
                     RedirectDataMap* url_redirect_data_map,
                     RedirectDataMap* host_redirect_data_map,
-                    ManifestDataMap* manifest_data_map));
+                    ManifestDataMap* manifest_data_map,
+                    OriginDataMap* origin_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(UpdateManifestData,
                void(const std::string& host,
                     const precache::PrecacheManifest& manifest_data));
+  MOCK_METHOD1(UpdateOriginData, void(const OriginData& origin_data));
   MOCK_METHOD2(DeleteResourceData,
                void(const std::vector<std::string>& urls,
                     const std::vector<std::string>& hosts));
+  MOCK_METHOD1(DeleteOriginData, void(const std::vector<std::string>& hosts));
   MOCK_METHOD2(DeleteSingleResourceDataPoint,
                void(const std::string& key, PrefetchKeyType key_type));
   MOCK_METHOD2(DeleteRedirectData,
                void(const std::vector<std::string>& urls,
                     const std::vector<std::string>& hosts));
   MOCK_METHOD2(DeleteSingleRedirectDataPoint,
                void(const std::string& key, PrefetchKeyType key_type));
   MOCK_METHOD1(DeleteManifestData, void(const std::vector<std::string>& hosts));
   MOCK_METHOD0(DeleteAllData, void());
 
@@ skipping 71 matching lines @@
   void ResetPredictor() {
     ResourcePrefetchPredictorConfig config;
     config.max_urls_to_track = 3;
     config.max_hosts_to_track = 2;
     config.min_url_visit_count = 2;
     config.max_resources_per_entry = 4;
     config.max_consecutive_misses = 2;
     config.min_resource_confidence_to_trigger_prefetch = 0.5;
     config.is_url_learning_enabled = true;
     config.is_manifests_enabled = true;
+    config.is_origin_prediction_enabled = true;
 
     config.mode |= ResourcePrefetchPredictorConfig::LEARNING;
     predictor_.reset(new ResourcePrefetchPredictor(config, profile_.get()));
     predictor_->set_mock_tables(mock_tables_);
   }
 
   void InitializeSampleData();
   void TestRedirectStatusHistogram(
       const std::string& predictor_initial_key,
       const std::string& predictor_key,
       const std::string& navigation_initial_url,
       const std::string& navigation_url,
       ResourcePrefetchPredictor::RedirectStatus expected_status);
 
   content::TestBrowserThreadBundle thread_bundle_;
   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_;
+  OriginDataMap test_origin_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 17 matching lines @@
       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(ManifestDataMap()))));
+                         Pointee(ContainerEq(ManifestDataMap())),
+                         Pointee(ContainerEq(OriginDataMap()))));
   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 121 matching lines @@
     InitializePrecacheResource(google.add_resource(),
                                "http://static.google.com/style.css", 0.333);
 
     precache::PrecacheManifest facebook = CreateManifestData(12);
     InitializePrecacheResource(facebook.add_resource(),
                                "http://fb.com/static.css", 0.99);
 
     test_manifest_data_.insert(std::make_pair("google.com", google));
     test_manifest_data_.insert(std::make_pair("facebook.com", facebook));
   }
+
+  {  // Origin data.
+    OriginData google = CreateOriginData("google.com", 12);
+    InitializeOriginStat(google.add_origins(), "https://static.google.com", 12,
+                         0, 0, 3., false, true);
+    InitializeOriginStat(google.add_origins(), "https://cats.google.com", 12, 0,
+                         0, 5., true, true);
+    test_origin_data_.insert({"google.com", google});
+
+    OriginData twitter = CreateOriginData("twitter.com", 42);
+    InitializeOriginStat(twitter.add_origins(), "https://static.twitter.com",
+                         12, 0, 0, 3., false, true);
+    InitializeOriginStat(twitter.add_origins(), "https://random.140chars.com",
+                         12, 0, 0, 3., false, true);
+    test_origin_data_.insert({"twitter.com", twitter});
+  }
 }
 
 void ResourcePrefetchPredictorTest::TestRedirectStatusHistogram(
     const std::string& predictor_initial_key,
     const std::string& predictor_key,
     const std::string& navigation_initial_url,
     const std::string& navigation_url,
     ResourcePrefetchPredictor::RedirectStatus expected_status) {
   // Database initialization.
   const std::string& script_url = "https://cdn.google.com/script.js";
@@ skipping 10 matching lines @@
     InitializeRedirectStat(redirect.add_redirect_endpoints(), predictor_key, 10,
                            0, 0);
     predictor_->host_redirect_table_cache_->insert(
         std::make_pair(redirect.primary_key(), redirect));
   }
 
   // Navigation simulation.
   using testing::_;
   EXPECT_CALL(*mock_tables_.get(), UpdateData(_, _, _, _))
       .Times(testing::AtLeast(1));
+  EXPECT_CALL(*mock_tables_.get(), UpdateOriginData(_));
+
   URLRequestSummary initial =
       CreateURLRequestSummary(1, navigation_initial_url);
   predictor_->RecordURLRequest(initial);
 
   if (navigation_initial_url != navigation_url) {
     URLRequestSummary redirect =
         CreateRedirectRequestSummary(1, navigation_initial_url, navigation_url);
     predictor_->RecordURLRedirect(redirect);
   }
   NavigationID navigation_id = CreateNavigationID(1, navigation_url);
@@ skipping 21 matching lines @@
               static_cast<int>(ResourceData_Priority_REQUEST_PRIORITY_HIGHEST),
               "Database/Net priority mismatch: Maximum");
 
 // Tests that the predictor initializes correctly without any data.
 TEST_F(ResourcePrefetchPredictorTest, LazilyInitializeEmpty) {
   EXPECT_TRUE(predictor_->url_table_cache_->empty());
   EXPECT_TRUE(predictor_->host_table_cache_->empty());
   EXPECT_TRUE(predictor_->url_redirect_table_cache_->empty());
   EXPECT_TRUE(predictor_->host_redirect_table_cache_->empty());
   EXPECT_TRUE(predictor_->manifest_table_cache_->empty());
+  EXPECT_TRUE(predictor_->origin_table_cache_->empty());
 }
 
 // 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(ManifestDataMap()))))
+                         Pointee(ContainerEq(ManifestDataMap())),
+                         Pointee(ContainerEq(OriginDataMap()))))
       .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<4>(test_manifest_data_)));
+                      SetArgPointee<4>(test_manifest_data_),
+                      SetArgPointee<5>(test_origin_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_);
+  EXPECT_EQ(test_origin_data_, *predictor_->origin_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 35 matching lines @@
                          net::MEDIUM, false, false);
   InitializeResourceData(
       host_data.add_resources(), "https://google.com/script1.js",
       content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 2.0, net::MEDIUM, false, false);
   InitializeResourceData(
       host_data.add_resources(), "https://google.com/script2.js",
       content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 3.0, net::MEDIUM, false, false);
   EXPECT_CALL(*mock_tables_.get(),
               UpdateData(empty_resource_data_, host_data, empty_redirect_data_,
                          empty_redirect_data_));
+  OriginData origin_data = CreateOriginData("www.google.com");
+  InitializeOriginStat(origin_data.add_origins(), "https://google.com/", 1, 0,
+                       0, 1., false, true);
+  EXPECT_CALL(*mock_tables_.get(), UpdateOriginData(origin_data));
 
   predictor_->RecordMainFrameLoadComplete(main_frame.navigation_id);
   profile_->BlockUntilHistoryProcessesPendingRequests();
 }
 
 // Single navigation that will be recorded. Will check for duplicate
 // resources and also for number of resources saved.
 TEST_F(ResourcePrefetchPredictorTest, NavigationUrlNotInDB) {
   const int kVisitCount = 4;
   AddUrlToHistory("http://www.google.com", kVisitCount);
@@ skipping 24 matching lines @@
       1, "http://www.google.com", "http://google.com/image1.png",
       content::RESOURCE_TYPE_IMAGE, net::MEDIUM, "image/png", false));
   predictor_->RecordURLResponse(resources.back());
   resources.push_back(CreateURLRequestSummary(
       1, "http://www.google.com", "http://google.com/image2.png",
       content::RESOURCE_TYPE_IMAGE, net::MEDIUM, "image/png", false));
   predictor_->RecordURLResponse(resources.back());
   resources.push_back(CreateURLRequestSummary(
       1, "http://www.google.com", "http://google.com/style2.css",
       content::RESOURCE_TYPE_STYLESHEET, net::MEDIUM, "text/css", true));
+
+  auto no_store = CreateURLRequestSummary(

[alexilin, 2017/04/11 09:42:19]

I'd test subresource redirect case as well to be sure that we record correct
origin.

[Benoit L, 2017/04/11 14:20:13]

Thank you, turns out that it was incorrect!

+      1, "http://www.google.com",
+      "http://static.google.com/style2-no-store.css",
+      content::RESOURCE_TYPE_STYLESHEET, net::MEDIUM, "text/css", true);
+  no_store.is_no_store = true;
+  predictor_->RecordURLResponse(no_store);
+
   predictor_->RecordURLResponse(resources.back());
 
   StrictMock<MockResourcePrefetchPredictorObserver> mock_observer(
       predictor_.get());
   EXPECT_CALL(mock_observer,
               OnNavigationLearned(
                   kVisitCount, CreatePageRequestSummary("http://www.google.com",
                                                         "http://www.google.com",
                                                         resources)));
 
   PrefetchData url_data = CreatePrefetchData("http://www.google.com/");
   InitializeResourceData(url_data.add_resources(),
                          "http://google.com/style1.css",
                          content::RESOURCE_TYPE_STYLESHEET, 1, 0, 0, 1.0,
                          net::MEDIUM, false, false);
   InitializeResourceData(
       url_data.add_resources(), "http://google.com/script1.js",
       content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 2.0, net::MEDIUM, false, false);
   InitializeResourceData(
       url_data.add_resources(), "http://google.com/script2.js",
       content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 3.0, net::MEDIUM, false, false);
   InitializeResourceData(url_data.add_resources(),
                          "http://google.com/style2.css",
                          content::RESOURCE_TYPE_STYLESHEET, 1, 0, 0, 7.0,
                          net::MEDIUM, false, false);
   EXPECT_CALL(*mock_tables_.get(),
               UpdateData(url_data, empty_resource_data_, empty_redirect_data_,
                          empty_redirect_data_));
 
+  OriginData origin_data = CreateOriginData("www.google.com");
+  InitializeOriginStat(origin_data.add_origins(), "http://static.google.com/",
+                       1, 0, 0, 2., true, true);
+  InitializeOriginStat(origin_data.add_origins(), "http://google.com/", 1, 0, 0,
+                       1., false, true);
+  EXPECT_CALL(*mock_tables_.get(), UpdateOriginData(origin_data));
+
   PrefetchData host_data = CreatePrefetchData("www.google.com");
   host_data.mutable_resources()->CopyFrom(url_data.resources());
   EXPECT_CALL(*mock_tables_.get(),
               UpdateData(empty_resource_data_, host_data, empty_redirect_data_,
                          empty_redirect_data_));
 
   predictor_->RecordMainFrameLoadComplete(main_frame.navigation_id);
   profile_->BlockUntilHistoryProcessesPendingRequests();
 }
 
 // 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(ManifestDataMap()))))
+                         Pointee(ContainerEq(ManifestDataMap())),
+                         Pointee(ContainerEq(OriginDataMap()))))
       .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 22 matching lines @@
       content::RESOURCE_TYPE_IMAGE, net::MEDIUM, "image/png", false));
   predictor_->RecordURLResponse(resources.back());
   resources.push_back(CreateURLRequestSummary(
       1, "http://www.google.com", "http://google.com/image2.png",
       content::RESOURCE_TYPE_IMAGE, net::MEDIUM, "image/png", false));
   predictor_->RecordURLResponse(resources.back());
   resources.push_back(CreateURLRequestSummary(
       1, "http://www.google.com", "http://google.com/style2.css",
       content::RESOURCE_TYPE_STYLESHEET, net::MEDIUM, "text/css", true));
   predictor_->RecordURLResponse(resources.back());
+  auto no_store = CreateURLRequestSummary(
+      1, "http://www.google.com",
+      "http://static.google.com/style2-no-store.css",
+      content::RESOURCE_TYPE_STYLESHEET, net::MEDIUM, "text/css", true);
+  no_store.is_no_store = true;
+  predictor_->RecordURLResponse(no_store);
 
   StrictMock<MockResourcePrefetchPredictorObserver> mock_observer(
       predictor_.get());
   EXPECT_CALL(mock_observer,
               OnNavigationLearned(
                   kVisitCount, CreatePageRequestSummary("http://www.google.com",
                                                         "http://www.google.com",
                                                         resources)));
 
   PrefetchData url_data = CreatePrefetchData("http://www.google.com/");
@@ skipping 29 matching lines @@
       host_data.add_resources(), "http://google.com/script2.js",
       content::RESOURCE_TYPE_SCRIPT, 1, 0, 0, 3.0, net::MEDIUM, false, false);
   InitializeResourceData(host_data.add_resources(),
                          "http://google.com/style2.css",
                          content::RESOURCE_TYPE_STYLESHEET, 1, 0, 0, 7.0,
                          net::MEDIUM, false, false);
   EXPECT_CALL(*mock_tables_.get(),
               UpdateData(empty_resource_data_, host_data, empty_redirect_data_,
                          empty_redirect_data_));
 
+  OriginData origin_data = CreateOriginData("www.google.com");
+  InitializeOriginStat(origin_data.add_origins(), "http://static.google.com/",
+                       1, 0, 0, 2., true, true);
+  InitializeOriginStat(origin_data.add_origins(), "http://google.com/", 1, 0, 0,
+                       1., false, true);
+  EXPECT_CALL(*mock_tables_.get(), UpdateOriginData(origin_data));
+
   predictor_->RecordMainFrameLoadComplete(main_frame.navigation_id);
   profile_->BlockUntilHistoryProcessesPendingRequests();
 }
 
 // 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(ManifestDataMap()))))
+                         Pointee(ContainerEq(ManifestDataMap())),
+                         Pointee(ContainerEq(OriginDataMap()))))
       .WillOnce(DoAll(SetArgPointee<0>(test_url_data_),
-                      SetArgPointee<1>(test_host_data_)));
+                      SetArgPointee<1>(test_host_data_),
+                      SetArgPointee<5>(test_origin_data_)));
   ResetPredictor();
   InitializePredictor();
   EXPECT_EQ(3U, predictor_->url_table_cache_->size());
   EXPECT_EQ(2U, predictor_->host_table_cache_->size());
+  EXPECT_EQ(2U, predictor_->origin_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);
   predictor_->RecordURLRequest(main_frame);
   EXPECT_EQ(1U, predictor_->inflight_navigations_.size());
 
   URLRequestSummary resource1 = CreateURLRequestSummary(
       1, "http://www.nike.com", "http://nike.com/style1.css",
       content::RESOURCE_TYPE_STYLESHEET, net::MEDIUM, "text/css", false);
@@ skipping 10 matching lines @@
                   kVisitCount, CreatePageRequestSummary(
                                    "http://www.nike.com", "http://www.nike.com",
                                    {resource1, resource2})));
 
   EXPECT_CALL(*mock_tables_.get(),
               DeleteSingleResourceDataPoint("http://www.google.com/",
                                             PREFETCH_KEY_TYPE_URL));
   EXPECT_CALL(*mock_tables_.get(),
               DeleteSingleResourceDataPoint("www.facebook.com",
                                             PREFETCH_KEY_TYPE_HOST));
+  EXPECT_CALL(*mock_tables_.get(),
+              DeleteOriginData(std::vector<std::string>({"google.com"})));
 
   PrefetchData url_data = CreatePrefetchData("http://www.nike.com/");
   InitializeResourceData(url_data.add_resources(), "http://nike.com/style1.css",
                          content::RESOURCE_TYPE_STYLESHEET, 1, 0, 0, 1.0,
                          net::MEDIUM, false, false);
   InitializeResourceData(url_data.add_resources(), "http://nike.com/image2.png",
                          content::RESOURCE_TYPE_IMAGE, 1, 0, 0, 2.0,
                          net::MEDIUM, false, false);
   EXPECT_CALL(*mock_tables_.get(),
               UpdateData(url_data, empty_resource_data_, empty_redirect_data_,
                          empty_redirect_data_));
 
   PrefetchData host_data = CreatePrefetchData("www.nike.com");
   host_data.mutable_resources()->CopyFrom(url_data.resources());
   EXPECT_CALL(*mock_tables_.get(),
               UpdateData(empty_resource_data_, host_data, empty_redirect_data_,
                          empty_redirect_data_));
 
+  EXPECT_CALL(*mock_tables_.get(), UpdateOriginData(testing::_));
+
   predictor_->RecordMainFrameLoadComplete(main_frame.navigation_id);
   profile_->BlockUntilHistoryProcessesPendingRequests();
 }
 
 TEST_F(ResourcePrefetchPredictorTest, RedirectUrlNotInDB) {
   const int kVisitCount = 4;
   AddUrlToHistory("https://facebook.com/google", kVisitCount);
 
   URLRequestSummary fb1 = CreateURLRequestSummary(1, "http://fb.com/google");
   predictor_->RecordURLRequest(fb1);
@@ skipping 46 matching lines @@
 // 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(ManifestDataMap()))))
+                         Pointee(ContainerEq(ManifestDataMap())),
+                         Pointee(ContainerEq(OriginDataMap()))))
       .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 58 matching lines @@
 
   predictor_->OnManifestFetched("google.com", manifest);
 }
 
 TEST_F(ResourcePrefetchPredictorTest, ManifestHostInDB) {
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(ManifestDataMap()))))
+                         Pointee(ContainerEq(ManifestDataMap())),
+                         Pointee(ContainerEq(OriginDataMap()))))
       .WillOnce(SetArgPointee<4>(test_manifest_data_));
   ResetPredictor();
   InitializePredictor();
   EXPECT_EQ(2U, predictor_->manifest_table_cache_->size());
 
   precache::PrecacheManifest manifest = CreateManifestData(1);
   InitializePrecacheResource(manifest.add_resource(),
                              "http://google.com/image.jpg", 0.1);
 
   EXPECT_CALL(*mock_tables_.get(), UpdateManifestData("google.com", manifest));
 
   predictor_->OnManifestFetched("google.com", manifest);
 }
 
 TEST_F(ResourcePrefetchPredictorTest, ManifestHostNotInDBAndDBFull) {
   EXPECT_CALL(*mock_tables_.get(),
               GetAllData(Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(PrefetchDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
                          Pointee(ContainerEq(RedirectDataMap())),
-                         Pointee(ContainerEq(ManifestDataMap()))))
+                         Pointee(ContainerEq(ManifestDataMap())),
+                         Pointee(ContainerEq(OriginDataMap()))))
       .WillOnce(SetArgPointee<4>(test_manifest_data_));
   ResetPredictor();
   InitializePredictor();
   EXPECT_EQ(2U, predictor_->manifest_table_cache_->size());
 
   precache::PrecacheManifest manifest = CreateManifestData(1);
   InitializePrecacheResource(manifest.add_resource(),
                              "http://en.wikipedia.org/logo.png", 1.0);
 
   EXPECT_CALL(*mock_tables_.get(),
@@ skipping 718 matching lines @@
   predictor_->url_table_cache_->insert(
       std::make_pair(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, TestPrecisionRecallHistograms) {
   using testing::_;
-  EXPECT_CALL(*mock_tables_.get(), UpdateData(_, _, _, _));
+  EXPECT_CALL(*mock_tables_.get(), UpdateData(_, _, _, _))
+      .Times(testing::AtLeast(1));
+  EXPECT_CALL(*mock_tables_.get(), UpdateOriginData(_));
 
   // Fill the database with 3 resources: 1 useful, 2 useless.
   const std::string main_frame_url = "http://google.com/?query=cats";
   PrefetchData google = CreatePrefetchData("google.com", 1);
 
   const std::string script_url = "https://cdn.google.com/script.js";
   InitializeResourceData(google.add_resources(), script_url,
                          content::RESOURCE_TYPE_SCRIPT, 10, 0, 1, 2.1,
                          net::MEDIUM, false, false);
   InitializeResourceData(google.add_resources(), script_url + "foo",
@@ skipping 86 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