Move BrowsingDataRemover to content/

chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.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 "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
 
 #include <set>
 #include <string>
 #include <utility>
 
@@ skipping 316 matching lines @@
 #endif
       clear_auto_sign_in_(sub_task_forward_callback_),
 #if BUILDFLAG(ENABLE_PLUGINS)
       flash_lso_helper_(BrowsingDataFlashLSOHelper::Create(browser_context)),
 #endif
 #if defined(OS_ANDROID)
       webapp_registry_(new WebappRegistry()),
 #endif
       weak_ptr_factory_(this) {}
 
-ChromeBrowsingDataRemoverDelegate::~ChromeBrowsingDataRemoverDelegate() {
+ChromeBrowsingDataRemoverDelegate::~ChromeBrowsingDataRemoverDelegate() {}
+
+void ChromeBrowsingDataRemoverDelegate::Shutdown() {
   history_task_tracker_.TryCancelAll();
   template_url_sub_.reset();
 }
 
-BrowsingDataRemoverDelegate::EmbedderOriginTypeMatcher
+content::BrowsingDataRemoverDelegate::EmbedderOriginTypeMatcher
 ChromeBrowsingDataRemoverDelegate::GetOriginTypeMatcher() const {
-  return base::Bind(DoesOriginMatchEmbedderMask);
+  return base::Bind(&DoesOriginMatchEmbedderMask);
+}
+
+bool ChromeBrowsingDataRemoverDelegate::MayRemoveDownloadHistory() const {
+  return profile_->GetPrefs()->GetBoolean(prefs::kAllowDeletingBrowserHistory);
 }
 
 void ChromeBrowsingDataRemoverDelegate::RemoveEmbedderData(
     const base::Time& delete_begin,
     const base::Time& delete_end,
     int remove_mask,
     const BrowsingDataFilterBuilder& filter_builder,
     int origin_type_mask,
     const base::Closure& callback) {
   DCHECK(((remove_mask & ~FILTERABLE_DATA_TYPES) == 0) ||
          filter_builder.IsEmptyBlacklist());
 
   // Embedder-defined DOM-accessible storage currently contains only
   // one datatype, which is the durable storage permission.
-  if (remove_mask & BrowsingDataRemover::DATA_TYPE_EMBEDDER_DOM_STORAGE) {
+  if (remove_mask &
+      content::BrowsingDataRemover::DATA_TYPE_EMBEDDER_DOM_STORAGE) {
     remove_mask |= DATA_TYPE_DURABLE_PERMISSION;
   }
 
-  if (origin_type_mask & BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB) {
+  if (origin_type_mask &
+      content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB) {
     base::RecordAction(
         UserMetricsAction("ClearBrowsingData_MaskContainsUnprotectedWeb"));
   }
-  if (origin_type_mask & BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB) {
+  if (origin_type_mask &
+      content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB) {
     base::RecordAction(
         UserMetricsAction("ClearBrowsingData_MaskContainsProtectedWeb"));
   }
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   if (origin_type_mask & ORIGIN_TYPE_EXTENSION) {
     base::RecordAction(
         UserMetricsAction("ClearBrowsingData_MaskContainsExtension"));
   }
 #endif
   // If this fires, we added a new BrowsingDataHelper::OriginTypeMask without
   // updating the user metrics above.
   static_assert(
-      ALL_ORIGIN_TYPES == (BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
+      ALL_ORIGIN_TYPES ==
+          (content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB |
 #if BUILDFLAG(ENABLE_EXTENSIONS)
-                           ORIGIN_TYPE_EXTENSION |
+           ORIGIN_TYPE_EXTENSION |
 #endif
-                           BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB),
+           content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB),
       "OriginTypeMask has been updated without updating user metrics");
 
   //////////////////////////////////////////////////////////////////////////////
   // INITIALIZATION
   synchronous_clear_operations_.Start();
   callback_ = callback;
 
   delete_begin_ = delete_begin;
   delete_end_ = delete_end;
 
   base::Callback<bool(const GURL& url)> filter =
       filter_builder.BuildGeneralFilter();
 
   // Some backends support a filter that |is_null()| to make complete deletion
   // more efficient.
   base::Callback<bool(const GURL&)> nullable_filter =
       filter_builder.IsEmptyBlacklist() ? base::Callback<bool(const GURL&)>()
                                         : filter;
 
   // Managed devices and supervised users can have restrictions on history
   // deletion.
   PrefService* prefs = profile_->GetPrefs();
   bool may_delete_history = prefs->GetBoolean(
       prefs::kAllowDeletingBrowserHistory);
 
   // 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 & BrowsingDataRemover::DATA_TYPE_NO_CHECKS) ||
+         (remove_mask & content::BrowsingDataRemover::DATA_TYPE_NO_CHECKS) ||
          (!(remove_mask & DATA_TYPE_HISTORY) &&
-          !(remove_mask & BrowsingDataRemover::DATA_TYPE_DOWNLOADS)));
+          !(remove_mask & content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS)));
 
   //////////////////////////////////////////////////////////////////////////////
   // DATA_TYPE_HISTORY
   if ((remove_mask & DATA_TYPE_HISTORY) && may_delete_history) {
     history::HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
     if (history_service) {
       // TODO(dmurph): Support all backends with filter (crbug.com/113621).
       base::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
@@ skipping 210 matching lines @@
     if (profile_->GetSSLHostStateDelegate()) {
       profile_->GetSSLHostStateDelegate()->Clear(
           filter_builder.IsEmptyBlacklist()
               ? base::Callback<bool(const std::string&)>()
               : filter_builder.BuildPluginFilter());
     }
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // DATA_TYPE_DOWNLOADS
-  if ((remove_mask & BrowsingDataRemover::DATA_TYPE_DOWNLOADS) &&
+  if ((remove_mask & content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS) &&
       may_delete_history) {
     DownloadPrefs* download_prefs = DownloadPrefs::FromDownloadManager(
         BrowserContext::GetDownloadManager(profile_));
     download_prefs->SetSaveFilePath(download_prefs->DownloadPath());
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // DATA_TYPE_COOKIES
   // We ignore the DATA_TYPE_COOKIES request if UNPROTECTED_WEB is not set,
   // so that callers who request DATA_TYPE_SITE_DATA with PROTECTED_WEB
   // don't accidentally remove the cookies that are associated with the
   // UNPROTECTED_WEB origin. This is necessary because cookies are not separated
   // between UNPROTECTED_WEB and PROTECTED_WEB.
-  if (remove_mask & BrowsingDataRemover::DATA_TYPE_COOKIES &&
-      origin_type_mask & BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB) {
+  if ((remove_mask & content::BrowsingDataRemover::DATA_TYPE_COOKIES) &&
+      (origin_type_mask &
+       content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB)) {
     base::RecordAction(UserMetricsAction("ClearBrowsingData_Cookies"));
 
     // Clear the safebrowsing cookies only if time period is for "all time".  It
     // doesn't make sense to apply the time period of deleting in the last X
     // hours/days to the safebrowsing cookies since they aren't the result of
     // any user action.
     if (delete_begin_ == base::Time()) {
       safe_browsing::SafeBrowsingService* sb_service =
           g_browser_process->safe_browsing_service();
       if (sb_service) {
@@ skipping 74 matching lines @@
         BrowserContext::GetDefaultStoragePartition(profile_)
             ->GetURLRequestContext();
     clear_http_auth_cache_.Start();
     BrowserThread::PostTaskAndReply(
         BrowserThread::IO, FROM_HERE,
         base::BindOnce(&ClearHttpAuthCacheOnIOThread,
                        std::move(request_context), delete_begin_),
         clear_http_auth_cache_.GetCompletionCallback());
   }
 
-  if (remove_mask & BrowsingDataRemover::DATA_TYPE_COOKIES) {
+  if (remove_mask & content::BrowsingDataRemover::DATA_TYPE_COOKIES) {
     password_manager::PasswordStore* password_store =
         PasswordStoreFactory::GetForProfile(profile_,
                                             ServiceAccessType::EXPLICIT_ACCESS)
             .get();
 
     if (password_store) {
       clear_auto_sign_in_.Start();
       password_store->DisableAutoSignInForOrigins(
           filter, clear_auto_sign_in_.GetCompletionCallback());
     }
@@ skipping 35 matching lines @@
 
       autofill::PersonalDataManager* data_manager =
           autofill::PersonalDataManagerFactory::GetForProfile(profile_);
       if (data_manager)
         data_manager->Refresh();
     }
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // DATA_TYPE_CACHE
-  if (remove_mask & BrowsingDataRemover::DATA_TYPE_CACHE) {
+  if (remove_mask & content::BrowsingDataRemover::DATA_TYPE_CACHE) {
     // Tell the renderers to clear their cache.
     // TODO(crbug.com/668114): Renderer cache is a platform concept, and should
     // live in BrowsingDataRemoverImpl. However, WebCacheManager itself is
     // a component with dependency on content/browser. Untangle these
     // dependencies or reimplement the relevant part of WebCacheManager
     // in content/browser.
     web_cache::WebCacheManager::GetInstance()->ClearCache();
 
 #if !defined(DISABLE_NACL)
     clear_nacl_cache_.Start();
@@ skipping 43 matching lines @@
       // Network Quality Estimator (NQE) stores the quality (RTT, bandwidth
       // etc.) of different networks in prefs. The stored quality is not
       // broken down by URLs or timestamps, so clearing the cache should
       // completely clear the prefs.
       ui_nqe_service->ClearPrefs();
     }
 
 #if defined(OS_ANDROID)
     // For now we're considering offline pages as cache, so if we're removing
     // cache we should remove offline pages as well.
-    if ((remove_mask & BrowsingDataRemover::DATA_TYPE_CACHE)) {
+    if ((remove_mask & content::BrowsingDataRemover::DATA_TYPE_CACHE)) {
       clear_offline_page_data_.Start();
       offline_pages::OfflinePageModelFactory::GetForBrowserContext(profile_)
           ->DeleteCachedPagesByURLPredicate(
               filter,
               IgnoreArgument<offline_pages::OfflinePageModel::DeletePageResult>(
                   clear_offline_page_data_.GetCompletionCallback()));
     }
 #endif
   }
 
 //////////////////////////////////////////////////////////////////////////////
 // DATA_TYPE_PLUGINS
 // Plugins are known to //content and their bulk deletion is implemented in
 // PluginDataRemover. However, the filtered deletion uses
 // BrowsingDataFlashLSOHelper which (currently) has strong dependencies
 // on //chrome.
 // TODO(msramek): Investigate these dependencies and move the plugin deletion
 // to BrowsingDataRemoverImpl in //content. Note that code in //content
 // can simply take advantage of PluginDataRemover directly to delete plugin
 // data in bulk.
 #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 & DATA_TYPE_PLUGIN_DATA &&
-      origin_type_mask & BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB) {
+  if ((remove_mask & DATA_TYPE_PLUGIN_DATA) &&
+      (origin_type_mask &
+       content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB)) {
     base::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_));
       base::WaitableEvent* event =
           plugin_data_remover_->StartRemoving(delete_begin_);
 
       base::WaitableEventWatcher::EventCallback watcher_callback = base::Bind(
           &ChromeBrowsingDataRemoverDelegate::OnWaitableEventSignaled,
           weak_ptr_factory_.GetWeakPtr());
       watcher_.StartWatching(event, std::move(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(
           &ChromeBrowsingDataRemoverDelegate::OnSitesWithFlashDataFetched,
           weak_ptr_factory_.GetWeakPtr(),
           filter_builder.BuildPluginFilter()));
     }
   }
 #endif
 
   //////////////////////////////////////////////////////////////////////////////
   // DATA_TYPE_MEDIA_LICENSES
-  if (remove_mask & BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES) {
+  if (remove_mask & content::BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES) {
     // TODO(jrummell): This UMA should be renamed to indicate it is for Media
     // Licenses.
     base::RecordAction(UserMetricsAction("ClearBrowsingData_ContentLicenses"));
 
 #if BUILDFLAG(ENABLE_PLUGINS)
     clear_flash_content_licenses_.Start();
     if (!pepper_flash_settings_manager_.get()) {
       pepper_flash_settings_manager_.reset(
           new PepperFlashSettingsManager(this, profile_));
     }
@@ skipping 20 matching lines @@
                   weak_ptr_factory_.GetWeakPtr()));
     }
 #endif  // defined(OS_CHROMEOS)
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Zero suggest.
   // Remove omnibox zero-suggest cache results. Filtering is not supported.
   // This is not a problem, as deleting more data than necessary will just cause
   // another server round-trip; no data is actually lost.
-  if ((remove_mask & (BrowsingDataRemover::DATA_TYPE_CACHE |
-                      BrowsingDataRemover::DATA_TYPE_COOKIES))) {
+  if ((remove_mask & (content::BrowsingDataRemover::DATA_TYPE_CACHE |
+                      content::BrowsingDataRemover::DATA_TYPE_COOKIES))) {
     prefs->SetString(omnibox::kZeroSuggestCachedResults, std::string());
   }
 
   //////////////////////////////////////////////////////////////////////////////
   // Domain reliability service.
   if (remove_mask &
-      (BrowsingDataRemover::DATA_TYPE_COOKIES | DATA_TYPE_HISTORY)) {
+      (content::BrowsingDataRemover::DATA_TYPE_COOKIES | DATA_TYPE_HISTORY)) {
     domain_reliability::DomainReliabilityService* service =
       domain_reliability::DomainReliabilityServiceFactory::
           GetForBrowserContext(profile_);
     if (service) {
       domain_reliability::DomainReliabilityClearMode mode;
-      if (remove_mask & BrowsingDataRemover::DATA_TYPE_COOKIES)
+      if (remove_mask & content::BrowsingDataRemover::DATA_TYPE_COOKIES)
         mode = domain_reliability::CLEAR_CONTEXTS;
       else
         mode = domain_reliability::CLEAR_BEACONS;
 
       clear_domain_reliability_monitor_.Start();
       service->ClearBrowsingData(
           mode,
           filter,
           clear_domain_reliability_monitor_.GetCompletionCallback());
     }
@@ skipping 137 matching lines @@
 }
 
 void ChromeBrowsingDataRemoverDelegate::
 OnDeauthorizeFlashContentLicensesCompleted(
     uint32_t request_id,
     bool /* success */) {
   DCHECK_EQ(request_id, deauthorize_flash_content_licenses_request_id_);
   clear_flash_content_licenses_.GetCompletionCallback().Run();
 }
 #endif