predictors: Pass manifests from Bork to store in ResourcePrefetchPredictor.

components/precache/core/precache_fetcher_unittest.cc

 // Copyright 2013 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 "components/precache/core/precache_fetcher.h"
 
 #include <stdint.h>
 
 #include <cstring>
 #include <memory>
@@ skipping 99 matching lines @@
 class TestPrecacheDelegate : public PrecacheFetcher::PrecacheDelegate {
  public:
   TestPrecacheDelegate()
       : on_done_was_called_(false) {}
 
   void OnDone() override {
     LOG(INFO) << "OnDone";
     on_done_was_called_ = true;
   }
 
+  void OnManifestFetched(const std::string& host,
+                         const PrecacheManifest& manifest) override {
+    hosts.push_back(host);
+  }
+
   bool was_on_done_called() const {
     return on_done_was_called_;
   }
 
+  void clear_manifest_hosts() { hosts.clear(); }
+
+  std::vector<std::string> get_manifest_hosts() const { return hosts; }
+
  private:
   bool on_done_was_called_;
+  std::vector<std::string> hosts;
 };
 
 class MockURLFetcherFactory : public net::URLFetcherFactory {
  public:
   typedef net::URLFetcher* DoURLFetcher(
       int id,
       const GURL& url,
       net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* delegate);
 
@@ skipping 425 matching lines @@
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.emplace_back(kManifestFetchFailureURL);
   expected_requested_urls.emplace_back(kBadManifestURL);
   expected_requested_urls.emplace_back(kGoodManifestURL);
   expected_requested_urls.emplace_back(kForcedStartingURLManifestURL);
   expected_requested_urls.emplace_back(kResourceFetchFailureURL);
   expected_requested_urls.emplace_back(kGoodResourceURL);
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {
+      "good-manifest.com", "forced-starting-url.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
                                url_callback_.total_response_bytes(), 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 class PrecacheFetcherResourceSelectionTest
     : public PrecacheFetcherTest,
@@ skipping 66 matching lines @@
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.emplace_back(kGoodManifestURL);
   expected_requested_urls.emplace_back(kGoodResourceURL);
   expected_requested_urls.emplace_back(kGoodResourceURLC);
   expected_requested_urls.emplace_back(kGoodResourceURLD);
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
                                url_callback_.total_response_bytes(), 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 TEST_P(PrecacheFetcherResourceSelectionTest, MissingBitset) {
   SetDefaultFlags();
@@ skipping 54 matching lines @@
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.emplace_back(kGoodManifestURL);
   expected_requested_urls.emplace_back(kGoodResourceURL);
   expected_requested_urls.emplace_back(kGoodResourceURLA);
   expected_requested_urls.emplace_back(kGoodResourceURLB);
   expected_requested_urls.emplace_back(kGoodResourceURLC);
   expected_requested_urls.emplace_back(kGoodResourceURLD);
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
                                url_callback_.total_response_bytes(), 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 INSTANTIATE_TEST_CASE_P(
     PrecacheFetcherResourceSelectionTest,
@@ skipping 46 matching lines @@
                                  std::move(unfinished_work), kExperimentID,
                                  precache_database_.GetWeakPtr(), task_runner(),
                                  &precache_delegate_);
   second_fetcher.Start();
   base::RunLoop().RunUntilIdle();
   expected_requested_urls.emplace_back(
       "http://manifest-url-prefix.com/manifest1.com");
   expected_requested_urls.emplace_back(
       "http://manifest-url-prefix.com/manifest2.com");
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+
+  EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, ResumeWithConfigOnly) {
   SetDefaultFlags();
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->mutable_config_settings()->add_forced_site(
       "good-manifest.com");
   unfinished_work->set_start_time(base::Time::Now().ToInternalValue());
@@ skipping 13 matching lines @@
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
   }
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kGoodManifestURL);
   expected_requested_urls.emplace_back(kGoodResourceURL);
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 
 TEST_F(PrecacheFetcherTest, CustomURLs) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("good-manifest.com");
@@ skipping 19 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kCustomConfigURL);
   expected_requested_urls.emplace_back(kCustomGoodManifestURL);
   expected_requested_urls.emplace_back(kGoodResourceURL);
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, ConfigFetchFailure) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("good-manifest.com");
 
   factory_.SetFakeResponse(GURL(kConfigURL), "",
                            net::HTTP_INTERNAL_SERVER_ERROR,
                            net::URLRequestStatus::FAILED);
   factory_.SetFakeResponse(GURL(kGoodManifestURL), "", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(
       request_context_.get(), GURL(), std::string(), std::move(unfinished_work),
       kExperimentID, precache_database_.GetWeakPtr(), task_runner(),
       &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.emplace_back(kGoodManifestURL);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, BadConfig) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("good-manifest.com");
 
   factory_.SetFakeResponse(GURL(kConfigURL), "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodManifestURL), "", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(
       request_context_.get(), GURL(), std::string(), std::move(unfinished_work),
       kExperimentID, precache_database_.GetWeakPtr(), task_runner(),
       &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.emplace_back(kGoodManifestURL);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, Cancel) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("starting-url.com");
 
@@ skipping 16 matching lines @@
     // should be recorded because this should not cause OnDone to be
     // called on the precache delegate.
   }
 
   base::RunLoop().RunUntilIdle();
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kConfigURL);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_FALSE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 0);
 }
 
 #if defined(PRECACHE_CONFIG_SETTINGS_URL)
 
 // If the default precache configuration settings URL is defined, then test that
 // it works with the PrecacheFetcher.
 TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultConfigSettingsURL) {
@@ skipping 13 matching lines @@
       kExperimentID, precache_database_.GetWeakPtr(), task_runner(),
       &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(PRECACHE_CONFIG_SETTINGS_URL);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 #endif  // PRECACHE_CONFIG_SETTINGS_URL
 
 #if defined(PRECACHE_MANIFEST_URL_PREFIX)
 
 // If the default precache manifest URL prefix is defined, then test that it
 // works with the PrecacheFetcher.
 TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultManifestURLPrefix) {
@@ skipping 20 matching lines @@
       &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.push_back(manifest_url);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"starting-url.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 #endif  // PRECACHE_MANIFEST_URL_PREFIX
 
 TEST_F(PrecacheFetcherTest, TopResourcesCount) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
@@ skipping 34 matching lines @@
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.emplace_back(kGoodManifestURL);
   expected_requested_urls.emplace_back("http://good-manifest.com/retrieved");
   expected_requested_urls.emplace_back("http://good-manifest.com/retrieved");
   expected_requested_urls.emplace_back("http://good-manifest.com/retrieved");
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
                                url_callback_.total_response_bytes(), 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 TEST_F(PrecacheFetcherTest, TopResourcesCount_ResourceBitset) {
   SetDefaultFlags();
@@ skipping 39 matching lines @@
   }
 
   std::vector<GURL> expected_requested_urls;
   expected_requested_urls.emplace_back(kConfigURL);
   expected_requested_urls.emplace_back(kGoodManifestURL);
   expected_requested_urls.emplace_back("http://good-manifest.com/retrieved");
   expected_requested_urls.emplace_back("http://good-manifest.com/retrieved");
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
                                url_callback_.total_response_bytes(), 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 // MaxBytesPerResource is impossible to test with net::FakeURLFetcherFactory:
 //
@@ skipping 65 matching lines @@
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
   }
 
   // Fetcher should request config, manifest, and all but 3 resources. For some
   // reason, we are seeing it fetch all but 4 resources. Meh, close enough.
   EXPECT_EQ(1 + 1 + kNumResources - 4, url_callback_.requested_urls().size());
 
