Implement cache counting for the simple and memory backends.

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 452 matching lines @@
       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);
 }
 
+void SimpleBackendImpl::IndexReadyForCalculation(
+    const CompletionCallback& callback,
+    int result) {
+  if (result == net::OK)
+    result = static_cast<int>(index_->GetCacheSize());

[msramek, 2015/10/09 09:32:24]

cache_size_, and thus also GetCacheSize(), are uint64.

However, I designed CalculateSizeOfAllEntries() to return an int, because
CreateCacheBackend takes a "max_bytes" parameter which is also an int.

So I'm a bit confused here - can the simple cache have a size larger than MAXINT
or not?

[pasko, 2015/10/09 15:52:03]

We do not want to introduce more constraints in the simplecache implementation,
such as  INT_MAX. The deficiency of the cache interface is bad, but let's not
make it worse.

It may be non-theoretical soon :)

[msramek, 2015/10/13 09:45:06]

Ah ok, good to know. Still, I'd like to keep the signature as int instead of
uint64 in this CL for several reasons:

1. I would need to change the signature in disk_cache.h as well, bringing it to
an inconsistent state where getting size uses wider ints than setting size.
2. My consumer currently expect getting int from disk cache, so I'll have to
touch a few more files.
3. I'll have to define a new callback, since nothing in completion_callback.h
can return uint64 and negative NET_ERR values as well.
4. There is a precedent for this in SimpleBackendImpl::GetMaxFileSize().

+  callback.Run(result);
+}
+
 int SimpleBackendImpl::CalculateSizeOfAllEntries(
     const CompletionCallback& callback) {
-  // TODO(msramek): Implement.
-  return net::ERR_NOT_IMPLEMENTED;
+  return index_->ExecuteWhenReady(
+      base::Bind(&SimpleBackendImpl::IndexReadyForCalculation,
+                 AsWeakPtr(),
+                 callback));
 }
 
 class SimpleBackendImpl::SimpleIterator final : public Iterator {
  public:
   explicit SimpleIterator(base::WeakPtr<SimpleBackendImpl> backend)
       : backend_(backend),
         weak_factory_(this) {
   }
 
   // From Backend::Iterator:
@@ skipping 252 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