Reduce BrowsingDataRemover's dependencies on Chrome

chrome/browser/browsing_data/browsing_data_remover.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 <map>
 #include <set>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/browsing_data/browsing_data_filter_builder.h"
 #include "chrome/browser/browsing_data/browsing_data_helper.h"
 #include "chrome/browser/browsing_data/browsing_data_remover_delegate.h"
 #include "chrome/browser/browsing_data/registrable_domain_filter_builder.h"
-#include "chrome/browser/download/download_prefs.h"
-#include "chrome/browser/io_thread.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/browsing_data/content/storage_partition_http_cache_data_remover.h"
 #include "components/prefs/pref_service.h"
 #include "components/web_cache/browser/web_cache_manager.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/download_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/plugin_data_remover.h"
 #include "content/public/browser/ssl_host_state_delegate.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/user_metrics.h"
 #include "extensions/features/features.h"
 #include "media/media_features.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_store.h"
@@ skipping 110 matching lines @@
                     weak_ptr_factory_.GetWeakPtr());
 }
 
 void BrowsingDataRemover::SubTask::CompletionCallback() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(is_pending_);
   is_pending_ = false;
   forward_callback_.Run();
 }
 
-bool BrowsingDataRemover::TimeRange::operator==(
-    const BrowsingDataRemover::TimeRange& other) const {
-  return begin == other.begin && end == other.end;
-}
-
-// static
-BrowsingDataRemover::TimeRange BrowsingDataRemover::Unbounded() {
-  return TimeRange(base::Time(), base::Time::Max());
-}
-
-// static
-BrowsingDataRemover::TimeRange BrowsingDataRemover::Period(
-    browsing_data::TimePeriod period) {
-  switch (period) {
-    case browsing_data::LAST_HOUR:
-      content::RecordAction(UserMetricsAction("ClearBrowsingData_LastHour"));
-      break;
-    case browsing_data::LAST_DAY:
-      content::RecordAction(UserMetricsAction("ClearBrowsingData_LastDay"));
-      break;
-    case browsing_data::LAST_WEEK:
-      content::RecordAction(UserMetricsAction("ClearBrowsingData_LastWeek"));
-      break;
-    case browsing_data::FOUR_WEEKS:
-      content::RecordAction(UserMetricsAction("ClearBrowsingData_LastMonth"));
-      break;
-    case browsing_data::ALL_TIME:
-      content::RecordAction(UserMetricsAction("ClearBrowsingData_Everything"));
-      break;
-  }
-  return TimeRange(CalculateBeginDeleteTime(period), base::Time::Max());
-}
-
 BrowsingDataRemover::BrowsingDataRemover(
     content::BrowserContext* browser_context)
