Reland of Implement cache counting for the simple and memory backends - with fixed test.

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>
 
@@ skipping 424 matching lines @@
   }
   scoped_refptr<SimpleEntryImpl> simple_entry =
       CreateOrFindActiveEntry(entry_hash, key);
   return simple_entry->DoomEntry(callback);
 }
 
 int SimpleBackendImpl::DoomAllEntries(const CompletionCallback& callback) {
   return DoomEntriesBetween(Time(), Time(), callback);
 }
 
-void SimpleBackendImpl::IndexReadyForDoom(Time initial_time,
-                                          Time end_time,
-                                          const CompletionCallback& callback,
-                                          int result) {
-  if (result != net::OK) {
-    callback.Run(result);
-    return;
-  }
-  scoped_ptr<std::vector<uint64> > removed_key_hashes(
-      index_->GetEntriesBetween(initial_time, end_time).release());
-  DoomEntries(removed_key_hashes.get(), callback);
-}
-
 int SimpleBackendImpl::DoomEntriesBetween(
     const Time initial_time,
     const Time end_time,
     const CompletionCallback& callback) {
   return index_->ExecuteWhenReady(
       base::Bind(&SimpleBackendImpl::IndexReadyForDoom, AsWeakPtr(),
                  initial_time, end_time, callback));
 }
 
 int SimpleBackendImpl::DoomEntriesSince(
     const Time initial_time,
     const CompletionCallback& callback) {
   return DoomEntriesBetween(initial_time, Time(), callback);
 }
 
 int SimpleBackendImpl::CalculateSizeOfAllEntries(
     const CompletionCallback& callback) {
-  // TODO(msramek): Implement.
-  return net::ERR_NOT_IMPLEMENTED;
+  return index_->ExecuteWhenReady(base::Bind(
+      &SimpleBackendImpl::IndexReadyForSizeCalculation, AsWeakPtr(), callback));
 }
 
 class SimpleBackendImpl::SimpleIterator final : public Iterator {
  public:
   explicit SimpleIterator(base::WeakPtr<SimpleBackendImpl> backend)
       : backend_(backend),
         weak_factory_(this) {
   }
 
   // From Backend::Iterator:
@@ skipping 76 matching lines @@
 
 void SimpleBackendImpl::InitializeIndex(const CompletionCallback& callback,
                                         const DiskStatResult& result) {
   if (result.net_error == net::OK) {
     index_->SetMaxSize(result.max_size);
     index_->Initialize(result.cache_dir_mtime);
   }
   callback.Run(result.net_error);
 }
 
+void SimpleBackendImpl::IndexReadyForDoom(Time initial_time,
+                                          Time end_time,
+                                          const CompletionCallback& callback,
+                                          int result) {
+  if (result != net::OK) {
+    callback.Run(result);
+    return;
+  }
+  scoped_ptr<std::vector<uint64>> removed_key_hashes(
+      index_->GetEntriesBetween(initial_time, end_time).release());
+  DoomEntries(removed_key_hashes.get(), callback);
+}
+
+void SimpleBackendImpl::IndexReadyForSizeCalculation(
+    const CompletionCallback& callback,
+    int result) {
+  if (result == net::OK)
+    result = static_cast<int>(index_->GetCacheSize());
+  callback.Run(result);
+}
+
 SimpleBackendImpl::DiskStatResult SimpleBackendImpl::InitCacheStructureOnDisk(
     const base::FilePath& path,
     uint64 suggested_max_size) {
   DiskStatResult result;
   result.max_size = suggested_max_size;
   result.net_error = net::OK;
   if (!FileStructureConsistent(path)) {
     LOG(ERROR) << "Simple Cache Backend: wrong file structure on disk: "
                << path.LossyDisplayName();
     result.net_error = net::ERR_FAILED;
@@ skipping 156 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