Interface for associating in-memory hint bytes with disk cache entries.

net/disk_cache/disk_cache.h

Index: net/disk_cache/disk_cache.h
diff --git a/net/disk_cache/disk_cache.h b/net/disk_cache/disk_cache.h
index 4a3ae119b53f9c90b22f5c70379e5d4fb0f1f057..68391041610c0ae916d8c19151d8119aa5161527 100644
--- a/net/disk_cache/disk_cache.h
+++ b/net/disk_cache/disk_cache.h
@@ -184,6 +184,22 @@ class NET_EXPORT Backend {
   virtual size_t DumpMemoryStats(
       base::trace_event::ProcessMemoryDump* pmd,
       const std::string& parent_absolute_name) const = 0;
+
+  // Backends can optionally permit one to store, probabilistically, up to a
+  // byte associated with a key of an existing entry in memory.
+
+  // GetMemoryEntryData has the following behavior:
+  // - If the feature is not supported by the backend, returns 0.
+  // - If the entry is not in the cache, returns 0.

[Randy Smith (Not in Mondays), 2017/06/27 21:33:56]

Definitively isn't in the cache, or isn't in the in-memory index associated with
the cache?  I.e. is this case a "Maybe there's an entry with this key--I don't
know" or "There is no entry with this key in the cache"?

The reason I ask is that the ability to be sure that there isn't an entry with
this key in the cache without checking disk, even in a best effort fashion, is a
simple cache feature.  If we want to leave the door open to caches that keep
only a partial index in memory in the future, we might want to have the ability
to respond with a shrug/I dunno.

[Maks Orlovich, 2017/06/28 13:54:31]

Hmm, good point. It's actually sort of a mixture even for SimpleCache: it can be
the first while we are initializing, then becomes the second.

[gavinp, 2017/08/04 17:33:14]

This is subtle; because of course yes we can operate without an index, and the
non-presence of an entry doesn't indicate that we don't have data.

Perhaps move this subtlety out of the context of this comment by rephrasing it
to something more like:

"If this data is not available for this particular key, for any reason, returns
0."

Sound reasonable?

[Maks Orlovich, 2017/08/23 18:52:05]

Rephrased, but added "at this time".

+  // - Otherwise, returns a value that was with very high probability
+  //   given to SetMemoryEntryData(|key|) (and with a very low probability
+  //   to a different key that collides in the in-memory index).

[Randy Smith (Not in Mondays), 2017/06/27 21:33:55]

Hmmm.  I'd rather have an interface that distinguished clearly between
supporting, not-in-cache, and an actual value.  Maybe I'm being silly, but I
could imagine consumers making use of those distinctions.  

How about:

* SetMemoryEntryData() returns false if the feature isn't supported.

* GetMemoryEntryData has an out argument for the value, and return false if the
entry isn't in the cache or the feature isn't supported?

[Maks Orlovich, 2017/06/28 13:54:31]

Not sure how you would use that.
Hmm, there is also the issue of entry being written by an older version, which
didn't use to have the feature. 

+  //
+  // Due to the probability of collisions, including those that can be induced
+  // by hostile 3rd parties, this interface should not be used to make decisions
+  // that affect correctness (especially security).
+  virtual uint8_t GetMemoryEntryData(const std::string& key);
+  virtual void SetMemoryEntryData(const std::string& key, uint8_t data);
 };
 
 // This interface represents an entry in the disk cache.