Implement in-memory byte hints in SimpleCache

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 40 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 GetMemoryEntryData() const { return memory_entry_data_; }
+  void SetMemoryEntryData(uint8_t val) { memory_entry_data_ = val; }
+
   // 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_memory_entry_data);
 
   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.
+  uint32_t entry_size_ : 24;  // in 256-byte blocks.

[gavinp, 2017/08/04 18:42:54]

pasko elsewhere suggests renaming this member. +1 to that.

[Maks Orlovich, 2017/08/23 19:29:06]

Went with entry_size_256b_chunks_, since I think rounded_ doesn't quite express
the right thing.

+  uint32_t memory_entry_data_ : 8;
 };
 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 27 matching lines @@
   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;
 
   // 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);
 
+  uint8_t GetMemoryEntryData(uint64_t entry_hash) const;
+  void SetMemoryEntryData(uint64_t entry_hash, uint8_t value);
+
   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);
 
   using EntrySet = std::unordered_map<uint64_t, EntryMetadata>;
 
@@ skipping 105 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_