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.
+  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 18 matching lines @@
 
   // Returns the time when this cache entry was last used.
   virtual base::Time GetLastUsed() const = 0;
 
   // Returns the time when this cache entry was last modified.
   virtual base::Time GetLastModified() const = 0;
 
   // Returns the size of the cache data with the given index.
   virtual int32 GetDataSize(int index) const = 0;
 
+  // Returns the total size of this entry, a sum of the cached data for each
+  // valid index.
+  virtual int GetEntrySize() const = 0;

[pasko, 2015/09/04 14:11:50]

I think it is a _bad_ interface to use for calculating overall size of the
cache.

This suggests that all entries in the cache should be opened one by one to get
the overall size. That can be very inefficient (it *is* inefficient in
simplecache compared to how SimpleIndex would do it).

Can we avoid exposing this and have only new interface in the backend exposed?

If a (deficient) backend can only calculate size by opening everything, it has a
way to talk to EntryImpl/whatever directly.

[msramek, 2015/09/04 16:56:47]

Makes sense. I removed GetEntrySize from everywhere except EntryImpl.

+
   // Copies cached data into the given buffer of length |buf_len|. Returns the
   // number of bytes read or a network error code. If this function returns
   // ERR_IO_PENDING, the completion callback will be called on the current
   // thread when the operation completes, and a reference to |buf| will be
   // retained until the callback is called. Note that as long as the function
   // does not complete immediately, the callback will always be invoked, even
   // after Close has been called; in other words, the caller may close this
   // entry without having to wait for all the callbacks, and still rely on the
   // cleanup performed from the callback code.
   virtual int ReadData(int index, int offset, IOBuffer* buf, int buf_len,
@@ skipping 122 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_