Add revalidation_only option to precache config.

components/precache/core/precache_fetcher_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/precache/core/precache_fetcher.h"
 
 #include <stdint.h>
 
 #include <cstring>
 #include <memory>
@@ skipping 221 matching lines @@
 
   net::FakeURLFetcher* fetcher = nullptr;
   EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
       .WillOnce(factory_.RespondWith("", &fetcher));
   EXPECT_CALL(*this,
               Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
                                 NotNull())));
 
   PrecacheFetcher::Fetcher precache_fetcher(
       request_context_.get(), url, url.host(), callback_,
-      false /* is_resource_request */, SIZE_MAX);
+      false /* is_resource_request */, SIZE_MAX, false /* revalidation_only */);
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_NE(nullptr, fetcher);
   EXPECT_EQ(kNoTracking, fetcher->GetLoadFlags());
 }
 
 TEST_F(PrecacheFetcherFetcherTest, ResourceNotInCache) {
   GURL url(kGoodResourceURL);
 
   net::FakeURLFetcher *fetcher1 = nullptr, *fetcher2 = nullptr;
   EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
       .WillOnce(factory_.RespondWith("", CacheMiss, &fetcher1))
       .WillOnce(factory_.RespondWith("", &fetcher2));
   EXPECT_CALL(*this,
               Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
-                                NotNull())))
-      .Times(1);
+                                NotNull())));
 
   PrecacheFetcher::Fetcher precache_fetcher(
       request_context_.get(), url, url.host(), callback_,
-      true /* is_resource_request */, SIZE_MAX);
+      true /* is_resource_request */, SIZE_MAX, false /* revalidation_only */);
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_NE(nullptr, fetcher1);
   EXPECT_EQ(
       net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION | kNoTracking,
       fetcher1->GetLoadFlags());
   ASSERT_NE(nullptr, fetcher2);
   EXPECT_EQ(net::LOAD_VALIDATE_CACHE | kNoTracking, fetcher2->GetLoadFlags());
 }
 
 TEST_F(PrecacheFetcherFetcherTest, ResourceHasValidators) {
   GURL url(kGoodResourceURL);
 
   net::FakeURLFetcher *fetcher1 = nullptr, *fetcher2 = nullptr;
   EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
       .WillOnce(factory_.RespondWith("", HasETag, &fetcher1))
       .WillOnce(factory_.RespondWith("", &fetcher2));
   EXPECT_CALL(*this,
               Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
                                 NotNull())));
 
   PrecacheFetcher::Fetcher precache_fetcher(
       request_context_.get(), url, url.host(), callback_,
-      true /* is_resource_request */, SIZE_MAX);
+      true /* is_resource_request */, SIZE_MAX, false /* revalidation_only */);
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_NE(nullptr, fetcher1);
   EXPECT_EQ(
       net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION | kNoTracking,
       fetcher1->GetLoadFlags());
   ASSERT_NE(nullptr, fetcher2);
   EXPECT_EQ(net::LOAD_VALIDATE_CACHE | kNoTracking, fetcher2->GetLoadFlags());
 }
 
 TEST_F(PrecacheFetcherFetcherTest, ResourceHasNoValidators) {
   GURL url(kGoodResourceURL);
 
-  net::FakeURLFetcher* fetcher;
+  net::FakeURLFetcher* fetcher = nullptr;
   EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
       .WillOnce(factory_.RespondWith("", &fetcher));
   EXPECT_CALL(*this,
+              Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
+                                nullptr)));  // It never reached the network.
+
+  PrecacheFetcher::Fetcher precache_fetcher(
+      request_context_.get(), url, url.host(), callback_,
+      true /* is_resource_request */, SIZE_MAX, false /* revalidation_only */);
+
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_EQ(
+      net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION | kNoTracking,
+      fetcher->GetLoadFlags());
+}
+
+TEST_F(PrecacheFetcherFetcherTest, RevalidationOnlyResourceNotInCache) {
+  GURL url(kGoodResourceURL);
+
+  net::FakeURLFetcher* fetcher = nullptr;
+  EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
+      .WillOnce(factory_.RespondWith("", CacheMiss, &fetcher));
+  EXPECT_CALL(*this,
+              Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
+                                nullptr)));  // It never reached the network.
+
+  PrecacheFetcher::Fetcher precache_fetcher(
+      request_context_.get(), url, url.host(), callback_,
+      true /* is_resource_request */, SIZE_MAX, true /* revalidation_only */);
+
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_NE(nullptr, fetcher);
+  EXPECT_EQ(
+      net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION | kNoTracking,
+      fetcher->GetLoadFlags());
+}
+
+TEST_F(PrecacheFetcherFetcherTest, RevalidationOnlyResourceHasValidators) {
+  GURL url(kGoodResourceURL);
+
+  net::FakeURLFetcher *fetcher1 = nullptr, *fetcher2 = nullptr;
+  EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
+      .WillOnce(factory_.RespondWith("", HasETag, &fetcher1))
+      .WillOnce(factory_.RespondWith("", &fetcher2));
+  EXPECT_CALL(*this,
+              Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
+                                NotNull())));
+
+  PrecacheFetcher::Fetcher precache_fetcher(
+      request_context_.get(), url, url.host(), callback_,
+      true /* is_resource_request */, SIZE_MAX, true /* revalidation_only */);
+
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_NE(nullptr, fetcher1);
+  EXPECT_EQ(
+      net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION | kNoTracking,
+      fetcher1->GetLoadFlags());
+  ASSERT_NE(nullptr, fetcher2);
+  EXPECT_EQ(net::LOAD_VALIDATE_CACHE | kNoTracking, fetcher2->GetLoadFlags());
+}
+
+TEST_F(PrecacheFetcherFetcherTest, RevalidationOnlyResourceHasNoValidators) {
+  GURL url(kGoodResourceURL);
+
+  net::FakeURLFetcher* fetcher = nullptr;
+  EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
+      .WillOnce(factory_.RespondWith("", &fetcher));
+  EXPECT_CALL(*this,
               Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
                                 nullptr)));  // It never reached the network.
 
   PrecacheFetcher::Fetcher precache_fetcher(
       request_context_.get(), url, url.host(), callback_,
-      true /* is_resource_request */, SIZE_MAX);
+      true /* is_resource_request */, SIZE_MAX, true /* revalidation_only */);
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(
       net::LOAD_ONLY_FROM_CACHE | net::LOAD_SKIP_CACHE_VALIDATION | kNoTracking,
       fetcher->GetLoadFlags());
 }
 
 TEST_F(PrecacheFetcherFetcherTest, ResourceTooBig) {
   GURL url(kGoodResourceURL);
 
   EXPECT_CALL(factory_, DoCreateURLFetcher(_, url, net::URLFetcher::GET, _))
       // Cache request will fail, so that a network request is made. Only
       // network requests are byte-capped.
       .WillOnce(factory_.RespondWith("", CacheMiss, nullptr))
       .WillOnce(factory_.RespondWith(std::string(100, '.'), nullptr));
 
   // The callback should be called even though the download was cancelled, so
   // that the next download can start. The network_url_fetcher within should be
   // null, to signify that either the network was never reached (which will be
   // flagged as an error due to the expectation above) or it was requested but
   // cancelled (which is the desired behavior).
   EXPECT_CALL(*this,
               Callback(Property(&PrecacheFetcher::Fetcher::network_url_fetcher,
                                 nullptr)));
 
   PrecacheFetcher::Fetcher precache_fetcher(
       request_context_.get(), url, url.host(), callback_,
-      true /* is_resource_request */, 99 /* max_bytes */);
+      true /* is_resource_request */, 99 /* max_bytes */,
+      false /* revalidation_only */);
 
   base::RunLoop().RunUntilIdle();
 }
 
 class PrecacheFetcherTest : public testing::Test {
  public:
   PrecacheFetcherTest()
       : task_runner_(base::ThreadTaskRunnerHandle::Get()),
         request_context_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())),
@@ skipping 1484 matching lines @@
   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