Add a size estimation mechanism to StoragePartitionHttpCacheDataRemover.

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_
 
@@ skipping 127 matching lines @@
                                  base::Time end_time,
                                  const CompletionCallback& callback) = 0;
 
   // 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 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;
 
   // 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|.
   virtual void OnExternalCacheHit(const std::string& key) = 0;
@@ skipping 160 matching lines @@
     entry->Close();
   }
 };
 
 // Automatically closes an entry when it goes out of scope.
 typedef scoped_ptr<Entry, EntryDeleter> ScopedEntryPtr;
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_DISK_CACHE_H_