[HttpCache] LOAD_ONLY_FROM_CACHE should not imply LOAD_PREFERRING_CACHE

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 245 matching lines @@
                                 NotNull())))
       .Times(1);
 
   PrecacheFetcher::Fetcher precache_fetcher(
       request_context_.get(), url, url.host(), callback_,
       true /* is_resource_request */, SIZE_MAX);
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_NE(nullptr, fetcher1);
-  EXPECT_EQ(net::LOAD_ONLY_FROM_CACHE | kNoTracking, fetcher1->GetLoadFlags());
+  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);
 
   base::RunLoop().RunUntilIdle();
 
   ASSERT_NE(nullptr, fetcher1);
-  EXPECT_EQ(net::LOAD_ONLY_FROM_CACHE | kNoTracking, fetcher1->GetLoadFlags());
+  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;
   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);
 
   base::RunLoop().RunUntilIdle();
 
-  EXPECT_EQ(net::LOAD_ONLY_FROM_CACHE | kNoTracking, fetcher->GetLoadFlags());
+  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));
@@ skipping 1143 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