Add a cache counter for iOS.

The CacheCounter class in chrome/browser/browsing_data could not be
componentized (unlike other counters in components/browsing_data) because
of its usage of StoragePartitionHttpCacheDataRemover that has a dependency
on content/.

This CL implements a separate CacheCounter class for iOS with the same
functionality. The core of the implementation, a series of IO thread
callbacks, is delegated to the private IOThreadCacheCounter class that
mimics StoragePartitionHttpCacheDataRemover.

BUG=620317

Review-Url: https://codereview.chromium.org/2354643002
Cr-Commit-Position: refs/heads/master@{#420599}

ios/chrome/BUILD.gn

@@ -33,6 +33,7 @@ test("ios_chrome_unittests") {
   sources = [
     "app/application_delegate/memory_warning_helper_unittest.mm",
     "app/safe_mode_util_unittest.cc",
+    "browser/browsing_data/cache_counter_unittest.cc",
     "browser/chrome_url_util_unittest.mm",
     "browser/crash_loop_detection_util_unittest.mm",
     "browser/favicon/large_icon_cache_unittest.cc",
@@ -95,6 +96,7 @@ test("ios_chrome_unittests") {
     "//components/autofill/core/common:common",
     "//components/autofill/ios/browser:browser",
     "//components/bookmarks/test",
+    "//components/browsing_data/core",
     "//components/favicon_base",
     "//components/metrics",
     "//components/metrics:test_support",
@@ -117,6 +119,7 @@ test("ios_chrome_unittests") {
     "//ios/chrome/common",
     "//ios/chrome/test",
     "//ios/chrome/test:run_all_unittests",
+    "//ios/net",
     "//ios/public/provider/chrome/browser",
     "//ios/public/provider/chrome/browser:test_support",
     "//ios/testing:ocmock_support",

ios/chrome/browser/BUILD.gn

@@ -95,6 +95,8 @@ source_set("browser") {
     "browsing_data/browsing_data_counter_wrapper.h",
     "browsing_data/browsing_data_remover_helper.cc",
     "browsing_data/browsing_data_remover_helper.h",
+    "browsing_data/cache_counter.cc",
+    "browsing_data/cache_counter.h",
     "browsing_data/ios_browsing_data_counter_factory.cc",
     "browsing_data/ios_browsing_data_counter_factory.h",
     "browsing_data/ios_chrome_browsing_data_remover.h",

ios/chrome/browser/browsing_data/cache_counter.cc

+// Copyright 2016 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.
+
+#include "base/bind.h"
+#include "components/browsing_data/core/pref_names.h"
+#include "ios/chrome/browser/browsing_data/cache_counter.h"
+#include "ios/web/public/browser_state.h"
+#include "ios/web/public/web_thread.h"
+#include "net/base/completion_callback.h"
+#include "net/base/net_errors.h"
+#include "net/disk_cache/disk_cache.h"
+#include "net/http/http_cache.h"
+#include "net/http/http_transaction_factory.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+
+namespace {
+
+class IOThreadCacheCounter {
+ public:
+  IOThreadCacheCounter(
+      const scoped_refptr<net::URLRequestContextGetter>& context_getter,
+      const net::CompletionCallback& result_callback)
+      : next_step_(STEP_GET_BACKEND),
+        context_getter_(context_getter),
+        result_callback_(result_callback),
+        result_(0),
+        backend_(nullptr) {}
+
+  void Count() {
+    web::WebThread::PostTask(web::WebThread::IO, FROM_HERE,
+                             base::Bind(&IOThreadCacheCounter::CountInternal,
+                                        base::Unretained(this), net::OK));
+  }
+
+ private:
+  enum Step {
+    STEP_GET_BACKEND,  // Get the disk_cache::Backend instance.
+    STEP_COUNT,        // Run CalculateSizeOfAllEntries() on it.
+    STEP_CALLBACK,     // Respond on the UI thread.
+    STEP_DONE          // Calculation completed.
+  };
+
+  void CountInternal(int rv) {
+    DCHECK_CURRENTLY_ON(web::WebThread::IO);
+
+    while (rv != net::ERR_IO_PENDING && next_step_ != STEP_DONE) {
+      // In case of an error, skip to the last step.
+      if (rv < 0)
+        next_step_ = STEP_CALLBACK;
+
+      // Process the counting in three steps: STEP_GET_BACKEND -> STEP_COUNT ->
+      // -> STEP_CALLBACK.
+      switch (next_step_) {
+        case STEP_GET_BACKEND: {
+          next_step_ = STEP_COUNT;
+
+          net::HttpCache* http_cache = context_getter_->GetURLRequestContext()
+                                           ->http_transaction_factory()
+                                           ->GetCache();
+
+          rv = http_cache->GetBackend(
+              &backend_, base::Bind(&IOThreadCacheCounter::CountInternal,
+                                    base::Unretained(this)));
+          break;
+        }
+
+        case STEP_COUNT: {
+          next_step_ = STEP_CALLBACK;
+
+          DCHECK(backend_);
+          rv = backend_->CalculateSizeOfAllEntries(base::Bind(
+              &IOThreadCacheCounter::CountInternal, base::Unretained(this)));
+          break;
+        }
+
+        case STEP_CALLBACK: {
+          next_step_ = STEP_DONE;
+          result_ = rv;
+
+          web::WebThread::PostTask(
+              web::WebThread::UI, FROM_HERE,
+              base::Bind(&IOThreadCacheCounter::OnCountingFinished,
+                         base::Unretained(this)));
+
+          break;
+        }
+
+        case STEP_DONE: {
+          NOTREACHED();
+        }
+      }
+    }
+  }
+
+  void OnCountingFinished() {
+    DCHECK_CURRENTLY_ON(web::WebThread::UI);
+    result_callback_.Run(result_);
+    delete this;
+  }
+
+  Step next_step_;
+  scoped_refptr<net::URLRequestContextGetter> context_getter_;
+  net::CompletionCallback result_callback_;
+  int result_;
+  disk_cache::Backend* backend_;
+};
+
+}  // namespace
+
+CacheCounter::CacheCounter(web::BrowserState* browser_state)
+    : pending_(false), browser_state_(browser_state), weak_ptr_factory_(this) {}
+
+CacheCounter::~CacheCounter() {}
+
+const char* CacheCounter::GetPrefName() const {
+  return browsing_data::prefs::kDeleteCache;
+}
+
+void CacheCounter::Count() {
+  // TODO(msramek): disk_cache::Backend currently does not implement counting
+  // for subsets of cache, only for the entire cache. Thus, we ignore the time
+  // period setting and always request counting for the unbounded time interval.
+  // It is up to the UI to interpret the results for finite time intervals as
+  // upper estimates.
+  pending_ = true;
+
+  // IOThreadCacheCounter deletes itself when done.
+  (new IOThreadCacheCounter(browser_state_->GetRequestContext(),
+                            base::Bind(&CacheCounter::OnCacheSizeCalculated,
+                                       weak_ptr_factory_.GetWeakPtr())))
+      ->Count();
+}
+
+void CacheCounter::OnCacheSizeCalculated(int result_bytes) {
+  pending_ = false;
+
+  // A value less than 0 means a net error code.
+  if (result_bytes < 0)
+    return;
+
+  ReportResult(result_bytes);
+}

ios/chrome/browser/browsing_data/cache_counter.h

+// Copyright 2016 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.
+
+#ifndef IOS_CHROME_BROWSER_BROWSING_DATA_CACHE_COUNTER_H_
+#define IOS_CHROME_BROWSER_BROWSING_DATA_CACHE_COUNTER_H_
+
+#include "base/memory/weak_ptr.h"
+#include "components/browsing_data/core/counters/browsing_data_counter.h"
+
+namespace web {
+class BrowserState;
+}
+
+class CacheCounter : public browsing_data::BrowsingDataCounter {
+ public:
+  explicit CacheCounter(web::BrowserState* browser_state);
+  ~CacheCounter() override;
+
+  // Whether this counter awaits the calculation result callback.
+  // Used only for testing.
+  bool pending() { return pending_; }
+
+  // BrowsingDataCounter implementation.
+  const char* GetPrefName() const override;
+
+ private:
+  // BrowsingDataCounter implementation.
+  void Count() override;
+
+  void OnCacheSizeCalculated(int result_bytes);
+
+  bool pending_;
+
+  web::BrowserState* browser_state_;
+
+  base::WeakPtrFactory<CacheCounter> weak_ptr_factory_;
+};
+
+#endif  // IOS_CHROME_BROWSER_BROWSING_DATA_CACHE_COUNTER_H_

ios/chrome/browser/browsing_data/ios_browsing_data_counter_factory.cc

@@ -15,6 +15,7 @@
 #include "components/browsing_data/core/pref_names.h"
 #include "components/keyed_service/core/service_access_type.h"
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
+#include "ios/chrome/browser/browsing_data/cache_counter.h"
 #include "ios/chrome/browser/experimental_flags.h"
 #include "ios/chrome/browser/history/history_service_factory.h"
 #include "ios/chrome/browser/history/web_history_service_factory.h"
@@ -39,6 +40,9 @@ IOSBrowsingDataCounterFactory::GetForBrowserStateAndPref(
         IOSChromeProfileSyncServiceFactory::GetForBrowserState(browser_state));
   }
 
+  if (pref_name == browsing_data::prefs::kDeleteCache)
+    return base::MakeUnique<CacheCounter>(browser_state);
+
   if (pref_name == browsing_data::prefs::kDeletePasswords) {
     return base::MakeUnique<browsing_data::PasswordsCounter>(
         IOSChromePasswordStoreFactory::GetForBrowserState(