Add revalidation_only option to precache config.

components/precache/core/precache_fetcher.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 <algorithm>
 #include <limits>
 #include <set>
 #include <utility>
@@ skipping 223 matching lines @@
 }
 
 }  // namespace
 
 PrecacheFetcher::Fetcher::Fetcher(
     net::URLRequestContextGetter* request_context,
     const GURL& url,
     const std::string& referrer,
     const base::Callback<void(const Fetcher&)>& callback,
     bool is_resource_request,
-    size_t max_bytes)
+    size_t max_bytes,
+    bool revalidation_only)
     : request_context_(request_context),
       url_(url),
       referrer_(referrer),
       callback_(callback),
       is_resource_request_(is_resource_request),
       max_bytes_(max_bytes),
+      revalidation_only_(revalidation_only),
       response_bytes_(0),
       network_response_bytes_(0),
       was_cached_(false) {
   DCHECK(url.is_valid());
   if (is_resource_request_)
     LoadFromCache();
   else
     LoadFromNetwork();
 }
 
@@ skipping 62 matching lines @@
     // Cancel the download.
     network_url_fetcher_.reset();
     callback_.Run(*this);
   }
 }
 
 void PrecacheFetcher::Fetcher::OnURLFetchComplete(
     const net::URLFetcher* source) {
   CHECK(source);
   if (fetch_stage_ == FetchStage::CACHE &&
-      (source->GetStatus().error() == net::ERR_CACHE_MISS ||
+      ((source->GetStatus().error() == net::ERR_CACHE_MISS &&
+        !revalidation_only_) ||
        (source->GetResponseHeaders() &&
         source->GetResponseHeaders()->HasValidators()))) {
     // If the resource was not found in the cache, request it from the
     // network.
     //
     // If the resource was found in the cache, but contains validators,
     // request a refresh. The presence of validators increases the chance that
     // we get a 304 response rather than a full one, thus allowing us to
     // refresh the cache with minimal network load.
     LoadFromNetwork();
@@ skipping 137 matching lines @@
       config_url_.is_empty() ? GetDefaultConfigURL() : config_url_;
 
   DCHECK(config_url.is_valid()) << "Config URL not valid: "
                                 << config_url.possibly_invalid_spec();
 
   // Fetch the precache configuration settings from the server.
   DCHECK(pool_.IsEmpty()) << "All parallel requests should be available";
   pool_.Add(base::MakeUnique<Fetcher>(
       request_context_.get(), config_url, std::string(),
       base::Bind(&PrecacheFetcher::OnConfigFetchComplete, AsWeakPtr()),
-      false /* is_resource_request */, std::numeric_limits<int32_t>::max()));
+      false /* is_resource_request */, std::numeric_limits<int32_t>::max(),
+      false /* revalidation_only */));
 }
 
 void PrecacheFetcher::StartNextResourceFetch() {
   DCHECK(unfinished_work_->has_config_settings());
   while (!resources_to_fetch_.empty() && pool_.IsAvailable()) {
     ResourceInfo& resource = resources_to_fetch_.front();
     const size_t max_bytes = std::min(
         quota_.remaining(),
         std::min(unfinished_work_->config_settings().max_bytes_per_resource(),
                  unfinished_work_->config_settings().max_bytes_total() -
                      unfinished_work_->total_bytes()));
     pool_.Add(base::MakeUnique<Fetcher>(
         request_context_.get(), resource.url, resource.referrer,
         base::Bind(&PrecacheFetcher::OnResourceFetchComplete, AsWeakPtr()),
-        true /* is_resource_request */, max_bytes));
+        true /* is_resource_request */, max_bytes,
+        unfinished_work_->config_settings().revalidation_only()));
 
     resources_fetching_.push_back(std::move(resource));
     resources_to_fetch_.pop_front();
   }
 }
 
 void PrecacheFetcher::StartNextManifestFetches() {
   // We fetch as many manifests at a time as possible, as we need all resource
   // URLs in memory in order to rank them.
   while (!top_hosts_to_fetch_.empty() && pool_.IsAvailable()) {
     ManifestHostInfo& top_host = top_hosts_to_fetch_.front();
     pool_.Add(base::MakeUnique<Fetcher>(
         request_context_.get(), top_host.manifest_url, top_host.hostname,
         base::Bind(&PrecacheFetcher::OnManifestFetchComplete, AsWeakPtr(),
                    top_host.visits),
-        false /* is_resource_request */, std::numeric_limits<int32_t>::max()));
+        false /* is_resource_request */, std::numeric_limits<int32_t>::max(),
+        false /* revalidation_only */));
     top_hosts_fetching_.push_back(std::move(top_host));
     top_hosts_to_fetch_.pop_front();
   }
 }
 
 void PrecacheFetcher::NotifyDone(
     size_t remaining_manifest_urls_to_fetch,
     size_t remaining_resource_urls_to_fetch) {
   RecordCompletionStatistics(*unfinished_work_,
                              remaining_manifest_urls_to_fetch,
@@ skipping 272 matching lines @@
       remaining = 0;
     quota_.set_remaining(
         used_bytes > quota_.remaining() ? 0U : quota_.remaining() - used_bytes);
     db_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&PrecacheDatabase::SaveQuota, precache_database_, quota_));
   }
 }
 
 }  // namespace precache