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

net/disk_cache/simple/simple_backend_impl.cc

 // 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.
 
 #include "net/disk_cache/simple/simple_backend_impl.h"
 
 #include <algorithm>
 #include <cstdlib>
 #include <functional>
 #include <limits>
@@ skipping 440 matching lines @@
     const CompletionCallback& callback) {
   return DoomEntriesBetween(initial_time, Time(), callback);
 }
 
 int SimpleBackendImpl::CalculateSizeOfAllEntries(
     const CompletionCallback& callback) {
   return index_->ExecuteWhenReady(base::Bind(
       &SimpleBackendImpl::IndexReadyForSizeCalculation, AsWeakPtr(), callback));
 }
 
+int SimpleBackendImpl::CalculateSizeOfEntriesBetween(
+    base::Time initial_time,
+    base::Time end_time,
+    const CompletionCallback& callback) {
+  return index_->ExecuteWhenReady(
+      base::Bind(&SimpleBackendImpl::IndexReadyForSizeBetweenCalculation,
+                 AsWeakPtr(), initial_time, end_time, callback));
+}
+
 class SimpleBackendImpl::SimpleIterator final : public Iterator {
  public:
   explicit SimpleIterator(base::WeakPtr<SimpleBackendImpl> backend)
       : backend_(backend),
         weak_factory_(this) {
   }
 
   // From Backend::Iterator:
   int OpenNextEntry(Entry** next_entry,
                     const CompletionCallback& callback) override {
@@ skipping 95 matching lines @@
 }
 
 void SimpleBackendImpl::IndexReadyForSizeCalculation(
     const CompletionCallback& callback,
     int result) {
   if (result == net::OK)
     result = static_cast<int>(index_->GetCacheSize());
   callback.Run(result);
 }
 
+void SimpleBackendImpl::IndexReadyForSizeBetweenCalculation(
+    base::Time initial_time,
+    base::Time end_time,
+    const CompletionCallback& callback,
+    int result) {
+  if (result == net::OK) {
+    result =
+        static_cast<int>(index_->GetCacheSizeBetween(initial_time, end_time));
+  }
+  callback.Run(result);
+}
+
 // static
 SimpleBackendImpl::DiskStatResult SimpleBackendImpl::InitCacheStructureOnDisk(
     const base::FilePath& path,
     uint64_t suggested_max_size,
     const SimpleExperiment& experiment) {
   DiskStatResult result;
   result.max_size = suggested_max_size;
   result.net_error = net::OK;
   if (!FileStructureConsistent(path, experiment)) {
     LOG(ERROR) << "Simple Cache Backend: wrong file structure on disk: "
@@ skipping 140 matching lines @@
 }
 
 // static
 void SimpleBackendImpl::FlushWorkerPoolForTesting() {
   // We only need to do this if we there is an active task runner.
   if (base::ThreadTaskRunnerHandle::IsSet())
     g_sequenced_worker_pool.Get().FlushForTesting();
 }
 
 }  // namespace disk_cache