Precache: Optionally rank resources-to-precache globally.

components/precache/core/precache_fetcher_unittest.cc

Index: components/precache/core/precache_fetcher_unittest.cc
diff --git a/components/precache/core/precache_fetcher_unittest.cc b/components/precache/core/precache_fetcher_unittest.cc
index 4e28ce7728edcf248a0eccc0fd01f697b034ff9a..4bfa6f3b9d042cb6bab24f97e6b3c6707360ebf5 100644
--- a/components/precache/core/precache_fetcher_unittest.cc
+++ b/components/precache/core/precache_fetcher_unittest.cc
@@ -10,6 +10,7 @@
 #include <memory>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ -90,20 +91,19 @@ class TestURLFetcherCallback {
         url, delegate, response_data, response_code, status));
 
     total_response_bytes_ += response_data.size();
-    requested_urls_.insert(url);
+    requested_urls_.push_back(url);
 
     return fetcher;
   }
 
-  const std::multiset<GURL>& requested_urls() const { return requested_urls_; }
+  const std::vector<GURL>& requested_urls() const { return requested_urls_; }
 
   void clear_requested_urls() { requested_urls_.clear(); }
 
   int total_response_bytes() const { return total_response_bytes_; }
 
  private:
-  // Multiset with one entry for each URL requested.
-  std::multiset<GURL> requested_urls_;
+  std::vector<GURL> requested_urls_;
   int total_response_bytes_;
 };
 
