Refactor cache counting into a separate helper class

components/browsing_data/content/conditional_cache_counting_helper.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 COMPONENTS_BROWSING_DATA_CONTENT_CONDITIONAL_CACHE_COUNTING_HELPER_H_
+#define COMPONENTS_BROWSING_DATA_CONTENT_CONDITIONAL_CACHE_COUNTING_HELPER_H_
+
+#include <memory>
+
+#include "base/callback_forward.h"
+#include "net/base/net_errors.h"
+#include "net/disk_cache/disk_cache.h"

[msramek, 2016/12/15 15:58:51]

nit: unnecessary include

[dullweber, 2016/12/16 16:41:11]

The forward declaration of disk_cache::Backend is not needed but I need this
include for std::unique_ptr<disk_cache::Backend::Iterator>. (At least I think
that I can't forward declare an inner class?)

[msramek, 2016/12/20 01:02:59]

Acknowledged. I didn't notice that; yes, AFAIK you can't forward declare an
inner class.

+
+namespace content {
+class StoragePartition;
+}
+
+namespace disk_cache {
+class Backend;
+}
+
+namespace net {
+class URLRequestContextGetter;
+}
+
+namespace browsing_data {
+
+// Helper to count the size of the http cache data from a StoragePartition.
+class ConditionalCacheCountingHelper {
+ public:
+  // Returns the number bytes in the selected range.
+  typedef base::Callback<void(int64_t)> CacheCountCallback;
+
+  static ConditionalCacheCountingHelper* CreateForRange(
+      content::StoragePartition* storage_partition,
+      base::Time begin_time,
+      base::Time end_time);
+
+  // Count the cache entries according to the specified time range. Destroys
+  // this instance of ConditionalCacheCountingHelper when finished.
+  // The returned WeakPtr can be used to cancel the operation if necessary.
+  // Must be called on the UI thread!
+  //
+  // The |completion_callback| will be invoked when the operation completes.
+  base::WeakPtr<ConditionalCacheCountingHelper> CountAndDestroySelfWhenFinished(
+      const CacheCountCallback& result_callback);
+
+  // Cancel the currently counting process. The task on the IO thread will stop
+  // and the callback will return net::ERR_ABORTED.
+  void CancelCounting();
+
+  bool IsFinished();
+
+ private:
+  enum CacheState {
+    STATE_NONE,
+    STATE_CREATE_MAIN,
+    STATE_CREATE_MEDIA,
+    STATE_PROCESS_MAIN,
+    STATE_PROCESS_MEDIA,
+    STATE_DONE
+  };
+
+  friend class base::DeleteHelper<ConditionalCacheCountingHelper>;
+
+  ConditionalCacheCountingHelper(
+      base::Time begin_time,
+      base::Time end_time,
+      net::URLRequestContextGetter* main_context_getter,
+      net::URLRequestContextGetter* media_context_getter);
+  ~ConditionalCacheCountingHelper();
+
+  void Finished();
+
+  void CountHttpCacheOnIOThread();
+  void DoCountCache(int rv);
+
+  int CountEntries(disk_cache::Backend* backend);
+  void IterateOverEntries(int error);
+
+  // Stores the cache size computation result before it can be returned
+  // via a callback. This is either the sum of size of the the two cache
+  // backends, or an error code if the calculation failed.
+  int64_t calculation_result_;
+
+  CacheCountCallback result_callback_;
+  const base::Time begin_time_;
+  const base::Time end_time_;
+
+  // This flag is used to tell the IO thread to stop counting if the user
+  // called CancelCounting().
+  volatile bool is_cancelled_;
+  bool is_finished_;
+
+  const scoped_refptr<net::URLRequestContextGetter> main_context_getter_;
+  const scoped_refptr<net::URLRequestContextGetter> media_context_getter_;
+
+  int next_cache_state_;
+  disk_cache::Backend* cache_;
+
+  std::unique_ptr<disk_cache::Backend::Iterator> iterator_;
+  disk_cache::Entry* current_entry_;
+
+  base::WeakPtrFactory<ConditionalCacheCountingHelper> weak_ptr_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConditionalCacheCountingHelper);
+};
+
+}  // namespace browsing_data
+
+#endif  // COMPONENTS_BROWSING_DATA_CONTENT_CONDITIONAL_CACHE_COUNTING_HELPER_H_