Add pause/resume functionality to precache

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 <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/test/histogram_tester.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "components/precache/core/precache_switches.h"
 #include "components/precache/core/proto/precache.pb.h"
+#include "components/precache/core/proto/unfinished_work.pb.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_status.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
@@ skipping 50 matching lines @@
   int total_response_bytes() const { return total_response_bytes_; }
 
  private:
   // Multiset with one entry for each URL requested.
   std::multiset<GURL> requested_urls_;
   int total_response_bytes_;
 };
 
 class TestPrecacheDelegate : public PrecacheFetcher::PrecacheDelegate {
  public:
-  TestPrecacheDelegate() : was_on_done_called_(false) {}
+  TestPrecacheDelegate()
+      : on_done_was_called_(false) {}
 
-  void OnDone() override { was_on_done_called_ = true; }
+  void OnDone() override { on_done_was_called_ = true; }
 
   bool was_on_done_called() const {
-    return was_on_done_called_;
+    return on_done_was_called_;
   }
 
  private:
-  bool was_on_done_called_;
+  bool on_done_was_called_;
 };
 
 class MockURLFetcherFactory : public net::URLFetcherFactory {
  public:
   typedef net::URLFetcher* DoURLFetcher(
       int id,
       const GURL& url,
       net::URLFetcher::RequestType request_type,
       net::URLFetcherDelegate* delegate);
 
@@ skipping 224 matching lines @@
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   TestURLFetcherCallback url_callback_;
   net::FakeURLFetcherFactory factory_;
   TestPrecacheDelegate precache_delegate_;
   int expected_total_response_bytes_;
 };
 
 TEST_F(PrecacheFetcherTest, FullPrecache) {
   SetDefaultFlags();
 
-  std::vector<std::string> starting_hosts;
-  starting_hosts.push_back("manifest-fetch-failure.com");
-  starting_hosts.push_back("bad-manifest.com");
-  starting_hosts.push_back("good-manifest.com");
-  starting_hosts.push_back("not-in-top-3.com");
+  std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
+      new PrecacheUnfinishedWork());
+  unfinished_work->add_top_host()->set_hostname("manifest-fetch-failure.com");
+  unfinished_work->add_top_host()->set_hostname("bad-manifest.com");
+  unfinished_work->add_top_host()->set_hostname("good-manifest.com");
+  unfinished_work->add_top_host()->set_hostname("not-in-top-3.com");
 
   PrecacheConfigurationSettings config;
   config.set_top_sites_count(3);
   config.add_forced_site("forced-starting-url.com");
   // Duplicate starting URL, the manifest for this should only be fetched once.
   config.add_forced_site("good-manifest.com");
 
   PrecacheManifest good_manifest;
   good_manifest.add_resource()->set_url(kResourceFetchFailureURL);
   good_manifest.add_resource();  // Resource with no URL, should not be fetched.