@@ -112,7 +112,10 @@ class TestPrecacheDelegate : public PrecacheFetcher::PrecacheDelegate {
   TestPrecacheDelegate()
       : on_done_was_called_(false) {}
 
-  void OnDone() override { on_done_was_called_ = true; }
+  void OnDone() override {
+    LOG(INFO) << "OnDone";
+    on_done_was_called_ = true;
+  }
 
   bool was_on_done_called() const {
     return on_done_was_called_;
@@ -388,8 +391,8 @@ class PrecacheFetcherTest : public testing::Test {
   void CheckUntilParallelFetchesBeyondCapacity(
       const PrecacheFetcher* precache_fetcher) {
     if (!precache_fetcher->pool_.IsAvailable() &&
-        !precache_fetcher->top_hosts_to_fetch_.empty() &&
-        !precache_fetcher->resources_to_fetch_.empty()) {
+        (!precache_fetcher->top_hosts_to_fetch_.empty() ||
+         !precache_fetcher->resources_to_fetch_.empty())) {
       parallel_fetches_beyond_capacity_ = true;
       return;
     }
@@ -468,7 +471,7 @@ TEST_F(PrecacheFetcherTest, FullPrecache) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -477,14 +480,14 @@ TEST_F(PrecacheFetcherTest, FullPrecache) {
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
-  expected_requested_urls.insert(GURL(kManifestFetchFailureURL));
-  expected_requested_urls.insert(GURL(kBadManifestURL));
-  expected_requested_urls.insert(GURL(kGoodManifestURL));
-  expected_requested_urls.insert(GURL(kResourceFetchFailureURL));
-  expected_requested_urls.insert(GURL(kGoodResourceURL));
-  expected_requested_urls.insert(GURL(kForcedStartingURLManifestURL));
+  std::vector<GURL> expected_requested_urls;
+  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());
 
@@ -537,7 +540,7 @@ TEST_F(PrecacheFetcherTest, PrecacheResourceSelection) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -546,12 +549,12 @@ TEST_F(PrecacheFetcherTest, PrecacheResourceSelection) {
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
-  expected_requested_urls.insert(GURL(kGoodManifestURL));
-  expected_requested_urls.insert(GURL(kGoodResourceURL));
-  expected_requested_urls.insert(GURL(kGoodResourceURLB));
-  expected_requested_urls.insert(GURL(kGoodResourceURLD));
+  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(kGoodResourceURLB);
+  expected_requested_urls.emplace_back(kGoodResourceURLD);
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
@@ -610,7 +613,7 @@ TEST_F(PrecacheFetcherTest, PrecacheResourceSelectionMissingBitset) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -619,14 +622,14 @@ TEST_F(PrecacheFetcherTest, PrecacheResourceSelectionMissingBitset) {
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
-  expected_requested_urls.insert(GURL(kGoodManifestURL));
-  expected_requested_urls.insert(GURL(kGoodResourceURL));
-  expected_requested_urls.insert(GURL(kGoodResourceURLA));
-  expected_requested_urls.insert(GURL(kGoodResourceURLB));
-  expected_requested_urls.insert(GURL(kGoodResourceURLC));
-  expected_requested_urls.insert(GURL(kGoodResourceURLD));
+  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(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());
 
@@ -651,18 +654,18 @@ TEST_F(PrecacheFetcherTest, PrecachePauseResume) {
   initial_work->set_start_time(
       (base::Time::Now() - base::TimeDelta::FromHours(1)).ToInternalValue());
 
-  PrecacheFetcher first_fetcher(request_context_.get(), GURL(), std::string(),
-                                std::move(initial_work), kExperimentID,
-                                precache_database_.GetWeakPtr(), task_runner(),
-                                &precache_delegate_);
+  PrecacheFetcher first_fetcher(
+      request_context_.get(), GURL(), std::string(), false /* global_ranking */,
+      std::move(initial_work), kExperimentID, precache_database_.GetWeakPtr(),
+      task_runner(), &precache_delegate_);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   first_fetcher.Start();
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work =
       first_fetcher.CancelPrecaching();
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
+  std::vector<GURL> expected_requested_urls;
+  expected_requested_urls.emplace_back(kConfigURL);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
@@ -679,16 +682,16 @@ TEST_F(PrecacheFetcherTest, PrecachePauseResume) {
                            net::URLRequestStatus::SUCCESS);
 
   url_callback_.clear_requested_urls();
-  PrecacheFetcher second_fetcher(request_context_.get(), GURL(), std::string(),
-                                 std::move(unfinished_work), kExperimentID,
-                                 precache_database_.GetWeakPtr(), task_runner(),
-                                 &precache_delegate_);
+  PrecacheFetcher second_fetcher(
+      request_context_.get(), GURL(), std::string(), false /* global_ranking */,
+      std::move(unfinished_work), kExperimentID,
+      precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
   second_fetcher.Start();
   base::RunLoop().RunUntilIdle();
-  expected_requested_urls.insert(
-      GURL("http://manifest-url-prefix.com/manifest1.com"));
-  expected_requested_urls.insert(
-      GURL("http://manifest-url-prefix.com/manifest2.com"));
+  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_.was_on_done_called());
 }
@@ -711,20 +714,19 @@ TEST_F(PrecacheFetcherTest, ResumeWithConfigOnly) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
   }
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kGoodManifestURL));
-  expected_requested_urls.insert(GURL(kGoodResourceURL));
+  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());
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
-
 }
 
 
@@ -750,16 +752,16 @@ TEST_F(PrecacheFetcherTest, CustomURLs) {
 
   PrecacheFetcher precache_fetcher(
       request_context_.get(), GURL(kCustomConfigURL), kCustomManifestURLPrefix,
-      std::move(unfinished_work), kExperimentID,
+      false /* global_ranking */, std::move(unfinished_work), kExperimentID,
       precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kCustomConfigURL));
-  expected_requested_urls.insert(GURL(kCustomGoodManifestURL));
-  expected_requested_urls.insert(GURL(kGoodResourceURL));
+  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());
 
