RFC: use some in-memory state in SimpleCache to quickly cache-miss some CantConditionalize cases

net/disk_cache/disk_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.
 
 // Defines the public interface of the disk cache. For more details see
 // http://dev.chromium.org/developers/design-documents/network-stack/disk-cache
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_H_
 #define NET_DISK_CACHE_DISK_CACHE_H_
 
@@ skipping 53 matching lines @@
     int max_bytes,
     bool force,
     const scoped_refptr<base::SingleThreadTaskRunner>& thread,
     net::NetLog* net_log,
     std::unique_ptr<Backend>* backend,
     const net::CompletionCallback& callback);
 
 // The root interface for a disk cache instance.
 class NET_EXPORT Backend {
  public:
+  enum class OracleJudgement { HIT, MISS_AND_DOOM };
+
   typedef net::CompletionCallback CompletionCallback;
+  typedef base::Callback<OracleJudgement(uint8_t)> OracleCallback;
 
   class Iterator {
    public:
     virtual ~Iterator() {}
 
     // OpenNextEntry returns |net::OK| and provides |next_entry| if there is an
     // entry to enumerate. It returns |net::ERR_FAILED| at the end of
     // enumeration. If the function returns |net::ERR_IO_PENDING|, then the
     // final result will be passed to the provided |callback|, otherwise
     // |callback| will not be called. If any entry in the cache is modified
@@ skipping 24 matching lines @@
 
   // Opens an existing entry. Upon success, |entry| holds a pointer to an Entry
   // object representing the specified disk cache entry. When the entry pointer
   // is no longer needed, its Close method should be called. The return value is
   // a net error code. If this method returns ERR_IO_PENDING, the |callback|
   // will be invoked when the entry is available. The pointer to receive the
   // |entry| must remain valid until the operation completes.
   virtual int OpenEntry(const std::string& key, Entry** entry,
                         const CompletionCallback& callback) = 0;
 
+  // This is a variant of above, which can give the client a chance to quickly
+  // invalidate the entry w/o fully opening it, by taking a look at a byte
+  // it has previously passed to Entry::SetOracleByte inside |oracle|.
+  //
+  // Default implementation just delegates to OpenEntry.
+  virtual int OpenEntryWithOracleByte(const std::string& key,

[jkarlin, 2017/06/07 20:01:54]

I'd rather we have a more general purpose byte in the index that can be used by
any customer. OracleJudgement and OpenEntryWithOracleByte forces a certain
behavior for the byte.

How about instead:

virtual uint8_t GetMemoryEntryData(const std::string& key);
virtual void SetMemoryEntryData(const std::string& key, uint8_t data);

Then the HttpCache::Transaction can call that and make its own decision before
the call to Open.

[jkarlin, 2017/06/07 20:04:44]

Ah, this will have to be an async call won't it because the index might be still
loading. That's still okay imo.

+                                      Entry** entry,
+                                      const OracleCallback& oracle,
+                                      const CompletionCallback& callback);
+
   // Creates a new entry. Upon success, the out param holds a pointer to an
   // Entry object representing the newly created disk cache entry. When the
   // entry pointer is no longer needed, its Close method should be called. The
   // return value is a net error code. If this method returns ERR_IO_PENDING,
   // the |callback| will be invoked when the entry is available. The pointer to
   // receive the |entry| must remain valid until the operation completes.
   virtual int CreateEntry(const std::string& key, Entry** entry,
                           const CompletionCallback& callback) = 0;
 
   // Marks the entry, specified by the given key, for deletion. The return value
@@ skipping 76 matching lines @@
 
   // Returns the time when this cache entry was last used.
   virtual base::Time GetLastUsed() const = 0;
 
   // Returns the time when this cache entry was last modified.
   virtual base::Time GetLastModified() const = 0;
 
   // Returns the size of the cache data with the given index.
   virtual int32_t GetDataSize(int index) const = 0;
 
+  // If supported by the backend, stores a byte associated with this entry in a
+  // way that can be accessed efficiently by OpenEntryWithOracleByte (before
+  // opening the whole entry).
+  // TBD non-zero, blah blah.
+  // TBD.
+  //
+  // Default implementation does nothing.
+  virtual void SetOracleByte(uint8_t);
+
   // Copies cached data into the given buffer of length |buf_len|. Returns the
   // number of bytes read or a network error code. If this function returns
   // ERR_IO_PENDING, the completion callback will be called on the current
   // thread when the operation completes, and a reference to |buf| will be
   // retained until the callback is called. Note that as long as the function
   // does not complete immediately, the callback will always be invoked, even
   // after Close has been called; in other words, the caller may close this
   // entry without having to wait for all the callbacks, and still rely on the
   // cleanup performed from the callback code.
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
@@ skipping 128 matching lines @@
     entry->Close();
   }
 };
 
 // Automatically closes an entry when it goes out of scope.
 typedef std::unique_ptr<Entry, EntryDeleter> ScopedEntryPtr;
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H_