Add removal filter support for Cookies, Storage, and Content Settings.

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>
 
@@ skipping 27 matching lines @@
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/browser/sessions/tab_restore_service_factory.h"
 #include "chrome/browser/web_data_service_factory.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/browser/webdata/autofill_webdata_service.h"
 #include "components/browsing_data/storage_partition_http_cache_data_remover.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
+#include "components/content_settings/core/common/content_settings.h"
+#include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_compression_stats.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_service.h"
 #include "components/data_reduction_proxy/core/browser/data_reduction_proxy_settings.h"
 #include "components/domain_reliability/service.h"
 #include "components/history/core/browser/history_service.h"
 #include "components/nacl/browser/nacl_browser.h"
 #include "components/nacl/browser/pnacl_host.h"
 #include "components/omnibox/browser/omnibox_pref_names.h"
 #include "components/password_manager/core/browser/password_store.h"
 #include "components/power/origin_power_map.h"
@@ skipping 92 matching lines @@
 }
 
 // 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.
-bool DoesOriginMatchMask(
+bool DoesOriginMatchMaskAndUrls(
     int origin_type_mask,
+    const base::Callback<bool(const GURL&)>& predicate,
     const GURL& origin,
     storage::SpecialStoragePolicy* special_storage_policy) {
-  return BrowsingDataHelper::DoesOriginMatchMask(
-      origin, origin_type_mask, special_storage_policy);
+  return predicate.Run(origin) &&
+         BrowsingDataHelper::DoesOriginMatchMask(origin, origin_type_mask,
+                                                 special_storage_policy);
+}
+
+bool ForwardPrimaryPatternCallback(
+    const base::Callback<bool(const ContentSettingsPattern&)> predicate,
+    const ContentSettingsPattern& primary_pattern,
+    const ContentSettingsPattern& secondary_pattern) {
+  return predicate.Run(primary_pattern);
 }
 
 void ClearHostnameResolutionCacheOnIOThread(IOThread* io_thread) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   io_thread->ClearHostCache();
 }
 
 void ClearNetworkPredictorOnIOThread(chrome_browser_net::Predictor* predictor) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
@@ skipping 24 matching lines @@
                             base::Time delete_end,
                             net::URLRequestContextGetter* rq_context,
                             const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::CookieStore* cookie_store =
       rq_context->GetURLRequestContext()->cookie_store();
   cookie_store->DeleteAllCreatedBetweenAsync(delete_begin, delete_end,
                                              IgnoreArgument<int>(callback));
 }
 
+void ClearCookiesWithPredicateOnIOThread(
+    base::Time delete_begin,
+    base::Time delete_end,
+    net::CookieStore::CookiePredicate predicate,
+    net::URLRequestContextGetter* rq_context,
+    const base::Closure& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  net::CookieStore* cookie_store =
+      rq_context->GetURLRequestContext()->cookie_store();
+  cookie_store->DeleteAllCreatedBetweenWithPredicateAsync(
+      delete_begin, delete_end, predicate, IgnoreArgument<int>(callback));
+}
+
 void OnClearedChannelIDsOnIOThread(net::URLRequestContextGetter* rq_context,
                                    const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // Need to close open SSL connections which may be using the channel ids we
   // are deleting.
   // TODO(mattm): http://crbug.com/166069 Make the server bound cert
   // service/store have observers that can notify relevant things directly.
   rq_context->GetURLRequestContext()
       ->ssl_config_service()
@@ skipping 100 matching lines @@
 }
 
 void BrowsingDataRemover::SetRemoving(bool is_removing) {
   DCHECK_NE(is_removing_, is_removing);
   is_removing_ = is_removing;
 }
 
 void BrowsingDataRemover::Remove(const TimeRange& time_range,
                                  int remove_mask,
                                  int origin_type_mask) {
-  RemoveImpl(time_range, remove_mask, GURL(), origin_type_mask);
+  OriginFilterBuilder builder(OriginFilterBuilder::BLACKLIST);
+  RemoveImpl(time_range, remove_mask, builder, origin_type_mask);
+}
+
+void BrowsingDataRemover::RemoveWithFilter(
+    const TimeRange& time_range,
+    int remove_mask,
+    int origin_type_mask,
+    const OriginFilterBuilder& origin_filter) {
+  RemoveImpl(time_range, remove_mask, origin_filter, origin_type_mask);
 }
 
 void BrowsingDataRemover::RemoveImpl(const TimeRange& time_range,
                                      int remove_mask,
-                                     const GURL& remove_url,
+                                     const OriginFilterBuilder& origin_filter,
                                      int origin_type_mask) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // 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);
 
   SetRemoving(true);
   delete_begin_ = time_range.begin;
   delete_end_ = time_range.end;
   remove_mask_ = remove_mask;
   origin_type_mask_ = origin_type_mask;
 