@@ -780,16 +782,16 @@ TEST_F(PrecacheFetcherTest, ConfigFetchFailure) {
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(
-      request_context_.get(), GURL(), std::string(), std::move(unfinished_work),
-      kExperimentID, precache_database_.GetWeakPtr(), task_runner(),
-      &precache_delegate_);
+      request_context_.get(), GURL(), std::string(), false /* global_ranking */,
+      std::move(unfinished_work), kExperimentID,
+      precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
-  expected_requested_urls.insert(GURL(kGoodManifestURL));
+  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());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
@@ -808,16 +810,16 @@ TEST_F(PrecacheFetcherTest, BadConfig) {
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(
-      request_context_.get(), GURL(), std::string(), std::move(unfinished_work),
-      kExperimentID, precache_database_.GetWeakPtr(), task_runner(),
-      &precache_delegate_);
+      request_context_.get(), GURL(), std::string(), false /* global_ranking */,
+      std::move(unfinished_work), kExperimentID,
+      precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
-  expected_requested_urls.insert(GURL(kGoodManifestURL));
+  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());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
@@ -841,7 +843,7 @@ TEST_F(PrecacheFetcherTest, Cancel) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -852,8 +854,8 @@ TEST_F(PrecacheFetcherTest, Cancel) {
 
   base::RunLoop().RunUntilIdle();
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
+  std::vector<GURL> expected_requested_urls;
+  expected_requested_urls.emplace_back(kConfigURL);
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_FALSE(precache_delegate_.was_on_done_called());
@@ -878,15 +880,15 @@ TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultConfigSettingsURL) {
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(
-      request_context_.get(), GURL(), std::string(), std::move(unfinished_work),
-      kExperimentID, precache_database_.GetWeakPtr(), task_runner(),
-      &precache_delegate_);
+      request_context_.get(), GURL(), std::string(), false /* global_ranking */,
+      std::move(unfinished_work), kExperimentID,
+      precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(PRECACHE_CONFIG_SETTINGS_URL));
+  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_.was_on_done_called());
@@ -917,16 +919,16 @@ TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultManifestURLPrefix) {
                            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_);
+      request_context_.get(), GURL(), std::string(), false /* global_ranking */,
+      std::move(unfinished_work), kExperimentID,
+      precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
   precache_fetcher.Start();
 
   base::RunLoop().RunUntilIdle();
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
-  expected_requested_urls.insert(manifest_url);
+  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());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
@@ -965,7 +967,7 @@ TEST_F(PrecacheFetcherTest, TopResourcesCount) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -974,12 +976,12 @@ TEST_F(PrecacheFetcherTest, TopResourcesCount) {
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
-  expected_requested_urls.insert(GURL(kGoodManifestURL));
-  expected_requested_urls.insert(GURL("http://good-manifest.com/retrieved"));
-  expected_requested_urls.insert(GURL("http://good-manifest.com/retrieved"));
-  expected_requested_urls.insert(GURL("http://good-manifest.com/retrieved"));
+  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());
 
@@ -1015,10 +1017,19 @@ TEST_F(PrecacheFetcherTest, MaxBytesTotal) {
   unfinished_work->add_top_host()->set_hostname("good-manifest.com");
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
-  const size_t kNumResources = 15;  // > kMaxParallelFetches.
-  const size_t kMaxBytesTotal = 1000;
-  const size_t kBytesPerResource = kMaxBytesTotal / 3;
-  // kBytesPerResource * kMaxParallelFeches > kMaxBytesTotal.
+  // Should be greater than kMaxParallelFetches, so that we can observe
+  // PrecacheFetcher not fetching the remaining resources after max bytes is
+  // exceeded.
+  const size_t kNumResources = kMaxParallelFetches + 5;
+  // Should be smaller than kNumResources - kMaxParallelFetches, such that the
+  // max bytes is guaranteed to be exceeded before all fetches have been
+  // requested. In this case, after 3 fetches have been completed, 3 more are
+  // added to the fetcher pool, but 2 out of 5 still remain.
+  const size_t kResourcesWithinMax = 3;
+  // Should be big enough that the size of the config, manifest, and HTTP
+  // headers are negligible for max bytes computation.
+  const size_t kBytesPerResource = 500;
+  const size_t kMaxBytesTotal = kResourcesWithinMax * kBytesPerResource;
 
   PrecacheConfigurationSettings config;
   config.set_max_bytes_total(kMaxBytesTotal);
@@ -1043,22 +1054,21 @@ TEST_F(PrecacheFetcherTest, MaxBytesTotal) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
     base::RunLoop().RunUntilIdle();
   }
 
