Precache: Optionally rank resources-to-precache globally.

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>
 #include <set>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ skipping 60 matching lines @@
   std::unique_ptr<net::FakeURLFetcher> CreateURLFetcher(
       const GURL& url,
       net::URLFetcherDelegate* delegate,
       const std::string& response_data,
       net::HttpStatusCode response_code,
       net::URLRequestStatus::Status status) {
     std::unique_ptr<net::FakeURLFetcher> fetcher(new net::FakeURLFetcher(
         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_;
 };
 
 class TestPrecacheDelegate : public PrecacheFetcher::PrecacheDelegate {
  public:
   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_;
   }
 
  private:
   bool on_done_was_called_;
 };
 
 class MockURLFetcherFactory : public net::URLFetcherFactory {
@@ skipping 255 matching lines @@
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         switches::kPrecacheManifestURLPrefix, kManifestURLPrefix);
   }
 
   // Posts a task to check if more parallel fetches of precache manifest and
   // resource URLs were attempted beyond the fetcher pool maximum defined
   // capacity. The task will be posted repeatedly until such condition is met.
   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;
     }
 
     // Check again after allowing the message loop to process some messages.
     loop_.task_runner()->PostTask(
         FROM_HERE,
         base::Bind(
             &PrecacheFetcherTest::CheckUntilParallelFetchesBeyondCapacity,
             base::Unretained(this), precache_fetcher));
@@ skipping 58 matching lines @@
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kForcedStartingURLManifestURL),
                            PrecacheManifest().SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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();
 
     // 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());
 
   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);
 }
@@ skipping 32 matching lines @@
   factory_.SetFakeResponse(GURL(kGoodResourceURLB), "good URL B", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURLD), "good URL D", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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();
 
     // 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());
 
   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);
 }
@@ skipping 38 matching lines @@
   factory_.SetFakeResponse(GURL(kGoodResourceURLC), "good URL C", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURLD), "good URL D", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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();
 
     // 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());
 
   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, PrecachePauseResume) {
   SetDefaultFlags();
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(3);
 
   std::unique_ptr<PrecacheUnfinishedWork> initial_work(
       new PrecacheUnfinishedWork());
   initial_work->add_top_host()->set_hostname("manifest1.com");
   initial_work->add_top_host()->set_hostname("manifest2.com");
   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(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kBadManifestURL), "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL("http://manifest-url-prefix.com/manifest1.com"),
                            "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL("http://manifest-url-prefix.com/manifest2.com"),
                            "bad protobuf", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            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());
 }
 
 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());
   PrecacheManifest good_manifest;
   good_manifest.add_resource()->set_url(kGoodResourceURL);
 
   factory_.SetFakeResponse(GURL(kGoodManifestURL),
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   {
     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());
-
 }
 
 
 TEST_F(PrecacheFetcherTest, CustomURLs) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("good-manifest.com");
 
   PrecacheConfigurationSettings config;
 
   PrecacheManifest good_manifest;
   good_manifest.add_resource()->set_url(kGoodResourceURL);
 
   factory_.SetFakeResponse(GURL(kCustomConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kCustomGoodManifestURL),
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   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());
 
   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_);
+      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());
 }
 
 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_);
+      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());
 }
 
 TEST_F(PrecacheFetcherTest, Cancel) {
   SetDefaultFlags();
 
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("starting-url.com");
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(1);
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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();
 
     // Destroy the PrecacheFetcher, to cancel precaching. No metrics
     // should be recorded because this should not cause OnDone to be
     // called on the precache delegate.
   }
 
   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());
 
   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) {
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   unfinished_work->add_top_host()->set_hostname("starting-url.com");
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(0);
 
   factory_.SetFakeResponse(GURL(PRECACHE_CONFIG_SETTINGS_URL),
                            config.SerializeAsString(), 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(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());
 }
 
 #endif  // PRECACHE_CONFIG_SETTINGS_URL
 
 #if defined(PRECACHE_MANIFEST_URL_PREFIX)
 
 // If the default precache manifest URL prefix is defined, then test that it
@@ skipping 10 matching lines @@
   config.set_top_sites_count(1);
 
   GURL manifest_url(PRECACHE_MANIFEST_URL_PREFIX "starting-url.com");
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(manifest_url, PrecacheManifest().SerializeAsString(),
                            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());
 }
 
 #endif  // PRECACHE_MANIFEST_URL_PREFIX
 
 TEST_F(PrecacheFetcherTest, TopResourcesCount) {
   SetDefaultFlags();
 
@@ skipping 18 matching lines @@
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL("http://good-manifest.com/retrieved"), "good",
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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();
 
     // 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());
 
   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);
 }
