Plumb network stack information about existence of cached copy

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.
@@ skipping 177 matching lines @@
 
   // Initializes the Infinite Cache, if selected by the field trial.
   void InitializeInfiniteCache(const base::FilePath& path);
 
   // HttpTransactionFactory implementation:
   virtual int CreateTransaction(RequestPriority priority,
                                 scoped_ptr<HttpTransaction>* trans) OVERRIDE;
   virtual HttpCache* GetCache() OVERRIDE;
   virtual HttpNetworkSession* GetSession() OVERRIDE;
 
+  // Reset the network layer to allow for browser tests that probe

[rvargas (doing something else), 2014/01/15 03:26:29]

nit: don't mention browser tests

[Randy Smith (Not in Mondays), 2014/01/15 19:14:43]

Done.

+  // network changes (e.g. host unreachable).  The old network layer is
+  // returned.  Note ownership exchange.
+  scoped_ptr<HttpTransactionFactory> SetNetworkLayerForTesting(

[rvargas (doing something else), 2014/01/15 03:26:29]

I'm wondering what do you envision for the returned network layer. That means
that I'm a little uncomfortable with giving away the old value, in part because
the use requires that no requests should be in flight when the network is
switched.

So I'm guessing that you want to create a browser, grab the cache right away and
replace the network for the lifetime of that browser.

[Randy Smith (Not in Mondays), 2014/01/15 19:14:43]

So that would work for this instance, and I'm willing to do that if you'd like. 
But the use case I had envisioned for possible/later tests was for the new
HttpTransactionFactory to act as a filter, sometimes interception
HttpTransaction creation requests, and sometimes passing them through to the
original factory.  This interface would enable that usage.

[rvargas (doing something else), 2014/01/15 19:39:45]

ah, ok. That works.

+      scoped_ptr<HttpTransactionFactory> new_network_layer);
+
  protected:
   // Disk cache entry data indices.
   enum {
     kResponseInfoIndex = 0,
     kResponseContentIndex,
     kMetadataIndex,
 
     // Must remain at the end of the enum.
     kNumCacheEntryDataIndices
   };
@@ skipping 166 matching lines @@
   // Variables ----------------------------------------------------------------
 
   NetLog* net_log_;
 
   // Used when lazily constructing the disk_cache_.
   scoped_ptr<BackendFactory> backend_factory_;
   bool building_backend_;
 
   Mode mode_;
 
-  const scoped_ptr<HttpTransactionFactory> network_layer_;
+  scoped_ptr<HttpTransactionFactory> network_layer_;
   scoped_ptr<disk_cache::Backend> disk_cache_;
 
   // The set of active entries indexed by cache key.
   ActiveEntriesMap active_entries_;
 
   // The set of doomed entries.
   ActiveEntriesSet doomed_entries_;
 
   // The set of entries "under construction".
   PendingOpsMap pending_ops_;
 
   scoped_ptr<PlaybackCacheMap> playback_cache_map_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpCache);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_CACHE_H_