Split BrowsingDataRemover into an abstract interface and implementation.

chrome/browser/browsing_data/browsing_data_remover_impl.cc

 // 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.
 
-#include "chrome/browser/browsing_data/browsing_data_remover.h"
+#include "chrome/browser/browsing_data/browsing_data_remover_impl.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 48 matching lines @@
   callback.Run();
 }
 
 // Another convenience method to turn a callback without arguments into one that
 // accepts (and ignores) a single argument.
 template <typename T>
 base::Callback<void(T)> IgnoreArgument(const base::Closure& callback) {
   return base::Bind(&IgnoreArgumentHelper<T>, callback);
 }
 
-// Helper to create callback for BrowsingDataRemover::DoesOriginMatchMask.
+// Helper to create callback for BrowsingDataRemoverImpl::DoesOriginMatchMask.
 bool DoesOriginMatchMaskAndUrls(
     int origin_type_mask,
     const base::Callback<bool(const GURL&)>& predicate,
     const GURL& origin,
     storage::SpecialStoragePolicy* special_storage_policy) {
   return predicate.Run(origin) &&
          BrowsingDataHelper::DoesOriginMatchMask(origin, origin_type_mask,
                                                  special_storage_policy);
 }
 
@@ skipping 35 matching lines @@
   net::ChannelIDService* channel_id_service =
       rq_context->GetURLRequestContext()->channel_id_service();
   channel_id_service->GetChannelIDStore()->DeleteForDomainsCreatedBetween(
       domain_predicate, delete_begin, delete_end,
       base::Bind(&OnClearedChannelIDsOnIOThread,
                  base::RetainedRef(std::move(rq_context)), callback));
 }
 
 }  // namespace
 
-BrowsingDataRemover::CompletionInhibitor*
-    BrowsingDataRemover::completion_inhibitor_ = nullptr;
+BrowsingDataRemoverImpl::CompletionInhibitor*
+    BrowsingDataRemoverImpl::completion_inhibitor_ = nullptr;
 
-BrowsingDataRemover::SubTask::SubTask(const base::Closure& forward_callback)
+BrowsingDataRemoverImpl::SubTask::SubTask(const base::Closure& forward_callback)
     : is_pending_(false),
       forward_callback_(forward_callback),
       weak_ptr_factory_(this) {
   DCHECK(!forward_callback_.is_null());
 }
 
-BrowsingDataRemover::SubTask::~SubTask() {}
+BrowsingDataRemoverImpl::SubTask::~SubTask() {}
 
-void BrowsingDataRemover::SubTask::Start() {
+void BrowsingDataRemoverImpl::SubTask::Start() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(!is_pending_);
   is_pending_ = true;
 }
 