@@ skipping 15 matching lines @@
 // MockURLFetcherFactory or EmbeddedTestServer, and add a test that fetches are
 // cancelled midstream.
 
 TEST_F(PrecacheFetcherTest, MaxBytesTotal) {
   SetDefaultFlags();
   std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
       new PrecacheUnfinishedWork());
   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 kNumResources = kMaxParallelFetches + 5;

[bengr, 2016/10/14 21:52:19]

Please add comments to explain the magic of "5" here and "7" below.

[twifkak, 2016/10/14 22:41:45]

OK, did my best. I don't fully understand this test, either (e.g. my new TODO
below).

   const size_t kMaxBytesTotal = 1000;
-  const size_t kBytesPerResource = kMaxBytesTotal / 3;
-  // kBytesPerResource * kMaxParallelFeches > kMaxBytesTotal.
+  const size_t kResourcesWithinMax = kMaxParallelFetches - 7;
+  const size_t kBytesPerResource = kMaxBytesTotal / kResourcesWithinMax;
 
   PrecacheConfigurationSettings config;
   config.set_max_bytes_total(kMaxBytesTotal);
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   PrecacheManifest good_manifest;
   for (size_t i = 0; i < kNumResources; ++i) {
     const std::string url = "http://good-manifest.com/" + std::to_string(i);
     good_manifest.add_resource()->set_url(url);
     factory_.SetFakeResponse(GURL(url), std::string(kBytesPerResource, '.'),
                              net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   }
 
   factory_.SetFakeResponse(GURL(kGoodManifestURL),
                            good_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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());
 
   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);
 }
 
 // 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 = 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());
   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);
+  }
+
+  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;
 
   {
     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();
 
     EXPECT_GT(kNumResources, precache_fetcher.pool_.max_size());
     CheckUntilParallelFetchesBeyondCapacity(&precache_fetcher);
 
     base::RunLoop().RunUntilIdle();
 
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
@@ skipping 21 matching lines @@
   unfinished_work->set_start_time(base::Time::UnixEpoch().ToInternalValue());
 
   factory_.SetFakeResponse(GURL(kConfigURL), "", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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();
   }
 
   // The config is fetched, but not the invalid manifest URL.
   EXPECT_EQ(1UL, url_callback_.requested_urls().size());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
@@ skipping 19 matching lines @@
 
   factory_.SetFakeResponse(GURL(kBadManifestURL),
                            bad_manifest.SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
     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();
   }
 
   // The config and manifest are fetched, but not the invalid resource URL.
   EXPECT_EQ(2UL, url_callback_.requested_urls().size());
 
   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(100, 1)));
+              ElementsAre(base::Bucket(0, 1)));
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 TEST(PrecacheFetcherStandaloneTest, GetResourceURLBase64Hash) {
   // Expected base64 hash for some selected URLs.
   EXPECT_EQ("dVSI/sC1cGk=", PrecacheFetcher::GetResourceURLBase64HashForTesting(
                                 {GURL("http://used-resource-1/a.js")}));
   EXPECT_EQ("B/Jc6JvusZQ=", PrecacheFetcher::GetResourceURLBase64HashForTesting(
                                 {GURL("http://used-resource-1/b.js")}));
   EXPECT_EQ("CmvACGJ4k08=", PrecacheFetcher::GetResourceURLBase64HashForTesting(
@@ skipping 58 matching lines @@
                true)),
       std::string(), net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(
       GURL(std::string(kManifestURLPrefix) +
            "top-host-3.com?manifest=1003&used_resources=&unused_resources="),
       std::string(), net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   {
     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();
   }
 }
 
+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) {
   SetDefaultFlags();
 
   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());
   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);
-    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();
 
     // 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);
+  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();
   }
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
   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::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);
     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);
     factory_.SetFakeResponse(
         GURL(std::string(kManifestURLPrefix) + top_host_url),
         manifest.SerializeAsString(), net::HTTP_OK,
         net::URLRequestStatus::SUCCESS);
     // Set a 5000 byte resource.
     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;
 
   {
     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();
 
     EXPECT_EQ(0U, precache_fetcher.quota_.remaining());
     unfinished_work = precache_fetcher.CancelPrecaching();
   }
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   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();
   {
     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();
 
     EXPECT_EQ(0U, precache_fetcher.quota_.remaining());
   }
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   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