Add revalidation_only option to precache config.

components/precache/core/precache_fetcher.h

 // 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.
 
 #ifndef COMPONENTS_PRECACHE_CORE_PRECACHE_FETCHER_H_
 #define COMPONENTS_PRECACHE_CORE_PRECACHE_FETCHER_H_
 
 #include <stdint.h>
 
 #include <deque>
@@ skipping 274 matching lines @@
 //
 // This allows the precache to "refresh" cache entries by increasing their
 // expiration date, but minimizes the network impact of doing so, by performing
 // only conditional GETs.
 //
 // On completion it calls the given callback. This class cancels requests whose
 // responses are or will be larger than max_bytes. In such cases,
 // network_url_fetcher() will return nullptr.
 class PrecacheFetcher::Fetcher : public net::URLFetcherDelegate {
  public:
-  // Construct a new Fetcher. This will create and start a new URLFetcher for
-  // the specified URL using the specified request context.
+  // Construct a new Fetcher. This will create and start a new URLFetcher
+  // immediately. Parameters:
+  //   request_context: The request context to pass to the URLFetcher.
+  //   url: The URL to fetch.
+  //   referrer: The hostname of the manifest requesting this resource. Empty
+  //       for config fetches.
+  //   callback: Called when the fetch is finished or cancelled.
+  //   is_resource_request: If true, the URL may be refreshed using
+  //       LOAD_VALIDATE_CACHE.
+  //   max_bytes: The number of bytes to download before cancelling.
+  //   revalidation_only: If true, the URL is fetched only if it has an existing
+  //       cache entry with conditional headers.
   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);
   ~Fetcher() override;
   void OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                   int64_t current,
                                   int64_t total,
                                   int64_t current_network_bytes) override;
   void OnURLFetchComplete(const net::URLFetcher* source) override;
   int64_t response_bytes() const { return response_bytes_; }
   int64_t network_response_bytes() const { return network_response_bytes_; }
   const net::URLFetcher* network_url_fetcher() const {
     return network_url_fetcher_.get();
   }
   const GURL& url() const { return url_; }
   const std::string& referrer() const { return referrer_; }
   bool is_resource_request() const { return is_resource_request_; }
   bool was_cached() const { return was_cached_; }
 
  private:
   enum class FetchStage { CACHE, NETWORK };
 
   void LoadFromCache();
   void LoadFromNetwork();
 
+  // The arguments to this Fetcher's constructor.
   net::URLRequestContextGetter* const request_context_;
   const GURL url_;
   const std::string referrer_;
   const base::Callback<void(const Fetcher&)> callback_;
   const bool is_resource_request_;
   const size_t max_bytes_;
+  const bool revalidation_only_;
 
   FetchStage fetch_stage_;
   // The cache_url_fetcher_ is kept alive until Fetcher destruction for testing.
   std::unique_ptr<net::URLFetcher> cache_url_fetcher_;
   std::unique_ptr<net::URLFetcher> network_url_fetcher_;
   int64_t response_bytes_;
   int64_t network_response_bytes_;
   bool was_cached_;
 
   DISALLOW_COPY_AND_ASSIGN(Fetcher);
 };
 
 }  // namespace precache
 
 #endif  // COMPONENTS_PRECACHE_CORE_PRECACHE_FETCHER_H_