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

net/disk_cache/disk_cache.cc

 // Copyright (c) 2012 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 <utility>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/single_thread_task_runner.h"
@@ skipping 70 matching lines @@
       backend_type_(backend_type),
 #if !defined(OS_ANDROID)
       flags_(flags),
 #endif
       thread_(thread),
       backend_(backend),
       callback_(callback),
       net_log_(net_log) {
 }
 
-CacheCreator::~CacheCreator() {
-}
+CacheCreator::~CacheCreator() {}
 
 int CacheCreator::Run() {
 #if defined(OS_ANDROID)
   static const bool kSimpleBackendIsDefault = true;
 #else
   static const bool kSimpleBackendIsDefault = false;
 #endif
   if (backend_type_ == net::CACHE_BACKEND_SIMPLE ||
       (backend_type_ == net::CACHE_BACKEND_DEFAULT &&
        kSimpleBackendIsDefault)) {
     disk_cache::SimpleBackendImpl* simple_cache =
-        new disk_cache::SimpleBackendImpl(
-            path_, max_bytes_, type_, thread_, net_log_);
+        new disk_cache::SimpleBackendImpl(path_, max_bytes_, type_, thread_,
+                                          net_log_);
     created_cache_.reset(simple_cache);
     return simple_cache->Init(
         base::Bind(&CacheCreator::OnIOComplete, base::Unretained(this)));
   }
 
-  // Avoid references to blockfile functions on Android to reduce binary size.
+// Avoid references to blockfile functions on Android to reduce binary size.
 #if defined(OS_ANDROID)
   return net::ERR_FAILED;
 #else
   disk_cache::BackendImpl* new_cache =
       new disk_cache::BackendImpl(path_, thread_, net_log_);
   created_cache_.reset(new_cache);
   new_cache->SetMaxSize(max_bytes_);
   new_cache->SetType(type_);
   new_cache->SetFlags(flags_);
   int rv = new_cache->Init(
@@ skipping 47 matching lines @@
     const scoped_refptr<base::SingleThreadTaskRunner>& thread,
     net::NetLog* net_log,
     std::unique_ptr<Backend>* backend,
     const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (type == net::MEMORY_CACHE) {
     *backend = disk_cache::MemBackendImpl::CreateBackend(max_bytes, net_log);
     return *backend ? net::OK : net::ERR_FAILED;
   }
   DCHECK(thread.get());
-  CacheCreator* creator = new CacheCreator(path,
-                                           force,
-                                           max_bytes,
-                                           type,
-                                           backend_type,
-                                           kNone,
-                                           thread,
-                                           net_log,
-                                           backend,
-                                           callback);
+  CacheCreator* creator =
+      new CacheCreator(path, force, max_bytes, type, backend_type, kNone,
+                       thread, net_log, backend, callback);
   return creator->Run();
 }
 
+int Backend::CalculateSizeOfEntriesBetween(base::Time initial_time,
+                                           base::Time end_time,
+                                           const CompletionCallback& callback) {
+  return net::ERR_NOT_IMPLEMENTED;
+}
+
 }  // namespace disk_cache