-  // TODO(msramek): Replace |remove_origin| with |filter| in all backends.
-  const url::Origin remove_origin(remove_url);
-  OriginFilterBuilder builder(OriginFilterBuilder::BLACKLIST);
-  if (!remove_url.is_empty()) {
-    // Make sure that only URLs representing origins, with no extra components,
-    // are passed to this class.
-    DCHECK_EQ(remove_url, remove_url.GetOrigin());
-    builder.SetMode(OriginFilterBuilder::WHITELIST);
-    builder.AddOrigin(url::Origin(remove_origin));
-  }
   base::Callback<bool(const GURL& url)> same_origin_filter =
-      builder.BuildSameOriginFilter();
+      origin_filter.BuildSameOriginFilter();
+  base::Callback<bool(const ContentSettingsPattern& url)> same_pattern_filter =
+      origin_filter.BuildWebsiteSettingsPatternMatchesFilter();
 
   PrefService* prefs = profile_->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)));
 
@@ skipping 15 matching lines @@
       BrowsingDataHelper::ALL == (BrowsingDataHelper::UNPROTECTED_WEB |
                                   BrowsingDataHelper::PROTECTED_WEB |
                                   BrowsingDataHelper::EXTENSION),
       "OriginTypeMask has been updated without updating user metrics");
 
   if ((remove_mask & REMOVE_HISTORY) && may_delete_history) {
     history::HistoryService* history_service =
         HistoryServiceFactory::GetForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
     if (history_service) {
-      // Selective history deletion is currently done through HistoryUI ->
-      // HistoryBackend -> HistoryService, and that is for individual URLs,
-      // not origins. The code below is currently unused, as the only callsite
-      // supplying |remove_url| is the unittest.
-      // TODO(msramek): Make it possible to delete history per origin, not just
-      // per URL, and use that functionality here.
-      std::set<GURL> restrict_urls;
-      if (!remove_url.is_empty())
-        restrict_urls.insert(remove_url);
+      // TODO(dmurph): Support all backends with filter (crbug.com/113621).
       content::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
       waiting_for_clear_history_ = true;
-
       history_service->ExpireLocalAndRemoteHistoryBetween(
-          WebHistoryServiceFactory::GetForProfile(profile_), restrict_urls,
+          WebHistoryServiceFactory::GetForProfile(profile_), std::set<GURL>(),
           delete_begin_, delete_end_,
           base::Bind(&BrowsingDataRemover::OnHistoryDeletionDone,
                      weak_ptr_factory_.GetWeakPtr()),
           &history_task_tracker_);
 
 #if defined(ENABLE_EXTENSIONS)
       // The extension activity contains details of which websites extensions
       // were active on. It therefore indirectly stores details of websites a
       // user has visited so best clean from here as well.
-      extensions::ActivityLog::GetInstance(profile_)->RemoveURLs(restrict_urls);
+      extensions::ActivityLog::GetInstance(profile_)->RemoveURLs(
+          std::set<GURL>());
 #endif
     }
 
 #if defined(ENABLE_EXTENSIONS)
     // Clear launch times as they are a form of history.
     extensions::ExtensionPrefs* extension_prefs =
         extensions::ExtensionPrefs::Get(profile_);
     extension_prefs->ClearLastLaunchTimes();
 #endif
 
     // The power consumption history by origin contains details of websites
     // that were visited.
+    // TODO(dmurph): Support all backends with filter (crbug.com/113621).
     power::OriginPowerMap* origin_power_map =
         power::OriginPowerMapFactory::GetForBrowserContext(profile_);
     if (origin_power_map)
       origin_power_map->ClearOriginMap();
 
     // Need to clear the host cache and accumulated speculative data, as it also
     // reveals some history: we have no mechanism to track when these items were
     // created, so we'll clear them all. Better safe than sorry.
     if (g_browser_process->io_thread()) {
+      // TODO(dmurph): Support all backends with filter (crbug.com/113621).
       waiting_for_clear_hostname_resolution_cache_ = true;
       BrowserThread::PostTaskAndReply(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&ClearHostnameResolutionCacheOnIOThread,
                      g_browser_process->io_thread()),
           base::Bind(&BrowsingDataRemover::OnClearedHostnameResolutionCache,
                      weak_ptr_factory_.GetWeakPtr()));
     }
     if (profile_->GetNetworkPredictor()) {
+      // TODO(dmurph): Support all backends with filter (crbug.com/113621).
       waiting_for_clear_network_predictor_ = true;
       BrowserThread::PostTaskAndReply(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&ClearNetworkPredictorOnIOThread,
                      profile_->GetNetworkPredictor()),
           base::Bind(&BrowsingDataRemover::OnClearedNetworkPredictor,
                      weak_ptr_factory_.GetWeakPtr()));
     }
 
     // As part of history deletion we also delete the auto-generated keywords.
     TemplateURLService* keywords_model =
         TemplateURLServiceFactory::GetForProfile(profile_);
