Add a size estimation mechanism to StoragePartitionHttpCacheDataRemover.

components/browsing_data/storage_partition_http_cache_data_remover.cc

Index: components/browsing_data/storage_partition_http_cache_data_remover.cc
diff --git a/components/browsing_data/storage_partition_http_cache_data_remover.cc b/components/browsing_data/storage_partition_http_cache_data_remover.cc
index c53c0be6409300347be7e76bc47cb98a9f1d1032..8115e489c4b3baaf5f24f5f151a35937158e8f3c 100644
--- a/components/browsing_data/storage_partition_http_cache_data_remover.cc
+++ b/components/browsing_data/storage_partition_http_cache_data_remover.cc
@@ -7,7 +7,10 @@
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "net/base/sdch_manager.h"
+#include "net/disk_cache/blockfile/backend_impl.h"
 #include "net/disk_cache/disk_cache.h"
+#include "net/disk_cache/memory/mem_backend_impl.h"
+#include "net/disk_cache/simple/simple_backend_impl.h"
 #include "net/http/http_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
@@ -26,7 +29,8 @@ StoragePartitionHttpCacheDataRemover::StoragePartitionHttpCacheDataRemover(
       main_context_getter_(main_context_getter),
       media_context_getter_(media_context_getter),
       next_cache_state_(STATE_NONE),
-      cache_(nullptr) {
+      cache_(nullptr),
+      calculation_result_(0) {
 }
 
 StoragePartitionHttpCacheDataRemover::~StoragePartitionHttpCacheDataRemover() {
@@ -56,6 +60,20 @@ void StoragePartitionHttpCacheDataRemover::Remove(
           base::Unretained(this)));
 }
 
+void StoragePartitionHttpCacheDataRemover::Count(
+    const net::Int64CompletionCallback& result_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  DCHECK(!result_callback.is_null());
+  result_callback_ = result_callback;
+  calculation_result_ = 0;
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &StoragePartitionHttpCacheDataRemover::CountHttpCacheOnIOThread,
+          base::Unretained(this)));
+}
+
 void StoragePartitionHttpCacheDataRemover::ClearHttpCacheOnIOThread() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   next_cache_state_ = STATE_NONE;
@@ -67,14 +85,31 @@ void StoragePartitionHttpCacheDataRemover::ClearHttpCacheOnIOThread() {
   DoClearCache(net::OK);
 }
 
+void StoragePartitionHttpCacheDataRemover::CountHttpCacheOnIOThread() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  next_cache_state_ = STATE_NONE;
+  DCHECK_EQ(STATE_NONE, next_cache_state_);
+  DCHECK(main_context_getter_.get());
+  DCHECK(media_context_getter_.get());
+
+  next_cache_state_ = STATE_CREATE_MAIN;
+  DoCountCache(net::OK);
+}
+
 void StoragePartitionHttpCacheDataRemover::ClearedHttpCache() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   done_callback_.Run();
   base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
+void StoragePartitionHttpCacheDataRemover::CountedHttpCache() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  result_callback_.Run(calculation_result_);
+  base::MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+}
+
 // The expected state sequence is STATE_NONE --> STATE_CREATE_MAIN -->
-// STATE_DELETE_MAIN --> STATE_CREATE_MEDIA --> STATE_DELETE_MEDIA -->
+// STATE_PROCESS_MAIN --> STATE_CREATE_MEDIA --> STATE_PROCESS_MEDIA -->
 // STATE_DONE, and any errors are ignored.
 void StoragePartitionHttpCacheDataRemover::DoClearCache(int rv) {
   DCHECK_NE(STATE_NONE, next_cache_state_);
@@ -93,8 +128,8 @@ void StoragePartitionHttpCacheDataRemover::DoClearCache(int rv) {
                                          ->GetCache();
 
         next_cache_state_ = (next_cache_state_ == STATE_CREATE_MAIN)
-                                ? STATE_DELETE_MAIN
-                                : STATE_DELETE_MEDIA;
+                                ? STATE_PROCESS_MAIN
+                                : STATE_PROCESS_MEDIA;
 
         // Clear QUIC server information from memory and the disk cache.
         http_cache->GetSession()
@@ -116,23 +151,24 @@ void StoragePartitionHttpCacheDataRemover::DoClearCache(int rv) {
                        base::Unretained(this)));
         break;
       }