@@ skipping 14 matching lines @@
                            net::URLRequestStatus::FAILED);
   factory_.SetFakeResponse(GURL(kGoodResourceURL), "good", net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kForcedStartingURLManifestURL),
                            PrecacheManifest().SerializeAsString(), net::HTTP_OK,
                            net::URLRequestStatus::SUCCESS);
 
   base::HistogramTester histogram;
 
   {
-    PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
+    PrecacheFetcher precache_fetcher(request_context_.get(),
                                      GURL(), std::string(),
+                                     std::move(unfinished_work),
                                      &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.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));
 
   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> empty_unfinished_work(
+      new PrecacheUnfinishedWork);
+
+  PrecacheFetcher first_fetcher(request_context_.get(),
+                                GURL(), std::string(),
+                                std::move(empty_unfinished_work),
+                                &precache_delegate_);
+  base::Time then = base::Time::Now() - base::TimeDelta::FromHours(1);
+  std::list<GURL> manifests, resources;
+  manifests.push_back(GURL("http://manifest-url-prefix.com/manifest1.com"));
+  manifests.push_back(GURL("http://manifest-url-prefix.com/manifest2.com"));
+  resources.push_back(GURL(kGoodResourceURL));
+  first_fetcher.AssignWorkForTest(
+      manifests, resources, 271828, 314159, 5, then);
+  loop_.RunUntilIdle();
+  std::unique_ptr<PrecacheUnfinishedWork> unfinished_work =
+      first_fetcher.CancelPrecaching();
+
+  std::multiset<GURL> expected_requested_urls;
+  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);
+  // Starting hosts should not be fetched.
+  unfinished_work->add_top_host()->set_hostname("bad-manifest.com");
+  PrecacheFetcher second_fetcher(request_context_.get(),
+                                 GURL(), std::string(),
+                                 std::move(unfinished_work),
+                                 &precache_delegate_);
+  second_fetcher.Start();
+  loop_.RunUntilIdle();
+  expected_requested_urls.insert(GURL(kConfigURL));
+  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.insert(GURL(kGoodResourceURL));
+  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),
+                                     &precache_delegate_);
+    precache_fetcher.Start();
+
+    loop_.RunUntilIdle();
+
+    // Destroy the PrecacheFetcher after it has finished, to record metrics.
+  }
+
+  std::multiset<GURL> expected_requested_urls;
+  expected_requested_urls.insert(GURL(kGoodManifestURL));
+  expected_requested_urls.insert(GURL(kGoodResourceURL));
+
+  EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
+  EXPECT_TRUE(precache_delegate_.was_on_done_called());
+
+}
+
+
 TEST_F(PrecacheFetcherTest, CustomURLs) {
   SetDefaultFlags();
 
-  std::vector<std::string> starting_hosts;
-  starting_hosts.push_back("good-manifest.com");
+  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(
-      starting_hosts, request_context_.get(), GURL(kCustomConfigURL),
-      kCustomManifestURLPrefix, &precache_delegate_);
+      request_context_.get(), GURL(kCustomConfigURL),
+      kCustomManifestURLPrefix, std::move(unfinished_work),
+      &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.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));
 
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, ConfigFetchFailure) {
   SetDefaultFlags();
 
-  std::vector<std::string> starting_hosts(1, "good-manifest.com");
+  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(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(),
+                                   GURL(), std::string(),
+                                   std::move(unfinished_work),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, BadConfig) {
   SetDefaultFlags();
 
-  std::vector<std::string> starting_hosts(1, "good-manifest.com");
+  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(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(),
+                                   GURL(), std::string(),
+                                   std::move(unfinished_work),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(GURL(kGoodManifestURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_TRUE(precache_delegate_.was_on_done_called());
 }
 
 TEST_F(PrecacheFetcherTest, Cancel) {
   SetDefaultFlags();
 
-  std::vector<std::string> starting_hosts(1, "starting-url.com");
+  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(starting_hosts, request_context_.get(),
+    PrecacheFetcher precache_fetcher(request_context_.get(),
                                      GURL(), std::string(),
+                                     std::move(unfinished_work),
                                      &precache_delegate_);
     precache_fetcher.Start();
 
     // Destroy the PrecacheFetcher, to cancel precaching and record metrics.
     // This should not cause OnDone to be called on the precache delegate.
   }
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   EXPECT_EQ(expected_requested_urls, url_callback_.requested_urls());
 
   EXPECT_FALSE(precache_delegate_.was_on_done_called());
 
   histogram.ExpectUniqueSample("Precache.Fetch.PercentCompleted", 0, 1);
   histogram.ExpectUniqueSample("Precache.Fetch.ResponseBytes.Total", 0, 1);
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
 #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::vector<std::string> starting_hosts(1, "starting-url.com");
+  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(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(),
+                                   GURL(), std::string(),
+                                   std::move(unfinished_work),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(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
 // works with the PrecacheFetcher.
 TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultManifestURLPrefix) {
   base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
       switches::kPrecacheConfigSettingsURL, kConfigURL);
 
-  std::vector<std::string> starting_hosts(1, "starting-url.com");
+  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);
 
   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(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+  PrecacheFetcher precache_fetcher(request_context_.get(),
+                                   GURL(), std::string(),
+                                   std::move(unfinished_work),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
   expected_requested_urls.insert(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();
 
-  std::vector<std::string> starting_hosts;
-  starting_hosts.push_back("good-manifest.com");
+  std::unique_ptr<PrecacheUnfinishedWork> unfinished_work(
+      new PrecacheUnfinishedWork());
+  unfinished_work->add_top_host()->set_hostname("good-manifest.com");
 
   PrecacheConfigurationSettings config;
   config.set_top_resources_count(3);
 
   PrecacheManifest good_manifest;
   good_manifest.add_resource()->set_url("http://good-manifest.com/retrieved");
   good_manifest.add_resource()->set_url("http://good-manifest.com/retrieved");
   good_manifest.add_resource()->set_url("http://good-manifest.com/retrieved");
   good_manifest.add_resource()->set_url("http://good-manifest.com/skipped");
   good_manifest.add_resource()->set_url("http://good-manifest.com/skipped");
 
   factory_.SetFakeResponse(GURL(kConfigURL), config.SerializeAsString(),
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
   factory_.SetFakeResponse(GURL(kGoodManifestURL),
                            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(starting_hosts, request_context_.get(),
+    PrecacheFetcher precache_fetcher(request_context_.get(),
                                      GURL(), std::string(),
+                                     std::move(unfinished_work),
                                      &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.RunUntilIdle();
 
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
   std::multiset<GURL> expected_requested_urls;
   expected_requested_urls.insert(GURL(kConfigURL));
@@ skipping 24 matching lines @@
 // PrecacheFetcherFetcherTest.ResourceTooBig tests the bulk of the code. We'll
 // assume that PrecacheFetcher passes the right max_bytes to the
 // PrecacheFetcher::Fetcher constructor.
 //
 // TODO(twifkak): Port these tests from FakeURLFetcherFactory to
 // 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");
+
   const size_t kNumResources = 15;  // > kMaxParallelFetches.
   const size_t kMaxBytesTotal = 1000;
   const size_t kBytesPerResource = kMaxBytesTotal / 3;
   // kBytesPerResource * kMaxParallelFeches > kMaxBytesTotal.
 
   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({"good-manifest.com"},
-                                     request_context_.get(), GURL(),
-                                     std::string(), &precache_delegate_);
+    PrecacheFetcher precache_fetcher(request_context_.get(), GURL(),
+                                     std::string(),
+                                     std::move(unfinished_work),
+                                     &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.RunUntilIdle();
 
     // Destroy the PrecacheFetcher after it has finished, to record metrics.
   }
 
   // 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.TimeToComplete", 1);
 }
 
 }  // namespace
 
 }  // namespace precache