+
     if (keywords_model && !keywords_model->loaded()) {
       template_url_sub_ = keywords_model->RegisterOnLoadedCallback(
           base::Bind(&BrowsingDataRemover::OnKeywordsLoaded,
                      weak_ptr_factory_.GetWeakPtr()));
       keywords_model->Load();
       waiting_for_clear_keyword_data_ = true;
     } else if (keywords_model) {
-      keywords_model->RemoveAutoGeneratedForOriginBetween(
-          remove_url, delete_begin_, delete_end_);
+      keywords_model->RemoveAutoGeneratedForOriginBetween(GURL(), delete_begin_,
+                                                          delete_end_);
     }
 
     // The PrerenderManager keeps history of prerendered pages, so clear that.
     // It also may have a prerendered page. If so, the page could be
     // considered to have a small amount of historical information, so delete
     // it, too.
     prerender::PrerenderManager* prerender_manager =
         prerender::PrerenderManagerFactory::GetForProfile(profile_);
     if (prerender_manager) {
+      // TODO(dmurph): Support all backends with filter (crbug.com/113621).
       prerender_manager->ClearData(
           prerender::PrerenderManager::CLEAR_PRERENDER_CONTENTS |
           prerender::PrerenderManager::CLEAR_PRERENDER_HISTORY);
     }
 
     // If the caller is removing history for all hosts, then clear ancillary
     // historical information.
-    if (remove_url.is_empty()) {
+    if (origin_filter.IsEmptyBlacklist()) {
       // We also delete the list of recently closed tabs. Since these expire,
       // they can't be more than a day old, so we can simply clear them all.
       sessions::TabRestoreService* tab_service =
           TabRestoreServiceFactory::GetForProfile(profile_);
       if (tab_service) {
         tab_service->ClearEntries();
         tab_service->DeleteLastSession();
       }
 
 #if defined(ENABLE_SESSION_SERVICE)
       // We also delete the last session when we delete the history.
       SessionService* session_service =
           SessionServiceFactory::GetForProfile(profile_);
       if (session_service)
         session_service->DeleteLastSession();
 #endif
     }
 
     // The saved Autofill profiles and credit cards can include the origin from
     // which these profiles and credit cards were learned.  These are a form of
     // history, so clear them as well.
+    // TODO(dmurph): Support all backends with filter (crbug.com/113621).
     scoped_refptr<autofill::AutofillWebDataService> web_data_service =
         WebDataServiceFactory::GetAutofillWebDataForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
     if (web_data_service.get()) {
       waiting_for_clear_autofill_origin_urls_ = true;
       web_data_service->RemoveOriginURLsModifiedBetween(
           delete_begin_, delete_end_);
       // The above calls are done on the UI thread but do their work on the DB
       // thread. So wait for it.
       BrowserThread::PostTaskAndReply(
@@ skipping 85 matching lines @@
     // 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) {
         scoped_refptr<net::URLRequestContextGetter> sb_context =
             sb_service->url_request_context();
         ++waiting_for_clear_cookies_count_;
-        BrowserThread::PostTask(
-            BrowserThread::IO, FROM_HERE,
-            base::Bind(&ClearCookiesOnIOThread, delete_begin_, delete_end_,
-                       std::move(sb_context),
-                       UIThreadTrampoline(
-                           base::Bind(&BrowsingDataRemover::OnClearedCookies,
-                                      weak_ptr_factory_.GetWeakPtr()))));
+
+        if (origin_filter.IsEmptyBlacklist()) {
+          BrowserThread::PostTask(
+              BrowserThread::IO, FROM_HERE,
+              base::Bind(&ClearCookiesOnIOThread, delete_begin_, delete_end_,
+                         std::move(sb_context),
+                         UIThreadTrampoline(
+                             base::Bind(&BrowsingDataRemover::OnClearedCookies,
+                                        weak_ptr_factory_.GetWeakPtr()))));
+        } else {
+          BrowserThread::PostTask(
+              BrowserThread::IO, FROM_HERE,
+              base::Bind(&ClearCookiesWithPredicateOnIOThread, delete_begin_,
+                         delete_end_, origin_filter.BuildDomainCookieFilter(),
+                         std::move(sb_context),
+                         UIThreadTrampoline(
+                             base::Bind(&BrowsingDataRemover::OnClearedCookies,
+                                        weak_ptr_factory_.GetWeakPtr()))));
+        }
       }
     }
 
     MediaDeviceIDSalt::Reset(profile_->GetPrefs());
   }
 
   // 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) {