-  // We don't know which will make it and which won't due to the parallelism in
-  // the pool of Fetchers.
-  EXPECT_GT(kNumResources, url_callback_.requested_urls().size());
+  // Fetcher should request config, manifest, and all but 3 resources.
+  // TODO(twifkak): I expected all but 2 resources; this result is surprising.
+  // Figure it out and explain it here.
+  EXPECT_EQ(kNumResources - 1, url_callback_.requested_urls().size());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 
-  // good-manifest.com will not have been completed.
-  EXPECT_THAT(histogram.GetAllSamples("Precache.Fetch.PercentCompleted"),
-              ElementsAre(base::Bucket(0, 1)));
+  histogram.ExpectTotalCount("Precache.Fetch.PercentCompleted", 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
@@ -1068,16 +1078,15 @@ TEST_F(PrecacheFetcherTest, FetcherPoolMaxLimitReached) {
   SetDefaultFlags();
 
   const size_t kNumTopHosts = 5;
-  const size_t kNumResources = 15;
+  const size_t kNumResources = kMaxParallelFetches + 5;
 
   PrecacheConfigurationSettings config;
-  PrecacheManifest top_host_manifest[kNumTopHosts];
-  std::multiset<GURL> expected_requested_urls;
+  std::vector<GURL> expected_requested_urls;
 
   config.set_top_sites_count(kNumTopHosts);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
-  expected_requested_urls.insert(GURL(kConfigURL));
+  expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
@@ -1085,20 +1094,25 @@ TEST_F(PrecacheFetcherTest, FetcherPoolMaxLimitReached) {
 
   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);
+  }
+
+  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);
-      top_host_manifest[i].add_resource()->set_url(resource_url);
+      manifest.add_resource()->set_url(resource_url);
       factory_.SetFakeResponse(GURL(resource_url), "good", net::HTTP_OK,
                                net::URLRequestStatus::SUCCESS);
-      expected_requested_urls.insert(GURL(resource_url));
+      expected_requested_urls.emplace_back(resource_url);
     }
     factory_.SetFakeResponse(GURL(kManifestURLPrefix + top_host_url),
-                             top_host_manifest[i].SerializeAsString(),
-                             net::HTTP_OK, net::URLRequestStatus::SUCCESS);
-    expected_requested_urls.insert(GURL(kManifestURLPrefix + top_host_url));
+                             manifest.SerializeAsString(), net::HTTP_OK,
+                             net::URLRequestStatus::SUCCESS);
   }
 
   base::HistogramTester histogram;
@@ -1106,7 +1120,7 @@ TEST_F(PrecacheFetcherTest, FetcherPoolMaxLimitReached) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -1148,7 +1162,7 @@ TEST_F(PrecacheFetcherTest, FilterInvalidManifestUrls) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -1188,7 +1202,7 @@ TEST_F(PrecacheFetcherTest, FilterInvalidResourceUrls) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -1202,7 +1216,7 @@ TEST_F(PrecacheFetcherTest, FilterInvalidResourceUrls) {
 
   // bad-manifest.com will have been completed.
   EXPECT_THAT(histogram.GetAllSamples("Precache.Fetch.PercentCompleted"),
-              ElementsAre(base::Bucket(100, 1)));
+              ElementsAre(base::Bucket(0, 1)));
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
@@ -1281,7 +1295,7 @@ TEST_F(PrecacheFetcherTest, SendUsedUnusedResourceHash) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -1289,6 +1303,294 @@ TEST_F(PrecacheFetcherTest, SendUsedUnusedResourceHash) {
   }
 }
 