-base::Closure BrowsingDataRemover::SubTask::GetCompletionCallback() {
-  return base::Bind(&BrowsingDataRemover::SubTask::CompletionCallback,
+base::Closure BrowsingDataRemoverImpl::SubTask::GetCompletionCallback() {
+  return base::Bind(&BrowsingDataRemoverImpl::SubTask::CompletionCallback,
                     weak_ptr_factory_.GetWeakPtr());
 }
 
-void BrowsingDataRemover::SubTask::CompletionCallback() {
+void BrowsingDataRemoverImpl::SubTask::CompletionCallback() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(is_pending_);
   is_pending_ = false;
   forward_callback_.Run();
 }
 
-BrowsingDataRemover::BrowsingDataRemover(
+BrowsingDataRemoverImpl::BrowsingDataRemoverImpl(
     content::BrowserContext* browser_context)
     : browser_context_(browser_context),
       remove_mask_(-1),
       origin_type_mask_(-1),
       is_removing_(false),
 #if BUILDFLAG(ENABLE_PLUGINS)
       flash_lso_helper_(BrowsingDataFlashLSOHelper::Create(browser_context_)),
 #endif
       sub_task_forward_callback_(
-          base::Bind(&BrowsingDataRemover::NotifyIfDone,
+          base::Bind(&BrowsingDataRemoverImpl::NotifyIfDone,
                      base::Unretained(this))),
       synchronous_clear_operations_(sub_task_forward_callback_),
       clear_embedder_data_(sub_task_forward_callback_),
       clear_cache_(sub_task_forward_callback_),
       clear_channel_ids_(sub_task_forward_callback_),
       clear_http_auth_cache_(sub_task_forward_callback_),
       clear_storage_partition_data_(sub_task_forward_callback_),
       weak_ptr_factory_(this) {
   DCHECK(browser_context_);
 }
 
-BrowsingDataRemover::~BrowsingDataRemover() {
+BrowsingDataRemoverImpl::~BrowsingDataRemoverImpl() {
   if (!task_queue_.empty()) {
-    VLOG(1) << "BrowsingDataRemover shuts down with " << task_queue_.size()
+    VLOG(1) << "BrowsingDataRemoverImpl shuts down with " << task_queue_.size()
             << " pending tasks";
   }
 
   // If we are still removing data, notify observers that their task has been
   // (albeit unsucessfuly) processed, so they can unregister themselves.
   // TODO(bauerb): If it becomes a problem that browsing data might not actually
   // be fully cleared when an observer is notified, add a success flag.
   while (!task_queue_.empty()) {
     if (observer_list_.HasObserver(task_queue_.front().observer))
       task_queue_.front().observer->OnBrowsingDataRemoverDone();
     task_queue_.pop();
   }
 }
 
-void BrowsingDataRemover::Shutdown() {
+void BrowsingDataRemoverImpl::Shutdown() {
   embedder_delegate_.reset();
 }
 
-void BrowsingDataRemover::SetRemoving(bool is_removing) {
+void BrowsingDataRemoverImpl::SetRemoving(bool is_removing) {
   DCHECK_NE(is_removing_, is_removing);
   is_removing_ = is_removing;
 }
 
-void BrowsingDataRemover::Remove(const base::Time& delete_begin,
+void BrowsingDataRemoverImpl::SetEmbedderDelegate(
+    std::unique_ptr<BrowsingDataRemoverDelegate> embedder_delegate) {
+  embedder_delegate_ = std::move(embedder_delegate);
+}
+
+BrowsingDataRemoverDelegate*
+BrowsingDataRemoverImpl::GetEmbedderDelegate() const {
+  return embedder_delegate_.get();
+}
+
+void BrowsingDataRemoverImpl::Remove(const base::Time& delete_begin,
                                  const base::Time& delete_end,
                                  int remove_mask,
                                  int origin_type_mask) {
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::unique_ptr<RegistrableDomainFilterBuilder>(), nullptr);
 }
 
-void BrowsingDataRemover::RemoveAndReply(
+void BrowsingDataRemoverImpl::RemoveAndReply(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     int remove_mask,
     int origin_type_mask,
     Observer* observer) {
   DCHECK(observer);
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::unique_ptr<RegistrableDomainFilterBuilder>(), observer);
 }
 
-void BrowsingDataRemover::RemoveWithFilter(
+void BrowsingDataRemoverImpl::RemoveWithFilter(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     int remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) {
   DCHECK_EQ(0, remove_mask & ~FILTERABLE_DATATYPES);
   DCHECK(filter_builder);
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::move(filter_builder), nullptr);
 }
 
-void BrowsingDataRemover::RemoveWithFilterAndReply(
+void BrowsingDataRemoverImpl::RemoveWithFilterAndReply(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     int remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer) {
   DCHECK_EQ(0, remove_mask & ~FILTERABLE_DATATYPES);
   DCHECK(filter_builder);
   DCHECK(observer);
   RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::move(filter_builder), observer);
 }
 
-void BrowsingDataRemover::RemoveInternal(
+void BrowsingDataRemoverImpl::RemoveInternal(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     int remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer) {
   DCHECK(!observer || observer_list_.HasObserver(observer))
       << "Every observer must register itself (by calling AddObserver()) "
       << "before observing a removal task.";
 
@@ skipping 15 matching lines @@
 
   // If this is the only scheduled task, execute it immediately. Otherwise,
   // it will be automatically executed when all tasks scheduled before it
   // finish.
   if (task_queue_.size() == 1) {
     SetRemoving(true);
     RunNextTask();
   }
 }
 
-void BrowsingDataRemover::RunNextTask() {
+void BrowsingDataRemoverImpl::RunNextTask() {
   DCHECK(!task_queue_.empty());
   const RemovalTask& removal_task = task_queue_.front();
 
   RemoveImpl(removal_task.delete_begin,
              removal_task.delete_end,
              removal_task.remove_mask,
              *removal_task.filter_builder,
              removal_task.origin_type_mask);
 }
 
-void BrowsingDataRemover::RemoveImpl(
+void BrowsingDataRemoverImpl::RemoveImpl(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     int remove_mask,
     const BrowsingDataFilterBuilder& filter_builder,
     int origin_type_mask) {
   // =============== README before adding more storage backends ===============
   //
   // If you're adding a data storage backend that is included among
   // RemoveDataMask::FILTERABLE_DATATYPES, you must do one of the following:
   // 1. Support one of the filters generated by |filter_builder|.
@@ skipping 43 matching lines @@
     choice = ONLY_CACHE;
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "History.ClearBrowsingData.UserDeletedCookieOrCache",
       choice, MAX_CHOICE_VALUE);
 
   // Managed devices and supervised users can have restrictions on history
   // deletion.
   // TODO(crbug.com/668114): This should be provided via ContentBrowserClient
-  // once BrowsingDataRemover moves to content.
+  // once BrowsingDataRemoverImpl moves to content.
   PrefService* prefs =
       Profile::FromBrowserContext(browser_context_)->GetPrefs();
   bool may_delete_history =
       prefs->GetBoolean(prefs::kAllowDeletingBrowserHistory);
 
-  // All the UI entry points into the BrowsingDataRemover should be disabled,
-  // but this will fire if something was missed or added.
+  // All the UI entry points into the BrowsingDataRemoverImpl should be
+  // disabled, but this will fire if something was missed or added.
   DCHECK(may_delete_history || (remove_mask & REMOVE_NOCHECKS) ||
       (!(remove_mask & REMOVE_HISTORY) && !(remove_mask & REMOVE_DOWNLOADS)));
 
   //////////////////////////////////////////////////////////////////////////////
   // INITIALIZATION
   base::Callback<bool(const GURL& url)> filter =
       filter_builder.BuildGeneralFilter();
 
   if ((remove_mask & REMOVE_HISTORY) && may_delete_history) {
     // The SSL Host State that tracks SSL interstitial "proceed" decisions may
@@ skipping 141 matching lines @@
     clear_plugin_data_count_ = 1;
 
     if (filter_builder.IsEmptyBlacklist()) {
       DCHECK(!plugin_data_remover_);
       plugin_data_remover_.reset(
           content::PluginDataRemover::Create(browser_context_));
       base::WaitableEvent* event =
           plugin_data_remover_->StartRemoving(delete_begin_);
 
       base::WaitableEventWatcher::EventCallback watcher_callback =
-          base::Bind(&BrowsingDataRemover::OnWaitableEventSignaled,
+          base::Bind(&BrowsingDataRemoverImpl::OnWaitableEventSignaled,
                      weak_ptr_factory_.GetWeakPtr());
       watcher_.StartWatching(event, watcher_callback);
     } else {
       // TODO(msramek): Store filters from the currently executed task on the
       // object to avoid having to copy them to callback methods.
       flash_lso_helper_->StartFetching(base::Bind(
-          &BrowsingDataRemover::OnSitesWithFlashDataFetched,
+          &BrowsingDataRemoverImpl::OnSitesWithFlashDataFetched,
           weak_ptr_factory_.GetWeakPtr(),
           filter_builder.BuildPluginFilter()));
     }
   }
 #endif
 
   //////////////////////////////////////////////////////////////////////////////
   // CACHE
   if (remove_mask & REMOVE_CACHE) {
     // Tell the renderers to clear their cache.
@@ skipping 46 matching lines @@
         remove_mask,
         filter_builder,
         origin_type_mask,
         clear_embedder_data_.GetCompletionCallback());
   }
 
   // Notify in case all actions taken were synchronous.
   synchronous_clear_operations_.GetCompletionCallback().Run();
 }
 
-void BrowsingDataRemover::AddObserver(Observer* observer) {
+void BrowsingDataRemoverImpl::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
 }
 
-void BrowsingDataRemover::RemoveObserver(Observer* observer) {
+void BrowsingDataRemoverImpl::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
-void BrowsingDataRemover::OverrideStoragePartitionForTesting(
+void BrowsingDataRemoverImpl::OverrideStoragePartitionForTesting(
     content::StoragePartition* storage_partition) {
   storage_partition_for_testing_ = storage_partition;
 }
 
 #if BUILDFLAG(ENABLE_PLUGINS)
-void BrowsingDataRemover::OverrideFlashLSOHelperForTesting(
+void BrowsingDataRemoverImpl::OverrideFlashLSOHelperForTesting(
     scoped_refptr<BrowsingDataFlashLSOHelper> flash_lso_helper) {
   flash_lso_helper_ = flash_lso_helper;
 }
 #endif
 
-const base::Time& BrowsingDataRemover::GetLastUsedBeginTime() {
+const base::Time& BrowsingDataRemoverImpl::GetLastUsedBeginTime() {
   return delete_begin_;
 }
 
-const base::Time& BrowsingDataRemover::GetLastUsedEndTime() {
+const base::Time& BrowsingDataRemoverImpl::GetLastUsedEndTime() {
   return delete_end_;
 }
 
-int BrowsingDataRemover::GetLastUsedRemovalMask() {
+int BrowsingDataRemoverImpl::GetLastUsedRemovalMask() {
   return remove_mask_;
 }
 
-int BrowsingDataRemover::GetLastUsedOriginTypeMask() {
+int BrowsingDataRemoverImpl::GetLastUsedOriginTypeMask() {
   return origin_type_mask_;
 }
 
-BrowsingDataRemover::RemovalTask::RemovalTask(
+BrowsingDataRemoverImpl::RemovalTask::RemovalTask(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     int remove_mask,
     int origin_type_mask,
     std::unique_ptr<BrowsingDataFilterBuilder> filter_builder,
     Observer* observer)
     : delete_begin(delete_begin),
       delete_end(delete_end),
       remove_mask(remove_mask),
       origin_type_mask(origin_type_mask),
       filter_builder(std::move(filter_builder)),
       observer(observer) {}
 
-BrowsingDataRemover::RemovalTask::~RemovalTask() {}
+BrowsingDataRemoverImpl::RemovalTask::~RemovalTask() {}
 
-bool BrowsingDataRemover::AllDone() {
+bool BrowsingDataRemoverImpl::AllDone() {
   return !synchronous_clear_operations_.is_pending() &&
          !clear_embedder_data_.is_pending() &&
          !clear_cache_.is_pending() &&
          !clear_channel_ids_.is_pending() &&
          !clear_http_auth_cache_.is_pending() &&
          !clear_storage_partition_data_.is_pending() &&
          !clear_plugin_data_count_;
 }
 
-void BrowsingDataRemover::Notify() {
+void BrowsingDataRemoverImpl::Notify() {
   // Some tests call |RemoveImpl| directly, without using the task scheduler.
   // TODO(msramek): Improve those tests so we don't have to do this. Tests
   // relying on |RemoveImpl| do so because they need to pass in
   // BrowsingDataFilterBuilder while still keeping ownership of it. Making
   // BrowsingDataFilterBuilder copyable would solve this.
   if (!is_removing_) {
     DCHECK(task_queue_.empty());
     return;
   }
 
@@ skipping 12 matching lines @@
     // All removal tasks have finished. Inform the observers that we're idle.
     SetRemoving(false);
     return;
   }
 
   // Yield to the UI thread before executing the next removal task.
   // TODO(msramek): Consider also adding a backoff if too many tasks
   // are scheduled.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      base::Bind(&BrowsingDataRemover::RunNextTask,
+      base::Bind(&BrowsingDataRemoverImpl::RunNextTask,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
-void BrowsingDataRemover::NotifyIfDone() {
+void BrowsingDataRemoverImpl::NotifyIfDone() {
   // TODO(brettw) http://crbug.com/305259: This should also observe session
   // clearing (what about other things such as passwords, etc.?) and wait for
   // them to complete before continuing.
 
   if (!AllDone())
     return;
 
   if (completion_inhibitor_) {
     completion_inhibitor_->OnBrowsingDataRemoverWouldComplete(
-        this, base::Bind(&BrowsingDataRemover::Notify,
+        this, base::Bind(&BrowsingDataRemoverImpl::Notify,
                          weak_ptr_factory_.GetWeakPtr()));
     return;
   }
 
   Notify();
 }
 
 #if BUILDFLAG(ENABLE_PLUGINS)
-void BrowsingDataRemover::OnWaitableEventSignaled(
+void BrowsingDataRemoverImpl::OnWaitableEventSignaled(
     base::WaitableEvent* waitable_event) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   DCHECK_EQ(1, clear_plugin_data_count_);
   clear_plugin_data_count_ = 0;
 
   plugin_data_remover_.reset();
   watcher_.StopWatching();
   NotifyIfDone();
 }
 
-void BrowsingDataRemover::OnSitesWithFlashDataFetched(
+void BrowsingDataRemoverImpl::OnSitesWithFlashDataFetched(
     base::Callback<bool(const std::string&)> plugin_filter,
     const std::vector<std::string>& sites) {
   DCHECK_EQ(1, clear_plugin_data_count_);
   clear_plugin_data_count_ = 0;
 
   std::vector<std::string> sites_to_delete;
   for (const std::string& site : sites) {
     if (plugin_filter.Run(site))
       sites_to_delete.push_back(site);
   }
 
   clear_plugin_data_count_ = sites_to_delete.size();
 
   for (const std::string& site : sites_to_delete) {
     flash_lso_helper_->DeleteFlashLSOsForSite(
         site,
-        base::Bind(&BrowsingDataRemover::OnFlashDataDeleted,
+        base::Bind(&BrowsingDataRemoverImpl::OnFlashDataDeleted,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   NotifyIfDone();
 }
 
-void BrowsingDataRemover::OnFlashDataDeleted() {
+void BrowsingDataRemoverImpl::OnFlashDataDeleted() {
   clear_plugin_data_count_--;
   NotifyIfDone();
 }
 #endif