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

net/disk_cache/simple/simple_index.h

 // Copyright (c) 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 NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_
 
 #include <stdint.h>
 
 #include <list>
@@ skipping 39 matching lines @@
 
   base::Time GetLastUsedTime() const;
   void SetLastUsedTime(const base::Time& last_used_time);
 
   uint32_t RawTimeForSorting() const {
     return last_used_time_seconds_since_epoch_;
   }
 
   uint32_t GetEntrySize() const;
   void SetEntrySize(base::StrictNumeric<uint32_t> entry_size);
+  uint8_t GetOracleByte() const;
+  void SetOracleByte(uint8_t oracle_byte);
 
   // Serialize the data into the provided pickle.
   void Serialize(base::Pickle* pickle) const;
-  bool Deserialize(base::PickleIterator* it);
+  bool Deserialize(base::PickleIterator* it, bool has_oracle_byte);
 
   static base::TimeDelta GetLowerEpsilonForTimeComparisons() {
     return base::TimeDelta::FromSeconds(1);
   }
   static base::TimeDelta GetUpperEpsilonForTimeComparisons() {
     return base::TimeDelta();
   }
 
   static const int kOnDiskSizeBytes = 16;
 
  private:
   friend class SimpleIndexFileTest;
 
   // There are tens of thousands of instances of EntryMetadata in memory, so the
   // size of each entry matters.  Even when the values used to set these members
   // are originally calculated as >32-bit types, the actual necessary size for
   // each shouldn't exceed 32 bits, so we use 32-bit types here.
   uint32_t last_used_time_seconds_since_epoch_;
-  uint32_t entry_size_;  // Storage size in bytes.
+  // Storage size in bytes... with oracle byte packed into lower 8 bites.
+  uint32_t entry_size_;
 };
 static_assert(sizeof(EntryMetadata) == 8, "incorrect metadata size");
 
 // This class is not Thread-safe.
 class NET_EXPORT_PRIVATE SimpleIndex
     : public base::SupportsWeakPtr<SimpleIndex> {
  public:
   // Used in histograms. Please only add entries at the end.
   enum IndexInitMethod {
     INITIALIZE_METHOD_RECOVERED = 0,
@@ skipping 23 matching lines @@
 
   void SetMaxSize(uint64_t max_bytes);
   uint64_t max_size() const { return max_size_; }
 
   void Insert(uint64_t entry_hash);
   void Remove(uint64_t entry_hash);
 
   // Check whether the index has the entry given the hash of its key.
   bool Has(uint64_t entry_hash) const;
 
+  // Like above, but also writes out the oracle byte (or 0) into |*oracle_byte|
+  // if returned true.
+  bool HasWithOracleByte(uint64_t entry_hash, uint8_t* oracle_byte);
+
   // Update the last used time of the entry with the given key and return true
   // iff the entry exist in the index.
   bool UseIfExists(uint64_t entry_hash);
 
   void WriteToDisk(IndexWriteToDiskReason reason);
 
   // Update the size (in bytes) of an entry, in the metadata stored in the
   // index. This should be the total disk-file size including all streams of the
   // entry.
   bool UpdateEntrySize(uint64_t entry_hash,
                        base::StrictNumeric<uint32_t> entry_size);
+  void UpdateEntryOracleByte(uint64_t entry_hash, uint8_t oracle_byte);
 
   using EntrySet = std::unordered_map<uint64_t, EntryMetadata>;
 
   static void InsertInEntrySet(uint64_t entry_hash,
                                const EntryMetadata& entry_metadata,
                                EntrySet* entry_set);
 
   // For use in tests only. Updates cache_size_, but will not start evictions
   // or adjust index writing time. Requires entry to not already be in the set.
   void InsertEntryForTesting(uint64_t entry_hash,
@@ skipping 98 matching lines @@
 
   // Set to true when the app is on the background. When the app is in the
   // background we can write the index much more frequently, to insure fresh
   // index on next startup.
   bool app_on_background_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_INDEX_H_