+  std::vector<std::string> expected_manifest_hosts = {"good-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectTotalCount("Precache.Fetch.PercentCompleted", 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 
   const double expected_min_weight =
       good_manifest.resource(kNumResources - 3).weight_ratio() *
       1 /* # of visits to good-manifest.com */;
   histogram.ExpectBucketCount("Precache.Fetch.MinWeight",
                               1000.0 * expected_min_weight, 1);
 }
 
 // Tests the parallel fetch behaviour when more precache resource and manifest
 // requests are available than the maximum capacity of fetcher pool.
 TEST_F(PrecacheFetcherTest, FetcherPoolMaxLimitReached) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 5;
   const size_t kNumResources = kMaxParallelFetches + 5;
 
   PrecacheConfigurationSettings config;
   std::vector<GURL> expected_requested_urls;
+  std::vector<std::string> expected_manifest_hosts;
 
   config.set_top_sites_count(kNumTopHosts);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     expected_requested_urls.emplace_back(kManifestURLPrefix + top_host_url);
+    expected_manifest_hosts.push_back(top_host_url);
   }
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     unfinished_work->add_top_host()->set_hostname(top_host_url);
 
     PrecacheManifest manifest;
     for (size_t j = 0; j < kNumResources; ++j) {
       const std::string resource_url =
           base::StringPrintf("http://top-host-%zu.com/resource-%zu", i, j);
@@ skipping 21 matching lines @@
 
     base::RunLoop().RunUntilIdle();
 
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
   EXPECT_TRUE(parallel_fetches_beyond_capacity_);
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 100, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total",
                                url_callback_.total_response_bytes(), 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 TEST_F(PrecacheFetcherTest, FilterInvalidManifestUrls) {
   SetDefaultFlags();
@@ skipping 16 matching lines @@
         std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
   }
 
   // The config is fetched, but not the invalid manifest URL.
   EXPECT_EQ(1UL, url_callback_.requested_urls().size());
 
+  EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   // manifest.com will have been failed to complete, in this case.
   EXPECT_THAT(histogram.GetAllSamples("Precache.Fetch.PercentCompleted"),
               ElementsAre(base::Bucket(101, 1)));
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 TEST_F(PrecacheFetcherTest, FilterInvalidResourceUrls) {
   SetDefaultFlags();
@@ skipping 20 matching lines @@
         std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
   }
 
   // The config and manifest are fetched, but not the invalid resource URL.
   EXPECT_EQ(2UL, url_callback_.requested_urls().size());
 
+  std::vector<std::string> expected_manifest_hosts = {"bad-manifest.com"};
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   // bad-manifest.com will have been completed.
   EXPECT_THAT(histogram.GetAllSamples("Precache.Fetch.PercentCompleted"),
               ElementsAre(base::Bucket(101, 1)));
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 TEST(PrecacheFetcherStandaloneTest, GetResourceURLBase64Hash) {
   // Expected base64 hash for some selected URLs.
@@ skipping 144 matching lines @@
       public testing::WithParamInterface<
           PrecacheConfigurationSettings::ResourceWeightFunction> {};
 
 TEST_P(PrecacheFetcherGlobalRankingTest, GloballyRankResources) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 5;
   const size_t kNumResources = 5;
 
   std::vector<GURL> expected_requested_urls;
+  std::vector<std::string> expected_manifest_hosts;
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(kNumTopHosts);
   config.set_global_ranking(true);
   config.set_resource_weight_function(GetParam());
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     expected_requested_urls.emplace_back(kManifestURLPrefix + top_host_url);
+    expected_manifest_hosts.push_back(top_host_url);
   }
 
   // Visit counts and weights are chosen in such a way that resource requests
   // between different hosts will be interleaved.
   std::vector<std::pair<std::string, float>> resources;
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     TopHost* top_host = unfinished_work->add_top_host();
     top_host->set_hostname(top_host_url);
     top_host->set_visits(kNumTopHosts - i);
@@ skipping 28 matching lines @@
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
         std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 INSTANTIATE_TEST_CASE_P(
     PrecacheFetcherGlobalRankingTest,
     PrecacheFetcherGlobalRankingTest,
     testing::Values(PrecacheConfigurationSettings::FUNCTION_NAIVE,
                     PrecacheConfigurationSettings::FUNCTION_GEOMETRIC));
 
 TEST_F(PrecacheFetcherTest, GloballyRankResourcesAfterPauseResume) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 5;
   const size_t kNumResources = 5;
 
   std::vector<GURL> expected_requested_urls;
+  std::vector<std::string> expected_manifest_hosts;
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(kNumTopHosts);
   config.set_global_ranking(true);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   // Visit counts and weights are chosen in such a way that resource requests
   // between different hosts will be interleaved.
   std::vector<std::pair<std::string, float>> resources;
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
+    expected_manifest_hosts.push_back(top_host_url);
     TopHost* top_host = unfinished_work->add_top_host();
     top_host->set_hostname(top_host_url);
     top_host->set_visits(kNumTopHosts - i);
 
     PrecacheManifest manifest;
     for (size_t j = 0; j < kNumResources; ++j) {
       const float weight = 1 - static_cast<float>(j) / kNumResources;
       const std::string resource_url =
           base::StringPrintf("http://top-host-%zu.com/resource-%zu-weight-%.1f",
                              i, j, top_host->visits() * weight);
@@ skipping 42 matching lines @@
 
     // Cancel precaching.
     cancelled_work = precache_fetcher.CancelPrecaching();
     EXPECT_TRUE(precache_fetcher.top_hosts_to_fetch_.empty());
     EXPECT_TRUE(precache_fetcher.resources_to_fetch_.empty());
   }
   EXPECT_NE(cancelled_work, nullptr);
   EXPECT_TRUE(cancelled_work->top_host().empty());
   EXPECT_EQ(kNumTopHosts * kNumResources,
             static_cast<size_t>(cancelled_work->resource().size()));
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_FALSE(precache_delegate_.was_on_done_called());
 
   url_callback_.clear_requested_urls();
+  precache_delegate_.clear_manifest_hosts();
 
   // Continuing with the precache should fetch all resources, as the previous
   // run was cancelled before any finished. They should be fetched in global
   // ranking order.
 
   base::HistogramTester histogram;
 
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
         std::move(cancelled_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     LOG(INFO) << "Resuming prefetch.";
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
   }
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+  EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectBucketCount("Precache.Fetch.MinWeight",
                               1000.0 * resources.back().second, 1);
 }
 
 TEST_F(PrecacheFetcherTest, MaxTotalResources) {
   SetDefaultFlags();
 
   const size_t kNumResources = 5;
 
   std::vector<GURL> expected_requested_urls;
+  std::vector<std::string> expected_manifest_hosts;
 
   PrecacheConfigurationSettings config;
   config.set_total_resources_count(2);
   config.set_global_ranking(true);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   TopHost* top_host = unfinished_work->add_top_host();
   top_host->set_hostname("top-host.com");
   top_host->set_visits(1);
 
   expected_requested_urls.emplace_back(kManifestURLPrefix +
                                        top_host->hostname());
+  expected_manifest_hosts.push_back(top_host->hostname());
 
   PrecacheManifest manifest;
   for (size_t i = 0; i < kNumResources; ++i) {
     const float weight = 1 - static_cast<float>(i) / kNumResources;
     const std::string resource_url =
         base::StringPrintf("http://top-host.com/resource-%zu-weight-%.1f", i,
                            top_host->visits() * weight);
     PrecacheResource* resource = manifest.add_resource();
     resource->set_url(resource_url);
     resource->set_weight_ratio(weight);
@@ skipping 11 matching lines @@
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
         std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   const float expected_min_weight =
       manifest.resource(config.total_resources_count() - 1).weight_ratio();
   histogram.ExpectUniqueSample("Precache.Fetch.MinWeight",
                                1000.0 * expected_min_weight, 1);
 }
 
 TEST_F(PrecacheFetcherTest, MinWeight) {
   SetDefaultFlags();
 
   const size_t kNumResources = 5;
 
   std::vector<GURL> expected_requested_urls;
+  std::vector<std::string> expected_manifest_hosts;
 
   PrecacheConfigurationSettings config;
   config.set_min_weight(3);
   config.set_global_ranking(true);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   TopHost* top_host = unfinished_work->add_top_host();
   top_host->set_hostname("top-host.com");
   top_host->set_visits(5);
 
   expected_requested_urls.emplace_back(kManifestURLPrefix +
                                        top_host->hostname());
+  expected_manifest_hosts.push_back(top_host->hostname());
 
   PrecacheManifest manifest;
   for (size_t i = 0; i < kNumResources; ++i) {
     const float weight = 1 - static_cast<float>(i) / kNumResources;
     const std::string resource_url =
         base::StringPrintf("http://top-host.com/resource-%zu-weight-%.1f", i,
                            top_host->visits() * weight);
     PrecacheResource* resource = manifest.add_resource();
     resource->set_url(resource_url);
     resource->set_weight_ratio(weight);
@@ skipping 10 matching lines @@
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
         std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
   }
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 // Tests cancel precaching when all tophost manifests are fetched, but some
 // resource fetches are pending.
 TEST_F(PrecacheFetcherTest, CancelPrecachingAfterAllManifestFetch) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 5;
   const size_t kNumResources = 5;
 
   PrecacheConfigurationSettings config;
   std::vector<GURL> expected_requested_urls;
+  std::vector<std::string> expected_manifest_hosts;
   std::unique_ptr<PrecacheUnfinishedWork> cancelled_work;
 
   config.set_top_sites_count(kNumTopHosts);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     expected_requested_urls.emplace_back(kManifestURLPrefix + top_host_url);
+    expected_manifest_hosts.push_back(top_host_url);
   }
 
   int num_resources = 0;
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     TopHost* top_host = unfinished_work->add_top_host();
     top_host->set_hostname(top_host_url);
     top_host->set_visits(kNumTopHosts - i);
 
     PrecacheManifest manifest;
@@ skipping 38 matching lines @@
     cancelled_work = precache_fetcher.CancelPrecaching();
     EXPECT_TRUE(precache_fetcher.top_hosts_to_fetch_.empty());
     EXPECT_TRUE(precache_fetcher.resources_to_fetch_.empty());
   }
   ASSERT_NE(nullptr, cancelled_work);
   EXPECT_TRUE(cancelled_work->top_host().empty());
   EXPECT_EQ(kNumTopHosts * kNumResources,
             static_cast<size_t>(cancelled_work->resource().size()));
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
-
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_FALSE(precache_delegate_.was_on_done_called());
 
   // Continuing with the precache should fetch all resources, as the previous
   // run was cancelled before any finished.
   expected_requested_urls.clear();
   url_callback_.clear_requested_urls();
