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

net/disk_cache/disk_cache.h

Index: net/disk_cache/disk_cache.h
diff --git a/net/disk_cache/disk_cache.h b/net/disk_cache/disk_cache.h
index f71bc81964b929f4dce5596d724c41bf36429279..c3c0a87d6d3f7193fc07c2ff05fdac78101f52b7 100644
--- a/net/disk_cache/disk_cache.h
+++ b/net/disk_cache/disk_cache.h
@@ -19,6 +19,7 @@
 #include "base/time/time.h"
 #include "net/base/cache_type.h"
 #include "net/base/completion_callback.h"
+#include "net/base/net_errors.h"

[gavinp, 2017/01/12 16:07:36]

Amazing that this wasn't there already!!! Good catch!

[dullweber, 2017/01/12 17:03:15]

Oh, that's funny. The include is here because I tried to add the "return
ERR_NOT_IMPLEMENTED;" here first but it complained that I can't put this in a
header file and there was no .cc, so I moved it to the individual
implementations. I'm not sure if this class should have implementations because
currently it is a completely virtual interface? If you prefer to have the
default implementation here, I will add the .cc file.

 #include "net/base/net_export.h"
 
 namespace base {
@@ -149,7 +150,18 @@ class NET_EXPORT Backend {
   // Calculate the total size of the cache. The return value is the size in
   // bytes or a net error code. If this method returns ERR_IO_PENDING,
   // the |callback| will be invoked when the operation completes.
-  virtual int CalculateSizeOfAllEntries(
+  virtual int CalculateSizeOfAllEntries(const CompletionCallback& callback) = 0;
+
+  // Calculate the size of all cache entries accessed between |initial_time| and
+  // |end_time|.
+  // The return value is the size in bytes or a net error code. A return value
+  // of ERR_NOT_IMPLEMTED means that there is no efficient way for the backend

[gavinp, 2017/01/12 16:07:36]

typo: ERR_NOT_IMPLEMENTED, isn't it?

[dullweber, 2017/01/12 17:03:15]

Done.

+  // to determine the size for a subset of the cache.
+  // If this method returns ERR_IO_PENDING, the |callback| will be invoked when
+  // the operation completes.
+  virtual int CalculateSizeOfEntriesBetween(
+      base::Time initial_time,
+      base::Time end_time,
       const CompletionCallback& callback) = 0;

[gavinp, 2017/01/12 16:07:35]

Does this method need to return a callback? Why not insist on it always being
synchronous?

The big question here is, if we make it synchronous, how do we handle the case
of the simple cache index not being ready. Typically that's not a long wait, but
it can be relatively long (check out the UMA on this if you're curious; index
rebuilds can be brutal here)...

Returning with an error then falling back to item-by-item is pretty lame, since
the first step in item-by-item iteration is waiting for the index. So I guess
maybe this should be asynchronous. What do you think?

[dullweber, 2017/01/12 17:03:15]

The CalculateSizeOfAllEntries() method that just returns the value of an int
attribute is also asynchronous because it also has to wait for the index to be
ready. I use CalculateSizeOfAllEntries as a fallback if
CalculateSizeOfEntriesBetween returns ERR_NOT_IMPLEMENTED, so the caller of this
method would be asynchronous anyway. The integration of this code is already
finished in this CL: http://crrev.com/2626223002.
I don't think we would gain anything by making this method synchronous. 

[gavinp, 2017/01/12 20:38:35]

You've sold me. It's fine as it is.

 
   // Returns an iterator which will enumerate all entries of the cache in an