net/disk_cache/simple: Reduce size of EntrySet nodes.

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 <list>
 #include <string>
 #include <vector>
@@ skipping 21 matching lines @@
 
 namespace base {
 class SingleThreadTaskRunner;
 }
 
 namespace disk_cache {
 
 class NET_EXPORT_PRIVATE EntryMetadata {
  public:
   EntryMetadata();
-  EntryMetadata(uint64 hash_key,
-                base::Time last_used_time,
-                uint64 entry_size);
+  EntryMetadata(base::Time last_used_time, uint64 entry_size);
 
-  uint64 GetHashKey() const { return hash_key_; }
   base::Time GetLastUsedTime() const;
   void SetLastUsedTime(const base::Time& last_used_time);
 
   uint64 GetEntrySize() const { return entry_size_; }
   void SetEntrySize(uint64 entry_size) { entry_size_ = entry_size; }
 
   // Serialize the data into the provided pickle.
   void Serialize(Pickle* pickle) const;
   bool Deserialize(PickleIterator* it);
 
   // Merge two EntryMetadata instances.
   // The existing current valid data in |this| will prevail.
   void MergeWith(const EntryMetadata& entry_metadata);
 
  private:
   friend class SimpleIndexFileTest;
 
   // When adding new members here, you should update the Serialize() and
   // Deserialize() methods.
-  uint64 hash_key_;
 
   // This is the serialized format from Time::ToInternalValue().
   // If you want to make calculations/comparisons, you should use the
   // base::Time() class. Use the GetLastUsedTime() method above.
   // TODO(felipeg): Use Time() here.
   int64 last_used_time_;
 
   uint64 entry_size_;  // Storage size in bytes.
 };
 
@@ skipping 26 matching lines @@
   // 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(const std::string& key, uint64 entry_size);
 
   // TODO(felipeg): This way we are storing the hash_key twice, as the
   // hash_map::key and as a member of EntryMetadata. We could save space if we
   // use a hash_set.
   typedef base::hash_map<uint64, EntryMetadata> EntrySet;
 
-  static void InsertInEntrySet(const EntryMetadata& entry_metadata,
+  static void InsertInEntrySet(uint64 hash_key,
+                               const EntryMetadata& entry_metadata,
                                EntrySet* entry_set);
 
   // Executes the |callback| when the index is ready. Allows multiple callbacks.
   int ExecuteWhenReady(const net::CompletionCallback& callback);
 
   // Takes out entries from the index that have last accessed time matching the
   // range between |initial_time| and |end_time| where open intervals are
   // possible according to the definition given in |DoomEntriesBetween()| in the
   // disk cache backend interface. Returns the set of hashes taken out.
   scoped_ptr<std::vector<uint64> > RemoveEntriesBetween(
@@ skipping 76 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_