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

net/disk_cache/disk_cache.h

 // 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.
 
 // Defines the public interface of the disk cache. For more details see
 // http://dev.chromium.org/developers/design-documents/network-stack/disk-cache
 
 #ifndef NET_DISK_CACHE_DISK_CACHE_H_
 #define NET_DISK_CACHE_DISK_CACHE_H_
 
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_split.h"
 #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 {
 class FilePath;
 class SingleThreadTaskRunner;
 }
 
 namespace net {
 class IOBuffer;
 class NetLog;
@@ skipping 110 matching lines @@
   // Marks all entries accessed since |initial_time| for deletion. The return
   // value is a net error code. If this method returns ERR_IO_PENDING, the
   // |callback| will be invoked when the operation completes.
   // Entries with |initial_time| <= access time are deleted.
   virtual int DoomEntriesSince(base::Time initial_time,
                                const CompletionCallback& callback) = 0;
 
   // 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
   // undefined order.
   virtual std::unique_ptr<Iterator> CreateIterator() = 0;
 
   // Return a list of cache statistics.
   virtual void GetStats(base::StringPairs* stats) = 0;
 
   // Called whenever an external cache in the system reuses the resource
   // referred to by |key|.
@@ skipping 167 matching lines @@
     entry->Close();
   }
 };
 
 // Automatically closes an entry when it goes out of scope.
 typedef std::unique_ptr<Entry, EntryDeleter> ScopedEntryPtr;
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H_