Add a size estimation mechanism to StoragePartitionHttpCacheDataRemover.

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 84c1ee99516654258486494a8afeacfb70ddc31d..e5faa8adf6488fcb50c5ee6ae80980e187d146de 100644
--- a/net/disk_cache/disk_cache.h
+++ b/net/disk_cache/disk_cache.h
@@ -145,6 +145,16 @@ class NET_EXPORT Backend {
   virtual int DoomEntriesSince(base::Time initial_time,
                                const CompletionCallback& callback) = 0;
 
+  // Calculate the total size of entries satisfying the condition
+  // |initial_time| <= access_time < |end_time|. The return value is the number
+  // of bytes written or a net error code. If this method returns
+  // ERR_IO_PENDING, the |callback| will be invoked when the operation
+  // completes.

[pasko, 2015/09/08 13:13:49]

Please also make it similar to DoomEntriesBetween with this portion of comment:
This supports unbounded time ranges in either direction by using null Time
values for either argument.

[msramek, 2015/09/08 18:32:22]

As explained in the other comment, this part is apparently not true. I suggest
omitting the part, as this method should actually not be used for unbounded
deletion at all.

[pasko, 2015/09/09 09:09:29]

opps, for simple_cache we certainly allow unbounded dooming. For
DoomAllEntries(...) the backend just calls DoomEntriesBetween(Time(), Time(),
...).

Where is the other comment you refer to? Can we clarify that for both functions
then? I am confused otherwise.

[msramek, 2015/09/09 09:20:42]

The comment is in Patchset 6, backend_impl.cc.

Interesting! In the Blockfile backend, DoomAllEntries simply purges the entire
cache, while DoomEntriesBetween goes element by element and tests the time
range.

In Simple backend, I assume that you implemented the semantics that (Time(),
Time()) means unbounded interval because the comment in disk_cache.h said so.

I would suggest to consolidate this to [base::Time(), base::Time::Max()). The
reasons are:

1. BrowsingDataRemover uses this to represent unbounded interval.
2. You can always do a simple check if begin_time < current_time < end_time
without any special cases.
3. It stays hidden from the caller anyway, because the caller should call
DoomAllEntries(). And how exactly this is passed to DoomEntriesBetween() is an
implementation detail.

+  virtual int CalculateSizeOfEntriesBetween(
+      base::Time initial_time,
+      base::Time end_time,
+      const CompletionCallback& callback) = 0;
+
   // Returns an iterator which will enumerate all entries of the cache in an
   // undefined order.
   virtual scoped_ptr<Iterator> CreateIterator() = 0;