Calculate the size of all cache entries between two points in time.

net/disk_cache/simple/simple_backend_impl.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_BACKEND_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_
 
 #include <stdint.h>
 
 #include <memory>
@@ skipping 92 matching lines @@
                   const CompletionCallback& callback) override;
   int DoomEntry(const std::string& key,
                 const CompletionCallback& callback) override;
   int DoomAllEntries(const CompletionCallback& callback) override;
   int DoomEntriesBetween(base::Time initial_time,
                          base::Time end_time,
                          const CompletionCallback& callback) override;
   int DoomEntriesSince(base::Time initial_time,
                        const CompletionCallback& callback) override;
   int CalculateSizeOfAllEntries(const CompletionCallback& callback) override;
+  int CalculateSizeOfEntriesBetween(
+      base::Time initial_time,
+      base::Time end_time,
+      const CompletionCallback& callback) override;
   std::unique_ptr<Iterator> CreateIterator() override;
   void GetStats(base::StringPairs* stats) override;
   void OnExternalCacheHit(const std::string& key) override;
 
  private:
   class SimpleIterator;
   friend class SimpleIterator;
 
   using EntryMap = std::unordered_map<uint64_t, SimpleEntryImpl*>;
 
@@ skipping 18 matching lines @@
   // |end_time|. Invoked when the index is ready.
   void IndexReadyForDoom(base::Time initial_time,
                          base::Time end_time,
                          const CompletionCallback& callback,
                          int result);
 
   // Calculates the size of the entire cache. Invoked when the index is ready.
   void IndexReadyForSizeCalculation(const CompletionCallback& callback,
                                     int result);
 
+  // Calculates the size all cache entries between |initial_time| and
+  // |end_time|. Invoked when the index is ready.
+  void IndexReadyForSizeBetweenCalculation(base::Time initial_time,
+                                           base::Time end_time,
+                                           const CompletionCallback& callback,
+                                           int result);
+
   // Try to create the directory if it doesn't exist. This must run on the IO
   // thread.
   static DiskStatResult InitCacheStructureOnDisk(
       const base::FilePath& path,
       uint64_t suggested_max_size,
       const SimpleExperiment& experiment);
 
   // Searches |active_entries_| for the entry corresponding to |key|. If found,
   // returns the found entry. Otherwise, creates a new entry and returns that.
   scoped_refptr<SimpleEntryImpl> CreateOrFindActiveEntry(
@@ skipping 55 matching lines @@
   // operations to be run at the completion of the Doom.
   std::unordered_map<uint64_t, std::vector<base::Closure>>
       entries_pending_doom_;
 
   net::NetLog* const net_log_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_BACKEND_IMPL_H_