-    : profile_(Profile::FromBrowserContext(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(profile_)),
+      flash_lso_helper_(BrowsingDataFlashLSOHelper::Create(browser_context_)),
 #endif
       sub_task_forward_callback_(
           base::Bind(&BrowsingDataRemover::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);
+  DCHECK(browser_context_);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   if (!task_queue_.empty()) {
     VLOG(1) << "BrowsingDataRemover 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() {
   embedder_delegate_.reset();
 }
 
 void BrowsingDataRemover::SetRemoving(bool is_removing) {
   DCHECK_NE(is_removing_, is_removing);
   is_removing_ = is_removing;
 }
 
-void BrowsingDataRemover::Remove(const TimeRange& time_range,
+void BrowsingDataRemover::Remove(const base::Time& delete_begin,
+                                 const base::Time& delete_end,
                                  int remove_mask,
                                  int origin_type_mask) {
-  RemoveInternal(time_range, remove_mask, origin_type_mask,
+  RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::unique_ptr<RegistrableDomainFilterBuilder>(), nullptr);
 }
 
 void BrowsingDataRemover::RemoveAndReply(
-    const TimeRange& time_range,
+    const base::Time& delete_begin,
+    const base::Time& delete_end,
     int remove_mask,
     int origin_type_mask,
     Observer* observer) {
   DCHECK(observer);
-  RemoveInternal(time_range, remove_mask, origin_type_mask,
+  RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::unique_ptr<RegistrableDomainFilterBuilder>(), observer);
 }
 
 void BrowsingDataRemover::RemoveWithFilter(
-    const TimeRange& time_range,
+    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(time_range, remove_mask, origin_type_mask,
+  RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::move(filter_builder), nullptr);
 }
 
 void BrowsingDataRemover::RemoveWithFilterAndReply(
-    const TimeRange& time_range,
+    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(time_range, remove_mask, origin_type_mask,
+  RemoveInternal(delete_begin, delete_end, remove_mask, origin_type_mask,
                  std::move(filter_builder), observer);
 }
 
 void BrowsingDataRemover::RemoveInternal(
-    const TimeRange& time_range,
+    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.";
 
   // Remove() and RemoveAndReply() pass a null pointer to indicate no filter.
   // No filter is equivalent to one that |IsEmptyBlacklist()|.
   if (!filter_builder) {
     filter_builder = base::MakeUnique<RegistrableDomainFilterBuilder>(
         RegistrableDomainFilterBuilder::BLACKLIST);
     DCHECK(filter_builder->IsEmptyBlacklist());
   }
 
   task_queue_.emplace(
-      time_range,
+      delete_begin,
+      delete_end,
       remove_mask,
       origin_type_mask,
       std::move(filter_builder),
       observer);
 
   // 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() {
   DCHECK(!task_queue_.empty());
   const RemovalTask& removal_task = task_queue_.front();
 
-  RemoveImpl(removal_task.time_range,
+  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(
-    const TimeRange& time_range,
+    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|.
   // 2. Add a comment explaining why is it acceptable in your case to delete all
   //    data without filtering URLs / origins / domains.
   // 3. Do not support partial deletion, i.e. only delete your data if
   //    |filter_builder.IsEmptyBlacklist()|. Add a comment explaining why this
   //    is acceptable.
   synchronous_clear_operations_.Start();
 
   // crbug.com/140910: Many places were calling this with base::Time() as
   // delete_end, even though they should've used base::Time::Max().
-  DCHECK_NE(base::Time(), time_range.end);
+  DCHECK_NE(base::Time(), delete_end);
 
-  delete_begin_ = time_range.begin;
-  delete_end_ = time_range.end;
+  delete_begin_ = delete_begin;
+  delete_end_ = delete_end;
   remove_mask_ = remove_mask;
   origin_type_mask_ = origin_type_mask;
 
   if (origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_MaskContainsUnprotectedWeb"));
   }
   if (origin_type_mask_ & BrowsingDataHelper::PROTECTED_WEB) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_MaskContainsProtectedWeb"));
@@ skipping 19 matching lines @@
   } else if (remove_mask & REMOVE_CACHE) {
     choice = ONLY_CACHE;
   }
 
   UMA_HISTOGRAM_ENUMERATION(
       "History.ClearBrowsingData.UserDeletedCookieOrCache",
       choice, MAX_CHOICE_VALUE);
 
   // Managed devices and supervised users can have restrictions on history
   // deletion.
-  PrefService* prefs = profile_->GetPrefs();
-  bool may_delete_history = prefs->GetBoolean(
-      prefs::kAllowDeletingBrowserHistory);
+  // TODO(crbug.com/668114): This should be provided via ContentBrowserClient
+  // once BrowsingDataRemover 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.
   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
     // include origins that the user has visited, so it must be cleared.
     // TODO(msramek): We can reuse the plugin filter here, since both plugins
     // and SSL host state are scoped to hosts and represent them as std::string.
     // Rename the method to indicate its more general usage.
-    if (profile_->GetSSLHostStateDelegate()) {
-      profile_->GetSSLHostStateDelegate()->Clear(
+    if (browser_context_->GetSSLHostStateDelegate()) {
+      browser_context_->GetSSLHostStateDelegate()->Clear(
           filter_builder.IsEmptyBlacklist()
               ? base::Callback<bool(const std::string&)>()
               : filter_builder.BuildPluginFilter());
     }
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // REMOVE_DOWNLOADS
   if ((remove_mask & REMOVE_DOWNLOADS) && may_delete_history) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Downloads"));
     content::DownloadManager* download_manager =
-        BrowserContext::GetDownloadManager(profile_);
+        BrowserContext::GetDownloadManager(browser_context_);
     download_manager->RemoveDownloadsByURLAndTime(filter,
                                                   delete_begin_, delete_end_);
-    DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
-        download_manager);
-    download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // REMOVE_CHANNEL_IDS
   // Channel IDs are not separated for protected and unprotected web
   // origins. We check the origin_type_mask_ to prevent unintended deletion.
   if (remove_mask & REMOVE_CHANNEL_IDS &&
       origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_ChannelIDs"));
     // Since we are running on the UI thread don't call GetURLRequestContext().
     scoped_refptr<net::URLRequestContextGetter> rq_context =
-        content::BrowserContext::GetDefaultStoragePartition(profile_)->
+        content::BrowserContext::GetDefaultStoragePartition(browser_context_)->
           GetURLRequestContext();
     clear_channel_ids_.Start();
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ClearChannelIDsOnIOThread,
                    filter_builder.BuildChannelIDFilter(),
                    delete_begin_, delete_end_, std::move(rq_context),
                    clear_channel_ids_.GetCompletionCallback()));
   }
 
@@ skipping 45 matching lines @@
   // Flash (which are deleted father down in this method).
   if (remove_mask & REMOVE_MEDIA_LICENSES) {
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_PLUGIN_PRIVATE_DATA;
   }
 
   if (storage_partition_remove_mask) {
     clear_storage_partition_data_.Start();
 
     content::StoragePartition* storage_partition;
-    if (storage_partition_for_testing_)
+    if (storage_partition_for_testing_) {
       storage_partition = storage_partition_for_testing_;
-    else
-      storage_partition = BrowserContext::GetDefaultStoragePartition(profile_);
+    } else {
+      storage_partition =
+          BrowserContext::GetDefaultStoragePartition(browser_context_);
+    }
 
     uint32_t quota_storage_remove_mask =
         ~content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
 
     if (delete_begin_ == base::Time() ||
         origin_type_mask_ &
           (BrowsingDataHelper::PROTECTED_WEB | BrowsingDataHelper::EXTENSION)) {
       // If we're deleting since the beginning of time, or we're removing
       // protected origins, then remove persistent quota data.
       quota_storage_remove_mask |=
@@ skipping 21 matching lines @@
 #if BUILDFLAG(ENABLE_PLUGINS)
   // Plugin is data not separated for protected and unprotected web origins. We
   // check the origin_type_mask_ to prevent unintended deletion.
   if (remove_mask & REMOVE_PLUGIN_DATA &&
       origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_LSOData"));
     clear_plugin_data_count_ = 1;
 
     if (filter_builder.IsEmptyBlacklist()) {
       DCHECK(!plugin_data_remover_);
-      plugin_data_remover_.reset(content::PluginDataRemover::Create(profile_));
+      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,
                      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.
@@ skipping 10 matching lines @@
   if (remove_mask & REMOVE_CACHE) {
     // Tell the renderers to clear their cache.
     web_cache::WebCacheManager::GetInstance()->ClearCache();
 
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Cache"));
 
     clear_cache_.Start();
     // StoragePartitionHttpCacheDataRemover deletes itself when it is done.
     if (filter_builder.IsEmptyBlacklist()) {
       browsing_data::StoragePartitionHttpCacheDataRemover::CreateForRange(
-          BrowserContext::GetDefaultStoragePartition(profile_),
+          BrowserContext::GetDefaultStoragePartition(browser_context_),
           delete_begin_, delete_end_)
           ->Remove(clear_cache_.GetCompletionCallback());
     } else {
       browsing_data::StoragePartitionHttpCacheDataRemover::
           CreateForURLsAndRange(
-              BrowserContext::GetDefaultStoragePartition(profile_),
+              BrowserContext::GetDefaultStoragePartition(browser_context_),
               filter, delete_begin_, delete_end_)
               ->Remove(clear_cache_.GetCompletionCallback());
     }
 
     // Tell the shader disk cache to clear.
     content::RecordAction(UserMetricsAction("ClearBrowsingData_ShaderCache"));
     storage_partition_remove_mask |=
         content::StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Auth cache.
   if (remove_mask & REMOVE_COOKIES || remove_mask & REMOVE_PASSWORDS) {
     scoped_refptr<net::URLRequestContextGetter> request_context =
-        profile_->GetRequestContext();
+        BrowserContext::GetDefaultStoragePartition(browser_context_)
+            ->GetURLRequestContext();
     clear_http_auth_cache_.Start();
     BrowserThread::PostTaskAndReply(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&ClearHttpAuthCacheOnIOThread, std::move(request_context),
                    delete_begin_),
         clear_http_auth_cache_.GetCompletionCallback());
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Embedder data.
@@ skipping 42 matching lines @@
 
 int BrowsingDataRemover::GetLastUsedRemovalMask() {
   return remove_mask_;
 }
 
 int BrowsingDataRemover::GetLastUsedOriginTypeMask() {
   return origin_type_mask_;
 }
 
 BrowsingDataRemover::RemovalTask::RemovalTask(
-    const TimeRange& time_range,
+    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)
-    : time_range(time_range),
+    : 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() {}
 
 bool BrowsingDataRemover::AllDone() {
   return !synchronous_clear_operations_.is_pending() &&
          !clear_embedder_data_.is_pending() &&
@@ skipping 94 matching lines @@
   }
 
   NotifyIfDone();
 }
 
 void BrowsingDataRemover::OnFlashDataDeleted() {
   clear_plugin_data_count_--;
   NotifyIfDone();
 }
 #endif