Speed up SimpleCache eviction set computation

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 33 matching lines @@
 
 class NET_EXPORT_PRIVATE EntryMetadata {
  public:
   EntryMetadata();
   EntryMetadata(base::Time last_used_time,
                 base::StrictNumeric<uint32_t> entry_size);
 
   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);
 
   // Serialize the data into the provided pickle.
   void Serialize(base::Pickle* pickle) const;
   bool Deserialize(base::PickleIterator* it);
 
   static base::TimeDelta GetLowerEpsilonForTimeComparisons() {
     return base::TimeDelta::FromSeconds(1);
   }
@@ skipping 64 matching lines @@
   // entry.
   bool UpdateEntrySize(uint64_t entry_hash,
                        base::StrictNumeric<uint32_t> entry_size);
 
   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,
+                             const EntryMetadata& entry_metadata);
+
   // Executes the |callback| when the index is ready. Allows multiple callbacks.
   int ExecuteWhenReady(const net::CompletionCallback& callback);
 
   // Returns 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.
   std::unique_ptr<HashList> GetEntriesBetween(const base::Time initial_time,
                                               const base::Time end_time);
 
@@ skipping 86 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_