@@ skipping 57 matching lines @@
         plugin_data_remover_->StartRemoving(delete_begin_);
 
     base::WaitableEventWatcher::EventCallback watcher_callback =
         base::Bind(&BrowsingDataRemover::OnWaitableEventSignaled,
                    weak_ptr_factory_.GetWeakPtr());
     watcher_.StartWatching(event, watcher_callback);
   }
 #endif
 
   if (remove_mask & REMOVE_SITE_USAGE_DATA) {
-    HostContentSettingsMapFactory::GetForProfile(profile_)
-        ->ClearSettingsForOneType(CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT);
+    ClearSettingsForOneTypeWithPredicate(
+        HostContentSettingsMapFactory::GetForProfile(profile_),
+        CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT,
+        base::Bind(&ForwardPrimaryPatternCallback, same_pattern_filter));
   }
 
   if (remove_mask & REMOVE_SITE_USAGE_DATA || remove_mask & REMOVE_HISTORY) {
-    HostContentSettingsMapFactory::GetForProfile(profile_)
-        ->ClearSettingsForOneType(CONTENT_SETTINGS_TYPE_APP_BANNER);
+    ClearSettingsForOneTypeWithPredicate(
+        HostContentSettingsMapFactory::GetForProfile(profile_),
+        CONTENT_SETTINGS_TYPE_APP_BANNER,
+        base::Bind(&ForwardPrimaryPatternCallback, same_pattern_filter));
   }
 
   if (remove_mask & REMOVE_PASSWORDS) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Passwords"));
     password_manager::PasswordStore* password_store =
         PasswordStoreFactory::GetForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS).get();
 
     if (password_store) {
       waiting_for_clear_passwords_ = true;
@@ skipping 27 matching lines @@
 
     if (password_store) {
       waiting_for_clear_passwords_stats_ = true;
       password_store->RemoveStatisticsCreatedBetween(
           delete_begin_, delete_end_,
           base::Bind(&BrowsingDataRemover::OnClearedPasswordsStats,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
+  // TODO(dmurph): Support all backends with filter (crbug.com/113621).
   if (remove_mask & REMOVE_FORM_DATA) {
     content::RecordAction(UserMetricsAction("ClearBrowsingData_Autofill"));
     scoped_refptr<autofill::AutofillWebDataService> web_data_service =
         WebDataServiceFactory::GetAutofillWebDataForProfile(
             profile_, ServiceAccessType::EXPLICIT_ACCESS);
 
     if (web_data_service.get()) {
       waiting_for_clear_form_ = true;
       web_data_service->RemoveFormElementsAddedBetween(delete_begin_,
           delete_end_);
@@ skipping 83 matching lines @@
 
     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 |=
           content::StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
     }
 
+    content::StoragePartition::CookieMatcherFunction cookie_matcher;
+    if (!origin_filter.IsEmptyBlacklist()) {
+      cookie_matcher = origin_filter.BuildDomainCookieFilter();
+    }
     storage_partition->ClearData(
-        storage_partition_remove_mask, quota_storage_remove_mask, remove_url,
-        base::Bind(&DoesOriginMatchMask, origin_type_mask_), delete_begin_,
-        delete_end_,
+        storage_partition_remove_mask, quota_storage_remove_mask,
+        base::Bind(&DoesOriginMatchMaskAndUrls, origin_type_mask_,
+                   same_origin_filter),
+        cookie_matcher, delete_begin_, delete_end_,
         base::Bind(&BrowsingDataRemover::OnClearedStoragePartitionData,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
 #if defined(ENABLE_PLUGINS)
   if (remove_mask & REMOVE_CONTENT_LICENSES) {
     content::RecordAction(
         UserMetricsAction("ClearBrowsingData_ContentLicenses"));
 
     waiting_for_clear_content_licenses_ = true;
@@ skipping 60 matching lines @@
     waiting_for_clear_webapp_data_ = true;
     WebappRegistry::UnregisterWebapps(
         base::Bind(&BrowsingDataRemover::OnClearedWebappData,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   if ((remove_mask & REMOVE_OFFLINE_PAGE_DATA) &&
       offline_pages::IsOfflinePagesEnabled()) {
     waiting_for_clear_offline_page_data_ = true;
     offline_pages::OfflinePageModelFactory::GetForBrowserContext(profile_)
-        ->ClearAll(base::Bind(&BrowsingDataRemover::OnClearedOfflinePageData,
-                              weak_ptr_factory_.GetWeakPtr()));
+        ->ClearWithURLPredicate(
+            same_origin_filter,
+            base::Bind(&BrowsingDataRemover::OnClearedOfflinePageData,
+                       weak_ptr_factory_.GetWeakPtr()));
   }
 #endif
 
   // Record the combined deletion of cookies and cache.
   CookieOrCacheDeletionChoice choice = NEITHER_COOKIES_NOR_CACHE;
   if (remove_mask & REMOVE_COOKIES &&
       origin_type_mask_ & BrowsingDataHelper::UNPROTECTED_WEB) {
     choice = remove_mask & REMOVE_CACHE ? BOTH_COOKIES_AND_CACHE
                                         : ONLY_COOKIES;
   } else if (remove_mask & REMOVE_CACHE) {
@@ skipping 11 matching lines @@
 
 void BrowsingDataRemover::RemoveObserver(Observer* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 void BrowsingDataRemover::OverrideStoragePartitionForTesting(
     content::StoragePartition* storage_partition) {
   storage_partition_for_testing_ = storage_partition;
 }
 
+void BrowsingDataRemover::ClearSettingsForOneTypeWithPredicate(
+    HostContentSettingsMap* content_settings_map,
+    ContentSettingsType content_type,
+    const base::Callback<bool(const ContentSettingsPattern& primary_pattern,
+                              const ContentSettingsPattern& secondary_pattern)>&
+        predicate) {
+  ContentSettingsForOneType settings;
+  content_settings_map->GetSettingsForOneType(content_type, std::string(),
+                                              &settings);
+  for (const ContentSettingPatternSource& setting : settings) {
+    if (predicate.Run(setting.primary_pattern, setting.secondary_pattern)) {
+      content_settings_map->SetWebsiteSettingCustomScope(
+          setting.primary_pattern, setting.secondary_pattern, content_type,
+          std::string(), nullptr);
+    }
+  }
+}
+
 base::Time BrowsingDataRemover::CalculateBeginDeleteTime(
     TimePeriod time_period) {
   base::TimeDelta diff;
   base::Time delete_begin_time = base::Time::Now();
   switch (time_period) {
     case LAST_HOUR:
       diff = base::TimeDelta::FromHours(1);
       break;
     case LAST_DAY:
       diff = base::TimeDelta::FromHours(24);
@@ skipping 238 matching lines @@
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyIfDone();
 }
 
 // static
 BrowsingDataRemover::CallbackSubscription
     BrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
         const BrowsingDataRemover::Callback& callback) {
   return GetOnBrowsingDataRemovedCallbacks()->Add(callback);
 }