Add pause/resume functionality to precache

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 72cb27027c83590d8efbf00dc5c6c4709d445cc9..33794721253509d94fe8a15f353f89842fbc9d98 100644
--- a/components/precache/core/precache_fetcher_unittest.cc
+++ b/components/precache/core/precache_fetcher_unittest.cc
@@ -24,6 +24,7 @@
 #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"
@@ -94,16 +95,17 @@ class TestURLFetcherCallback {
 
 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 {
@@ -327,7 +329,8 @@ class PrecacheFetcherTest : public testing::Test {
         factory_(NULL,
                  base::Bind(&TestURLFetcherCallback::CreateURLFetcher,
                             base::Unretained(&url_callback_))),
-        expected_total_response_bytes_(0) {}
+        expected_total_response_bytes_(0),
+        empty_unfinished_work_(new PrecacheUnfinishedWork()) {}
 
  protected:
   void SetDefaultFlags() {
@@ -343,6 +346,7 @@ class PrecacheFetcherTest : public testing::Test {
   net::FakeURLFetcherFactory factory_;
   TestPrecacheDelegate precache_delegate_;
   int expected_total_response_bytes_;
+  std::unique_ptr<PrecacheUnfinishedWork> empty_unfinished_work_;
 };
 
 TEST_F(PrecacheFetcherTest, FullPrecache) {
@@ -389,6 +393,7 @@ TEST_F(PrecacheFetcherTest, FullPrecache) {
   {
     PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
                                      GURL(), std::string(),
+                                     empty_unfinished_work_.get(),
                                      &precache_delegate_);
     precache_fetcher.Start();
 
@@ -416,6 +421,104 @@ TEST_F(PrecacheFetcherTest, FullPrecache) {
   histogram.ExpectTotalCount("Precache.Fetch.TimeToComplete", 1);
 }
 
+TEST_F(PrecacheFetcherTest, PrecachePauseResume) {
+  SetDefaultFlags();
+
+  PrecacheConfigurationSettings config;
+  config.set_top_sites_count(3);
+  std::vector<std::string> starting_hosts;
+
+  PrecacheFetcher first_fetcher(starting_hosts, request_context_.get(),
+                                GURL(), std::string(),
+                                empty_unfinished_work_.get(),
+                                &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.GetUnfinishedWork();
+
+  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.
+  starting_hosts.push_back("bad-manifest.com");
+
+  PrecacheFetcher second_fetcher(starting_hosts, request_context_.get(),
+                                 GURL(), std::string(),
+                                 unfinished_work.get(),
+                                 &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(std::vector<std::string>(),
+                                     request_context_.get(),
+                                     GURL(), std::string(),
+                                     unfinished_work.get(),
+                                     &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();
 
@@ -437,7 +540,8 @@ TEST_F(PrecacheFetcherTest, CustomURLs) {
 
   PrecacheFetcher precache_fetcher(
       starting_hosts, request_context_.get(), GURL(kCustomConfigURL),
-      kCustomManifestURLPrefix, &precache_delegate_);
+      kCustomManifestURLPrefix, empty_unfinished_work_.get(),
+      &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
@@ -464,7 +568,9 @@ TEST_F(PrecacheFetcherTest, ConfigFetchFailure) {
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+                                   GURL(), std::string(),
+                                   empty_unfinished_work_.get(),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
@@ -488,7 +594,9 @@ TEST_F(PrecacheFetcherTest, BadConfig) {
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+                                   GURL(), std::string(),
+                                   empty_unfinished_work_.get(),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
@@ -517,6 +625,7 @@ TEST_F(PrecacheFetcherTest, Cancel) {
   {
     PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
                                      GURL(), std::string(),
+                                     empty_unfinished_work_.get(),
                                      &precache_delegate_);
     precache_fetcher.Start();
 
@@ -552,7 +661,9 @@ TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultConfigSettingsURL) {
                            net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+                                   GURL(), std::string(),
+                                   empty_unfinished_work_.get(),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
@@ -587,7 +698,9 @@ TEST_F(PrecacheFetcherTest, PrecacheUsingDefaultManifestURLPrefix) {
                            net::HTTP_OK, net::URLRequestStatus::SUCCESS);
 
   PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
-                                   GURL(), std::string(), &precache_delegate_);
+                                   GURL(), std::string(),
+                                   empty_unfinished_work_.get(),
+                                   &precache_delegate_);
   precache_fetcher.Start();
 
   loop_.RunUntilIdle();
@@ -631,6 +744,7 @@ TEST_F(PrecacheFetcherTest, TopResourcesCount) {
   {
     PrecacheFetcher precache_fetcher(starting_hosts, request_context_.get(),
                                      GURL(), std::string(),
+                                     empty_unfinished_work_.get(),
                                      &precache_delegate_);
     precache_fetcher.Start();
 
@@ -703,7 +817,9 @@ TEST_F(PrecacheFetcherTest, MaxBytesTotal) {
   {
     PrecacheFetcher precache_fetcher({"good-manifest.com"},
                                      request_context_.get(), GURL(),
-                                     std::string(), &precache_delegate_);
+                                     std::string(),
+                                     empty_unfinished_work_.get(),
+                                     &precache_delegate_);
     precache_fetcher.Start();
 
     loop_.RunUntilIdle();