+  precache_delegate_.clear_manifest_hosts();
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     for (size_t j = 0; j < kNumResources; ++j) {
       expected_requested_urls.emplace_back(
           base::StringPrintf("http://top-host-%zu.com/resource-%zu", i, j));
     }
   }
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
         std::move(cancelled_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     LOG(INFO) << "Resuming prefetch.";
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
   }
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+  EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, DailyQuota) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 3;
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(kNumTopHosts);
   config.set_daily_quota_total(10000);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   std::vector<GURL> expected_requested_urls;
+  std::vector<std::string> expected_manifest_hosts;
   expected_requested_urls.emplace_back(kConfigURL);
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     expected_requested_urls.emplace_back(std::string(kManifestURLPrefix) +
                                          top_host_url);
+    expected_manifest_hosts.push_back(top_host_url);
   }
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
     const std::string resource_url =
         base::StringPrintf("http://top-host-%zu.com/resource.html", i);
     PrecacheManifest manifest;
     manifest.add_resource()->set_url(resource_url);
 
     unfinished_work->add_top_host()->set_hostname(top_host_url);
@@ skipping 17 matching lines @@
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(0U, precache_fetcher.quota_.remaining());
     unfinished_work = precache_fetcher.CancelPrecaching();
   }
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
-
+  EXPECT_EQ(expected_manifest_hosts, precache_delegate_.get_manifest_hosts());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   EXPECT_EQ(0, unfinished_work->top_host_size());
   EXPECT_EQ(1, unfinished_work->resource_size());
 
   histogram.ExpectTotalCount("Precache.Fetch.PercentCompleted", 1);
   histogram.ExpectTotalCount("Precache.Fetch.ResponseBytes.Total", 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 
   // Continuing with the precache when quota limit is reached, will not fetch
   // any resources.
   expected_requested_urls.clear();
   url_callback_.clear_requested_urls();
+  precache_delegate_.clear_manifest_hosts();
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
         std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
 
     EXPECT_EQ(0U, precache_fetcher.quota_.remaining());
   }
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
-
+  EXPECT_TRUE(precache_delegate_.get_manifest_hosts().empty());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectTotalCount("Precache.Fetch.PercentCompleted", 2);
   histogram.ExpectTotalCount("Precache.Fetch.ResponseBytes.Total", 2);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 2);
 }
 
 }  // namespace precache