Update from https://crrev.com/311076

net/http/http_cache.h

 // Copyright (c) 2012 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.
 
 // This file declares a HttpTransactionFactory implementation that can be
 // layered on top of another HttpTransactionFactory to add HTTP caching.  The
 // caching logic follows RFC 2616 (any exceptions are called out in the code).
 //
 // The HttpCache takes a disk_cache::Backend as a parameter, and uses that for
 // the cache storage.
 //
 // See HttpTransactionFactory and HttpTransaction for more details.
 
 #ifndef NET_HTTP_HTTP_CACHE_H_
 #define NET_HTTP_HTTP_CACHE_H_
 
 #include <list>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/threading/non_thread_safe.h"
+#include "base/time/clock.h"
 #include "base/time/time.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
 #include "net/base/load_states.h"
 #include "net/base/net_export.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_transaction_factory.h"
 
 class GURL;
@@ skipping 81 matching lines @@
                       const CompletionCallback& callback) override;
 
    private:
     CacheType type_;
     BackendType backend_type_;
     const base::FilePath path_;
     int max_bytes_;
     scoped_refptr<base::SingleThreadTaskRunner> thread_;
   };
 
+  // The number of minutes after a resource is prefetched that it can be used
+  // again without validation.
+  static const int kPrefetchReuseMins = 5;
+
   // The disk cache is initialized lazily (by CreateTransaction) in this case.
   // The HttpCache takes ownership of the |backend_factory|.
   HttpCache(const net::HttpNetworkSession::Params& params,
             BackendFactory* backend_factory);
 
   // The disk cache is initialized lazily (by CreateTransaction) in this case.
   // Provide an existing HttpNetworkSession, the cache can construct a
   // network layer with a shared HttpNetworkSession in order for multiple
   // network layers to share information (e.g. authentication data). The
   // HttpCache takes ownership of the |backend_factory|.
@@ skipping 35 matching lines @@
   void WriteMetadata(const GURL& url,
                      RequestPriority priority,
                      base::Time expected_response_time,
                      IOBuffer* buf,
                      int buf_len);
 
   // Get/Set the cache's mode.
   void set_mode(Mode value) { mode_ = value; }
   Mode mode() { return mode_; }
 
+  // Get/Set the cache's clock. These are public only for testing.
+  void SetClockForTesting(scoped_ptr<base::Clock> clock) {
+    clock_.reset(clock.release());
+  }
+  base::Clock* clock() const { return clock_.get(); }
+
   // Close currently active sockets so that fresh page loads will not use any
   // recycled connections.  For sockets currently in use, they may not close
   // immediately, but they will not be reusable. This is for debugging.
   void CloseAllConnections();
 
   // Close all idle connections. Will close all sockets not in active use.
   void CloseIdleConnections();
 
   // Called whenever an external cache in the system reuses the resource
   // referred to by |url| and |http_method|.
@@ skipping 261 matching lines @@
   ActiveEntriesSet doomed_entries_;
 
   // The set of entries "under construction".
   PendingOpsMap pending_ops_;
 
   scoped_ptr<PlaybackCacheMap> playback_cache_map_;
 
   // The async validations currently in progress, keyed by URL.
   AsyncValidationMap async_validations_;
 
+  // A clock that can be swapped out for testing.
+  scoped_ptr<base::Clock> clock_;
+
   base::WeakPtrFactory<HttpCache> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpCache);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_H_