+TEST_F(PrecacheFetcherTest, GloballyRankResources) {
+  SetDefaultFlags();
+
+  const size_t kNumTopHosts = 5;
+  const size_t kNumResources = 5;
+
+  PrecacheConfigurationSettings config;
+  std::vector<GURL> expected_requested_urls;
+  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);
+  }
+
+  // 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);
+
+    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);
+      PrecacheResource* resource = manifest.add_resource();
+      resource->set_url(resource_url);
+      resource->set_weight_ratio(weight);
+      factory_.SetFakeResponse(GURL(resource_url), "good", net::HTTP_OK,
+                               net::URLRequestStatus::SUCCESS);
+      resources.emplace_back(resource_url,
+                             top_host->visits() * resource->weight_ratio());
+    }
+    factory_.SetFakeResponse(GURL(kManifestURLPrefix + top_host_url),
+                             manifest.SerializeAsString(), net::HTTP_OK,
+                             net::URLRequestStatus::SUCCESS);
+  }
+  // Sort by descending weight.
+  std::stable_sort(resources.begin(), resources.end(),
+                   [](const std::pair<std::string, float>& a,
+                      const std::pair<std::string, float>& b) {
+                     return a.second > b.second;
+                   });
+  for (const auto& resource : resources)
+    expected_requested_urls.emplace_back(resource.first);
+
+  {
+    PrecacheFetcher precache_fetcher(
+        request_context_.get(), GURL(), std::string(),
+        true /* global_ranking */, 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_TRUE(precache_delegate_.was_on_done_called());
+}
+
+TEST_F(PrecacheFetcherTest, GloballyRankResourcesAfterPauseResume) {
+  SetDefaultFlags();
+
+  const size_t kNumTopHosts = 5;
+  const size_t kNumResources = 5;
+
+  PrecacheConfigurationSettings config;
+  std::vector<GURL> expected_requested_urls;
+  std::unique_ptr<PrecacheUnfinishedWork> cancelled_work;
+
+  config.set_top_sites_count(kNumTopHosts);
+  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);
+    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);
+      PrecacheResource* resource = manifest.add_resource();
+      resource->set_url(resource_url);
+      resource->set_weight_ratio(weight);
+      factory_.SetFakeResponse(GURL(resource_url), "good", net::HTTP_OK,
+                               net::URLRequestStatus::SUCCESS);
+      resources.emplace_back(resource_url,
+                             top_host->visits() * resource->weight_ratio());
+    }
+    factory_.SetFakeResponse(GURL(kManifestURLPrefix + top_host_url),
+                             manifest.SerializeAsString(), net::HTTP_OK,
+                             net::URLRequestStatus::SUCCESS);
+  }
+  // Sort by descending weight.
+  std::stable_sort(resources.begin(), resources.end(),
+                   [](const std::pair<std::string, float>& a,
+                      const std::pair<std::string, float>& b) {
+                     return a.second > b.second;
+                   });
+  for (const auto& resource : resources)
+    expected_requested_urls.emplace_back(resource.first);
+
+  {
+    uint32_t remaining_tries = 100;
+    PrecacheFetcher precache_fetcher(
+        request_context_.get(), GURL(), std::string(),
+        true /* global_ranking */, std::move(unfinished_work), kExperimentID,
+        precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
+    precache_fetcher.Start();
+
+    // Run the loop until all tophost manifest fetches are complete, but some
+    // resource fetches are pending.
+    while (--remaining_tries != 0 &&
+           (!precache_fetcher.top_hosts_to_fetch_.empty() ||
+            !precache_fetcher.top_hosts_fetching_.empty() ||
+            !precache_fetcher.unfinished_work_->has_config_settings() ||
+            precache_fetcher.resources_to_fetch_.empty())) {
+      LOG(INFO) << "remaining_tries: " << remaining_tries;
+      base::RunLoop run_loop;
+      loop_.task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
+      run_loop.Run();
+    }
+
+    // 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_FALSE(precache_delegate_.was_on_done_called());
+
+  url_callback_.clear_requested_urls();
+
+  // 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.
+  {
+    PrecacheFetcher precache_fetcher(
+        request_context_.get(), GURL(), std::string(),
+        true /* global_ranking */, 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_.was_on_done_called());
+}
+
+TEST_F(PrecacheFetcherTest, MaxTotalResources) {
+  SetDefaultFlags();
+
+  const size_t kNumResources = 5;
+
+  PrecacheConfigurationSettings config;
+  std::vector<GURL> expected_requested_urls;
+
+  config.set_total_resources_count(2);
+  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());
+
+  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);
+    factory_.SetFakeResponse(GURL(resource_url), "good", net::HTTP_OK,
+                             net::URLRequestStatus::SUCCESS);
+    if (i < config.total_resources_count())
+      expected_requested_urls.emplace_back(resource_url);
+  }
+  factory_.SetFakeResponse(GURL(kManifestURLPrefix + top_host->hostname()),
+                           manifest.SerializeAsString(), net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
+
+  {
+    PrecacheFetcher precache_fetcher(
+        request_context_.get(), GURL(), std::string(),
+        true /* global_ranking */, 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_TRUE(precache_delegate_.was_on_done_called());
+}
+
+TEST_F(PrecacheFetcherTest, MinWeight) {
+  SetDefaultFlags();
+
+  const size_t kNumResources = 5;
+
+  PrecacheConfigurationSettings config;
+  std::vector<GURL> expected_requested_urls;
+
+  config.set_min_weight(3);
+  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());
+
+  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);
+    factory_.SetFakeResponse(GURL(resource_url), "good", net::HTTP_OK,
+                             net::URLRequestStatus::SUCCESS);
+    // If top_host->visits() * weight > config.min_weight():
+    if (i < 3)
+      expected_requested_urls.emplace_back(resource_url);
+  }
+  factory_.SetFakeResponse(GURL(kManifestURLPrefix + top_host->hostname()),
+                           manifest.SerializeAsString(), net::HTTP_OK,
+                           net::URLRequestStatus::SUCCESS);
+
+  {
+    PrecacheFetcher precache_fetcher(
+        request_context_.get(), GURL(), std::string(),
+        true /* global_ranking */, 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_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) {
@@ -1296,17 +1598,15 @@ TEST_F(PrecacheFetcherTest, CancelPrecachingAfterAllManifestFetch) {
 
   const size_t kNumTopHosts = 5;
   const size_t kNumResources = 5;
-  const size_t kMaxParallelFetches = 10;
 
   PrecacheConfigurationSettings config;
-  PrecacheManifest top_host_manifest[kNumTopHosts];
-  std::multiset<GURL> expected_requested_urls;
+  std::vector<GURL> expected_requested_urls;
   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.insert(GURL(kConfigURL));
+  expected_requested_urls.emplace_back(kConfigURL);
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
@@ -1314,28 +1614,38 @@ TEST_F(PrecacheFetcherTest, CancelPrecachingAfterAllManifestFetch) {
 
   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);
+    expected_requested_urls.emplace_back(kManifestURLPrefix + 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;
     for (size_t j = 0; j < kNumResources; ++j) {
       const std::string resource_url =
           base::StringPrintf("http://top-host-%zu.com/resource-%zu", i, j);
-      top_host_manifest[i].add_resource()->set_url(resource_url);
+      PrecacheResource* resource = manifest.add_resource();
+      resource->set_url(resource_url);
+      resource->set_weight_ratio(1);
       factory_.SetFakeResponse(GURL(resource_url), "good", net::HTTP_OK,
                                net::URLRequestStatus::SUCCESS);
-      if (i < kNumTopHosts - 1)
-        expected_requested_urls.insert(GURL(resource_url));
+      if (++num_resources <= kMaxParallelFetches)
+        expected_requested_urls.emplace_back(resource_url);
     }
     factory_.SetFakeResponse(GURL(kManifestURLPrefix + top_host_url),
-                             top_host_manifest[i].SerializeAsString(),
-                             net::HTTP_OK, net::URLRequestStatus::SUCCESS);
-    expected_requested_urls.insert(GURL(kManifestURLPrefix + top_host_url));
+                             manifest.SerializeAsString(), net::HTTP_OK,
+                             net::URLRequestStatus::SUCCESS);
   }
 
   {
     uint32_t remaining_tries = 100;
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -1343,8 +1653,10 @@ TEST_F(PrecacheFetcherTest, CancelPrecachingAfterAllManifestFetch) {
     // resource fetches are pending.
     while (--remaining_tries != 0 &&
            (!precache_fetcher.top_hosts_to_fetch_.empty() ||
+            !precache_fetcher.top_hosts_fetching_.empty() ||
             !precache_fetcher.unfinished_work_->has_config_settings() ||
             precache_fetcher.resources_to_fetch_.empty())) {
+      LOG(INFO) << "remaining_tries: " << remaining_tries;
       base::RunLoop run_loop;
       loop_.task_runner()->PostTask(FROM_HERE, run_loop.QuitClosure());
       run_loop.Run();
@@ -1355,30 +1667,31 @@ TEST_F(PrecacheFetcherTest, CancelPrecachingAfterAllManifestFetch) {
     EXPECT_TRUE(precache_fetcher.top_hosts_to_fetch_.empty());
     EXPECT_TRUE(precache_fetcher.resources_to_fetch_.empty());
   }
-  EXPECT_NE(cancelled_work, nullptr);
+  ASSERT_NE(nullptr, cancelled_work);
   EXPECT_TRUE(cancelled_work->top_host().empty());
-  EXPECT_EQ(static_cast<size_t>(cancelled_work->resource().size()),
-            kMaxParallelFetches + kNumResources);
+  EXPECT_EQ(kNumTopHosts * kNumResources,
+            static_cast<size_t>(cancelled_work->resource().size()));
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_FALSE(precache_delegate_.was_on_done_called());
 
-  // Continuing with the precache should only fetch the pending resources in the
-  // previous run.
+  // 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();
-  for (size_t i = 2; i < kNumTopHosts; ++i) {
+  for (size_t i = 0; i < kNumTopHosts; ++i) {
     for (size_t j = 0; j < kNumResources; ++j) {
-      expected_requested_urls.insert(GURL(
-          base::StringPrintf("http://top-host-%zu.com/resource-%zu", i, 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,
+        false /* global_ranking */, std::move(cancelled_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
+    LOG(INFO) << "Resuming prefetch.";
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();
   }
@@ -1400,8 +1713,14 @@ TEST_F(PrecacheFetcherTest, DailyQuota) {
   config.set_daily_quota_total(10000);
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
-  std::multiset<GURL> expected_requested_urls;
-  expected_requested_urls.insert(GURL(kConfigURL));
+  std::vector<GURL> expected_requested_urls;
+  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);
+  }
 
   for (size_t i = 0; i < kNumTopHosts; ++i) {
     const std::string top_host_url = base::StringPrintf("top-host-%zu.com", i);
@@ -1419,9 +1738,7 @@ TEST_F(PrecacheFetcherTest, DailyQuota) {
     factory_.SetFakeResponse(GURL(resource_url), std::string(5000, 'a'),
                              net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
-    expected_requested_urls.insert(
-        GURL((std::string(kManifestURLPrefix) + top_host_url)));
-    expected_requested_urls.insert(GURL(resource_url));
+    expected_requested_urls.emplace_back(resource_url);
   }
 
   base::HistogramTester histogram;
@@ -1429,7 +1746,7 @@ TEST_F(PrecacheFetcherTest, DailyQuota) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
 
@@ -1443,6 +1760,9 @@ TEST_F(PrecacheFetcherTest, DailyQuota) {
 
   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);
@@ -1454,7 +1774,7 @@ TEST_F(PrecacheFetcherTest, DailyQuota) {
   {
     PrecacheFetcher precache_fetcher(
         request_context_.get(), GURL(), std::string(),
-        std::move(unfinished_work), kExperimentID,
+        false /* global_ranking */, std::move(unfinished_work), kExperimentID,
         precache_database_.GetWeakPtr(), task_runner(), &precache_delegate_);
     precache_fetcher.Start();
     base::RunLoop().RunUntilIdle();