-      case STATE_DELETE_MAIN:
-      case STATE_DELETE_MEDIA: {
-        next_cache_state_ = (next_cache_state_ == STATE_DELETE_MAIN)
+      case STATE_PROCESS_MAIN:
+      case STATE_PROCESS_MEDIA: {
+        next_cache_state_ = (next_cache_state_ == STATE_PROCESS_MAIN)
                                 ? STATE_CREATE_MEDIA
                                 : STATE_DONE;
 
         // |cache_| can be null if it cannot be initialized.
         if (cache_) {
-          if (delete_begin_.is_null()) {
-            rv = cache_->DoomAllEntries(
-                base::Bind(&StoragePartitionHttpCacheDataRemover::DoClearCache,
-                           base::Unretained(this)));
+          if (delete_begin_.is_null() && delete_end_.is_max()) {

[msramek, 2015/09/02 19:22:25]

I changed this to check both delete_begin_ and delete_end_. Previously the check
was only on begin, probably because there isn't an entry point that would
support setting delete_end_ != base::Time::Max().

However, I now use both time constraints in the tests.

+            rv = cache_->DoomAllEntries(base::Bind(
+                &StoragePartitionHttpCacheDataRemover::DoClearCache,
+                base::Unretained(this)));
           } else {
             rv = cache_->DoomEntriesBetween(
                 delete_begin_, delete_end_,
-                base::Bind(&StoragePartitionHttpCacheDataRemover::DoClearCache,
-                           base::Unretained(this)));
+                base::Bind(
+                    &StoragePartitionHttpCacheDataRemover::DoClearCache,
+                    base::Unretained(this)));
           }
           cache_ = NULL;
         }
@@ -158,4 +194,91 @@ void StoragePartitionHttpCacheDataRemover::DoClearCache(int rv) {
   }
 }
 
+// The expected state sequence is STATE_NONE --> STATE_CREATE_MAIN -->
+// STATE_PROCESS_MAIN --> STATE_CREATE_MEDIA --> STATE_PROCESS_MEDIA -->
+// STATE_DONE. On error, we jump directly to STATE_DONE.
+void StoragePartitionHttpCacheDataRemover::DoCountCache(int rv) {
+  DCHECK_NE(STATE_NONE, next_cache_state_);
+
+  while (rv != net::ERR_IO_PENDING && next_cache_state_ != STATE_NONE) {
+    // On error, finish and return the error code. A valid result value might
+    // be of two types - either net::OK from the CREATE states, or the result
+    // of calculation from the PROCESS states. Since net::OK == 0, it is valid
+    // to simply add the value to the final calculation result.
+    if (rv < 0) {
+      calculation_result_ = rv;
+      next_cache_state_ = STATE_DONE;
+    } else {
+      DCHECK_EQ(0, net::OK);
+      calculation_result_ += rv;
+    }
+
+    switch (next_cache_state_) {
+      case STATE_CREATE_MAIN:
+      case STATE_CREATE_MEDIA: {
+        // Get a pointer to the cache.
+        net::URLRequestContextGetter* getter =
+            (next_cache_state_ == STATE_CREATE_MAIN)
+                ? main_context_getter_.get()
+                : media_context_getter_.get();
+        net::HttpCache* http_cache = getter->GetURLRequestContext()
+                                         ->http_transaction_factory()
+                                         ->GetCache();
+
+        next_cache_state_ = (next_cache_state_ == STATE_CREATE_MAIN)
+                                ? STATE_PROCESS_MAIN
+                                : STATE_PROCESS_MEDIA;
+
+        rv = http_cache->GetBackend(
+            &cache_,
+            base::Bind(&StoragePartitionHttpCacheDataRemover::DoClearCache,
+                       base::Unretained(this)));
+        break;
+      }
+      case STATE_PROCESS_MAIN:
+      case STATE_PROCESS_MEDIA: {
+        next_cache_state_ = (next_cache_state_ == STATE_PROCESS_MAIN)
+                                ? STATE_CREATE_MEDIA
+                                : STATE_DONE;
+
+        // |cache_| can be null if it cannot be initialized.
+        if (cache_) {
+          if (delete_begin_.is_null() && delete_end_.is_max()) {
+            // TODO(msramek): Implement analogous |CalculateSizeOfAllEntries|.
+            rv = cache_->CalculateSizeOfEntriesBetween(
+                base::Time(), base::Time::Max(),
+                base::Bind(
+                    &StoragePartitionHttpCacheDataRemover::DoCountCache,
+                    base::Unretained(this)));
+          } else {
+            rv = cache_->CalculateSizeOfEntriesBetween(
+                delete_begin_, delete_end_,
+                base::Bind(
+                    &StoragePartitionHttpCacheDataRemover::DoCountCache,
+                    base::Unretained(this)));
+          }
+          cache_ = NULL;
+        }
+        break;
+      }
+      case STATE_DONE: {
+        cache_ = NULL;
+        next_cache_state_ = STATE_NONE;
+
+        // Notify the UI thread that we are done.
+        BrowserThread::PostTask(
+            BrowserThread::UI, FROM_HERE,
+            base::Bind(&StoragePartitionHttpCacheDataRemover::CountedHttpCache,
+                       base::Unretained(this)));
+        return;
+      }
+      default: {
+        NOTREACHED() << "bad state";
+        next_cache_state_ = STATE_NONE;  // Stop looping.
+        return;
+      }
+    }
+  }
+}
+
 }  // namespace browsing_data