Deprecate the CallbackSubscription in BrowsingDataRemover

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 102 matching lines @@
 #include "chrome/browser/media/webrtc_log_util.h"
 #endif
 
 using base::UserMetricsAction;
 using content::BrowserContext;
 using content::BrowserThread;
 using content::DOMStorageContext;
 
 namespace {
 
-using CallbackList =
-    base::CallbackList<void(const BrowsingDataRemover::NotificationDetails&)>;
-
-// Contains all registered callbacks for browsing data removed notifications.
-CallbackList* g_on_browsing_data_removed_callbacks = nullptr;
-
-// Accessor for |*g_on_browsing_data_removed_callbacks|. Creates a new object
-// the first time so that it always returns a valid object.
-CallbackList* GetOnBrowsingDataRemovedCallbacks() {
-  if (!g_on_browsing_data_removed_callbacks)
-    g_on_browsing_data_removed_callbacks = new CallbackList();
-  return g_on_browsing_data_removed_callbacks;
-}
-
 void UIThreadTrampolineHelper(const base::Closure& callback) {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, callback);
 }
 
 // Convenience method to create a callback that can be run on any thread and
 // will post the given |callback| back to the UI thread.
 base::Closure UIThreadTrampoline(const base::Closure& callback) {
   // We could directly bind &BrowserThread::PostTask, but that would require
   // evaluating FROM_HERE when this method is called, as opposed to when the
   // task is actually posted.
@@ skipping 112 matching lines @@
       domain_predicate, delete_begin, delete_end,
       base::Bind(&OnClearedChannelIDsOnIOThread,
                  base::RetainedRef(std::move(rq_context)), callback));
 }
 
 }  // namespace
 
 BrowsingDataRemover::CompletionInhibitor*
     BrowsingDataRemover::completion_inhibitor_ = nullptr;
 
-BrowsingDataRemover::NotificationDetails::NotificationDetails()
-    : removal_begin(base::Time()),
-      removal_mask(-1),
-      origin_type_mask(-1) {
-}
-
-BrowsingDataRemover::NotificationDetails::NotificationDetails(
-    const BrowsingDataRemover::NotificationDetails& details)
-    : removal_begin(details.removal_begin),
-      removal_mask(details.removal_mask),
-      origin_type_mask(details.origin_type_mask) {
-}
-
-BrowsingDataRemover::NotificationDetails::NotificationDetails(
-    base::Time removal_begin,
-    int removal_mask,
-    int origin_type_mask)
-    : removal_begin(removal_begin),
-      removal_mask(removal_mask),
-      origin_type_mask(origin_type_mask) {
-}
-
-BrowsingDataRemover::NotificationDetails::~NotificationDetails() {}
-
 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());
 }
 
@@ skipping 17 matching lines @@
       content::RecordAction(UserMetricsAction("ClearBrowsingData_Everything"));
       break;
   }
   return TimeRange(CalculateBeginDeleteTime(period), base::Time::Max());
 }
 
 BrowsingDataRemover::BrowsingDataRemover(
     content::BrowserContext* browser_context)
     : profile_(Profile::FromBrowserContext(browser_context)),
       is_removing_(false),
+      remove_mask_(-1),
+      origin_type_mask_(-1),
 #if BUILDFLAG(ANDROID_JAVA_UI)
       webapp_registry_(new WebappRegistry()),
 #endif
       weak_ptr_factory_(this) {
   DCHECK(browser_context);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   // If we are still removing data, notify observers so they can remove
   // themselves from the observer list.
@@ skipping 722 matching lines @@
   storage_partition_for_testing_ = storage_partition;
 }
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 void BrowsingDataRemover::OverrideWebappRegistryForTesting(
     std::unique_ptr<WebappRegistry> webapp_registry) {
   webapp_registry_.reset(webapp_registry.release());
 }
 #endif
 
+const base::Time& BrowsingDataRemover::GetLastUsedBeginTime() {
+  return delete_begin_;
+}
+
+const base::Time& BrowsingDataRemover::GetLastUsedEndTime() {
+  return delete_end_;
+}
+
+int BrowsingDataRemover::GetLastUsedRemovalMask() {
+  return remove_mask_;
+}
+
+int BrowsingDataRemover::GetLastUsedOriginTypeMask() {
+  return origin_type_mask_;
+}
+
+
 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) {
@@ skipping 39 matching lines @@
   TemplateURLService* model =
       TemplateURLServiceFactory::GetForProfile(profile_);
   model->RemoveAutoGeneratedBetween(delete_begin_, delete_end_);
   waiting_for_clear_keyword_data_ = false;
   template_url_sub_.reset();
   NotifyIfDone();
 }
 
 void BrowsingDataRemover::Notify() {
   SetRemoving(false);
-
-  // Notify observers.
-  BrowsingDataRemover::NotificationDetails details(delete_begin_, remove_mask_,
-      origin_type_mask_);
-
-  GetOnBrowsingDataRemovedCallbacks()->Notify(details);
-
   FOR_EACH_OBSERVER(Observer, observer_list_, OnBrowsingDataRemoverDone());
 }
 
 void BrowsingDataRemover::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;
@@ skipping 169 matching lines @@
   waiting_for_clear_offline_page_data_ = false;
   NotifyIfDone();
 }
 #endif
 
 void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyIfDone();
 }
-
-// static
-BrowsingDataRemover::CallbackSubscription
-    BrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
-        const BrowsingDataRemover::Callback& callback) {
-  return GetOnBrowsingDataRemovedCallbacks()->Add(callback);
-}