Reduce BrowsingDataRemover's dependencies on Chrome

chrome/browser/browsing_data/browsing_data_remover_unittest.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 <stddef.h>
 #include <stdint.h>
 
 #include <list>
@@ skipping 382 matching lines @@
     const base::Callback<bool(const GURL&)>& filter) {
   return MakeMatcher(new ProbablySameFilterMatcher(filter));
 }
 
 bool ProbablySameFilters(
     const base::Callback<bool(const GURL&)>& filter1,
     const base::Callback<bool(const GURL&)>& filter2) {
   return ProbablySameFilter(filter1).MatchAndExplain(filter2, nullptr);
 }
 
+base::Time AnHourAgo() {
+  return base::Time::Now() - base::TimeDelta::FromHours(1);
+}
+
 }  // namespace
 
 // Testers -------------------------------------------------------------------
 
 class RemoveCookieTester {
  public:
   RemoveCookieTester() {}
 
   // Returns true, if the given cookie exists in the cookie store.
   bool ContainsCookie() {
@@ skipping 750 matching lines @@
     // posts a message to the WEBKIT thread to delete some of its member
     // variables. We need to ensure that the profile is destroyed, and that
     // the message loop is cleared out, before destroying the threads and loop.
     // Otherwise we leak memory.
     profile_.reset();
     base::RunLoop().RunUntilIdle();
 
     TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr);
   }
 
-  void BlockUntilBrowsingDataRemoved(browsing_data::TimePeriod period,
+  void BlockUntilBrowsingDataRemoved(const base::Time& delete_begin,
+                                     const base::Time& delete_end,
                                      int remove_mask,
                                      bool include_protected_origins) {
     BrowsingDataRemover* remover =
         BrowsingDataRemoverFactory::GetForBrowserContext(profile_.get());
 
     TestStoragePartition storage_partition;
     remover->OverrideStoragePartitionForTesting(&storage_partition);
 
     int origin_type_mask = BrowsingDataHelper::UNPROTECTED_WEB;
     if (include_protected_origins)
       origin_type_mask |= BrowsingDataHelper::PROTECTED_WEB;
 
     BrowsingDataRemoverCompletionObserver completion_observer(remover);
-    remover->RemoveAndReply(BrowsingDataRemover::Period(period), remove_mask,
-                            origin_type_mask, &completion_observer);
+    remover->RemoveAndReply(
+        delete_begin, delete_end, remove_mask, origin_type_mask,
+        &completion_observer);
     completion_observer.BlockUntilCompletion();
 
     // Save so we can verify later.
     storage_partition_removal_data_ =
         storage_partition.GetStoragePartitionRemovalData();
   }
 
   void BlockUntilOriginDataRemoved(
-      browsing_data::TimePeriod period,
+      const base::Time& delete_begin,
+      const base::Time& delete_end,
       int remove_mask,
       const BrowsingDataFilterBuilder& filter_builder) {
     BrowsingDataRemover* remover =
         BrowsingDataRemoverFactory::GetForBrowserContext(profile_.get());
     TestStoragePartition storage_partition;
     remover->OverrideStoragePartitionForTesting(&storage_partition);
 
     BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
-    remover->RemoveImpl(BrowsingDataRemover::Period(period), remove_mask,
-                        filter_builder, BrowsingDataHelper::UNPROTECTED_WEB);
+    remover->RemoveImpl(delete_begin, delete_end, remove_mask, filter_builder,
+                        BrowsingDataHelper::UNPROTECTED_WEB);
     completion_inhibitor.BlockUntilNearCompletion();
     completion_inhibitor.ContinueToCompletion();
 
     // Save so we can verify later.
     storage_partition_removal_data_ =
         storage_partition.GetStoragePartitionRemovalData();
   }
 
   TestingProfile* GetProfile() {
     return profile_.get();
@@ skipping 64 matching lines @@
 
   // Needed to mock out DomainReliabilityService, even for unrelated tests.
   ClearDomainReliabilityTester clear_domain_reliability_tester_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverTest);
 };
 
 // Tests ---------------------------------------------------------------------
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookieForever) {
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the cookies.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookieLastHour) {
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the cookies.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
-  // Removing with time period other than ALL_TIME should not clear
+  // Removing with time period other than all time should not clear
   // persistent storage data.
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveCookiesDomainBlacklist) {
   RegistrableDomainFilterBuilder filter(
       RegistrableDomainFilterBuilder::BLACKLIST);
   filter.AddRegisterableDomain(kTestRegisterableDomain1);
   filter.AddRegisterableDomain(kTestRegisterableDomain3);
-  BlockUntilOriginDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_COOKIES, filter);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the cookies.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
-  // Removing with time period other than ALL_TIME should not clear
+  // Removing with time period other than all time should not clear
   // persistent storage data.
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
   // Even though it's a different origin, it's the same domain.
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin4, mock_policy()));
 
   EXPECT_FALSE(removal_data.cookie_matcher.Run(CreateCookieWithHost(kOrigin1)));
   EXPECT_TRUE(removal_data.cookie_matcher.Run(CreateCookieWithHost(kOrigin2)));
   EXPECT_FALSE(removal_data.cookie_matcher.Run(CreateCookieWithHost(kOrigin3)));
   // This is false, because this is the same domain as 3, just with a different
   // scheme.
   EXPECT_FALSE(removal_data.cookie_matcher.Run(CreateCookieWithHost(kOrigin4)));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveSafeBrowsingCookieForever) {
   RemoveSafeBrowsingCookieTester tester;
 
   tester.AddCookie();
   ASSERT_TRUE(tester.ContainsCookie());
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_FALSE(tester.ContainsCookie());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveSafeBrowsingCookieLastHour) {
   RemoveSafeBrowsingCookieTester tester;
 
   tester.AddCookie();
   ASSERT_TRUE(tester.ContainsCookie());
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
-  // Removing with time period other than ALL_TIME should not clear safe
+  // Removing with time period other than all time should not clear safe
   // browsing cookies.
   EXPECT_TRUE(tester.ContainsCookie());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveSafeBrowsingCookieForeverWithPredicate) {
   RemoveSafeBrowsingCookieTester tester;
 
   tester.AddCookie();
   ASSERT_TRUE(tester.ContainsCookie());
   RegistrableDomainFilterBuilder filter(
       RegistrableDomainFilterBuilder::BLACKLIST);
   filter.AddRegisterableDomain(kTestRegisterableDomain1);
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_COOKIES, filter);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_TRUE(tester.ContainsCookie());
 
   RegistrableDomainFilterBuilder filter2(
       RegistrableDomainFilterBuilder::WHITELIST);
   filter2.AddRegisterableDomain(kTestRegisterableDomain1);
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_COOKIES, filter2);
   EXPECT_FALSE(tester.ContainsCookie());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveChannelIDForever) {
   RemoveChannelIDTester tester(GetProfile());
 
   tester.AddChannelID(kTestOrigin1);
   EXPECT_EQ(0, tester.ssl_config_changed_count());
   EXPECT_EQ(1, tester.ChannelIDCount());
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_CHANNEL_IDS, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_EQ(1, tester.ssl_config_changed_count());
   EXPECT_EQ(0, tester.ChannelIDCount());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveChannelIDLastHour) {
   RemoveChannelIDTester tester(GetProfile());
 
   base::Time now = base::Time::Now();
   tester.AddChannelID(kTestOrigin1);
   tester.AddChannelIDWithTimes(kTestOrigin2,
                                now - base::TimeDelta::FromHours(2));
   EXPECT_EQ(0, tester.ssl_config_changed_count());
   EXPECT_EQ(2, tester.ChannelIDCount());
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_CHANNEL_IDS, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_EQ(1, tester.ssl_config_changed_count());
   ASSERT_EQ(1, tester.ChannelIDCount());
   net::ChannelIDStore::ChannelIDList channel_ids;
   tester.GetChannelIDList(&channel_ids);
   ASSERT_EQ(1U, channel_ids.size());
   EXPECT_EQ(kTestOrigin2, channel_ids.front().server_identifier());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveChannelIDsForServerIdentifiers) {
   RemoveChannelIDTester tester(GetProfile());
 
   tester.AddChannelID(kTestRegisterableDomain1);
   tester.AddChannelID(kTestRegisterableDomain3);
   EXPECT_EQ(2, tester.ChannelIDCount());
 
   RegistrableDomainFilterBuilder filter_builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   filter_builder.AddRegisterableDomain(kTestRegisterableDomain1);
 
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_CHANNEL_IDS,
                               filter_builder);
 
   EXPECT_EQ(1, tester.ChannelIDCount());
   net::ChannelIDStore::ChannelIDList channel_ids;
   tester.GetChannelIDList(&channel_ids);
   EXPECT_EQ(kTestRegisterableDomain3, channel_ids.front().server_identifier());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveUnprotectedLocalStorageForever) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
                                 false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the data correctly.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 
   // Check origin matcher.
   EXPECT_EQ(ShouldRemoveForProtectedOriginOne(),
             removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveProtectedLocalStorageForever) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   // Protect kOrigin1.
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
                                 true);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB |
             BrowsingDataHelper::PROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the data correctly.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE);
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 
   // Check origin matcher all http origin will match since we specified
   // both protected and unprotected.
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveLocalStorageForLastWeek) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_WEEK,
-                                BrowsingDataRemover::REMOVE_LOCAL_STORAGE,
-                                false);
+  BlockUntilBrowsingDataRemoved(
+      base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(),
+      BrowsingDataRemover::REMOVE_LOCAL_STORAGE, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify that storage partition was instructed to remove the data correctly.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE);
   // Persistent storage won't be deleted.
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT);
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 
   // Check origin matcher.
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForever) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryForLastHour) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
 }
 
 // This should crash (DCHECK) in Debug, but death tests don't work properly
 // here.
 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
 TEST_F(BrowsingDataRemoverTest, RemoveHistoryProhibited) {
   RemoveHistoryTester tester;
   ASSERT_TRUE(tester.Init(GetProfile()));
   PrefService* prefs = GetProfile()->GetPrefs();
   prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Nothing should have been deleted.
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
 }
 #endif
 
 TEST_F(BrowsingDataRemoverTest, RemoveMultipleTypes) {
   // Add some history.
   RemoveHistoryTester history_tester;
   ASSERT_TRUE(history_tester.Init(GetProfile()));
   history_tester.AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
 
   int removal_mask = BrowsingDataRemover::REMOVE_HISTORY |
                      BrowsingDataRemover::REMOVE_COOKIES;
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME, removal_mask, false);
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
+                                removal_mask, false);
 
   EXPECT_EQ(removal_mask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_FALSE(history_tester.HistoryContainsURL(kOrigin1));
 
   // The cookie would be deleted throught the StorageParition, check if the
   // partition was requested to remove cookie.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
@@ skipping 10 matching lines @@
 
   // Add some history.
   RemoveHistoryTester history_tester;
   ASSERT_TRUE(history_tester.Init(GetProfile()));
   history_tester.AddHistory(kOrigin1, base::Time::Now());
   ASSERT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
 
   int removal_mask = BrowsingDataRemover::REMOVE_HISTORY |
                      BrowsingDataRemover::REMOVE_COOKIES;
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR, removal_mask, false);
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
+                                removal_mask, false);
   EXPECT_EQ(removal_mask, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // 1/2. History should remain.
   EXPECT_TRUE(history_tester.HistoryContainsURL(kOrigin1));
 
   // 2/2. The cookie(s) would be deleted throught the StorageParition, check if
   // the partition was requested to remove cookie.
   StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
   EXPECT_EQ(removal_data.remove_mask,
             StoragePartition::REMOVE_DATA_MASK_COOKIES);
-  // Persistent storage won't be deleted, since ALL_TIME was not specified.
+  // Persistent storage won't be deleted, since the time period is not all time.
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT);
 }
 #endif
 
 // Test that clearing history deletes favicons not associated with bookmarks.
 TEST_F(BrowsingDataRemoverTest, RemoveFaviconsForever) {
   GURL page_url("http://a");
 
   RemoveFaviconTester favicon_tester;
   ASSERT_TRUE(favicon_tester.Init(GetProfile()));
   favicon_tester.VisitAndAddFavicon(page_url);
   ASSERT_TRUE(favicon_tester.HasFaviconForPageURL(page_url));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_FALSE(favicon_tester.HasFaviconForPageURL(page_url));
 }
 
 // Test that a bookmark's favicon is expired and not deleted when clearing
 // history. Expiring the favicon causes the bookmark's favicon to be updated
 // when the user next visits the bookmarked page. Expiring the bookmark's
 // favicon is useful when the bookmark's favicon becomes incorrect (See
 // crbug.com/474421 for a sample bug which causes this).
 TEST_F(BrowsingDataRemoverTest, ExpireBookmarkFavicons) {
   GURL bookmarked_page("http://a");
 
   TestingProfile* profile = GetProfile();
   profile->CreateBookmarkModel(true);
   bookmarks::BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForBrowserContext(profile);
   bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model);
   bookmark_model->AddURL(bookmark_model->bookmark_bar_node(), 0,
                          base::ASCIIToUTF16("a"), bookmarked_page);
 
   RemoveFaviconTester favicon_tester;
   ASSERT_TRUE(favicon_tester.Init(GetProfile()));
   favicon_tester.VisitAndAddFavicon(bookmarked_page);
   ASSERT_TRUE(favicon_tester.HasFaviconForPageURL(bookmarked_page));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_TRUE(favicon_tester.HasExpiredFaviconForPageURL(bookmarked_page));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverBoth) {
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_WEBSQL |
           BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_INDEXEDDB,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
@@ skipping 16 matching lines @@
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyTemporary) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_WEBSQL |
           BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_INDEXEDDB,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
@@ skipping 23 matching lines @@
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverOnlyPersistent) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_WEBSQL |
           BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_INDEXEDDB,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
@@ skipping 23 matching lines @@
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverNeither) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_WEBSQL |
           BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_INDEXEDDB,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
@@ skipping 22 matching lines @@
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForeverSpecificOrigin) {
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   builder.AddRegisterableDomain(kTestRegisterableDomain1);
   // Remove Origin 1.
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_APPCACHE |
                                   BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
                                   BrowsingDataRemover::REMOVE_CACHE_STORAGE |
                                   BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                                   BrowsingDataRemover::REMOVE_INDEXEDDB |
                                   BrowsingDataRemover::REMOVE_WEBSQL,
                               builder);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
                 BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
@@ skipping 17 matching lines @@
   EXPECT_EQ(removal_data.quota_storage_remove_mask,
             StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
   EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin4, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastHour) {
   BlockUntilBrowsingDataRemoved(
-      browsing_data::LAST_HOUR,
+      AnHourAgo(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_WEBSQL |
           BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_INDEXEDDB,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
@@ skipping 19 matching lines @@
   // beginning of time.
   uint32_t expected_quota_mask =
       ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
   EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask);
   // Check removal begin time.
   EXPECT_EQ(removal_data.remove_begin, GetBeginTime());
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedDataForLastWeek) {
   BlockUntilBrowsingDataRemoved(
-      browsing_data::LAST_WEEK,
+      base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(),
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_WEBSQL |
           BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_INDEXEDDB,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
@@ skipping 25 matching lines @@
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedUnprotectedOrigins) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_WEBSQL |
           BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_INDEXEDDB,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                 BrowsingDataRemover::REMOVE_WEBSQL |
@@ skipping 29 matching lines @@
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   builder.AddRegisterableDomain(kTestRegisterableDomain1);
 
   // Try to remove kOrigin1. Expect failure.
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_APPCACHE |
                                   BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
                                   BrowsingDataRemover::REMOVE_CACHE_STORAGE |
                                   BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
                                   BrowsingDataRemover::REMOVE_INDEXEDDB |
                                   BrowsingDataRemover::REMOVE_WEBSQL,
                               builder);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
                 BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
@@ skipping 28 matching lines @@
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedProtectedOrigins) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
   // Protect kOrigin1.
   policy->AddProtected(kOrigin1.GetOrigin());
 #endif
 
   // Try to remove kOrigin1. Expect success.
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_INDEXEDDB |
           BrowsingDataRemover::REMOVE_WEBSQL,
       true);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
                 BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
@@ skipping 24 matching lines @@
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
   EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedIgnoreExtensionsAndDevTools) {
 #if BUILDFLAG(ENABLE_EXTENSIONS)
   CreateMockPolicy();
 #endif
 
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_APPCACHE |
           BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
           BrowsingDataRemover::REMOVE_CACHE_STORAGE |
           BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
           BrowsingDataRemover::REMOVE_INDEXEDDB |
           BrowsingDataRemover::REMOVE_WEBSQL,
       false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE |
                 BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
@@ skipping 29 matching lines @@
 
   base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2);
 
   tester.AddHistory(kOrigin1, base::Time::Now());
   tester.AddHistory(kOrigin2, two_hours_ago);
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1));
   ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2));
 
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::BLACKLIST);
-  BlockUntilOriginDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_HISTORY, builder);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1));
   EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2));
 }
 
 // Verify that clearing autofill form data works.
 TEST_F(BrowsingDataRemoverTest, AutofillRemovalLastHour) {
   GetProfile()->CreateWebDataService();
   RemoveAutofillTester tester(GetProfile());
 
   ASSERT_FALSE(tester.HasProfile());
   tester.AddProfilesAndCards();
   ASSERT_TRUE(tester.HasProfile());
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_FORM_DATA, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FORM_DATA, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   ASSERT_FALSE(tester.HasProfile());
 }
 
 TEST_F(BrowsingDataRemoverTest, AutofillRemovalEverything) {
   GetProfile()->CreateWebDataService();
   RemoveAutofillTester tester(GetProfile());
 
   ASSERT_FALSE(tester.HasProfile());
   tester.AddProfilesAndCards();
   ASSERT_TRUE(tester.HasProfile());
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_FORM_DATA, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_FORM_DATA, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   ASSERT_FALSE(tester.HasProfile());
 }
 
 // Verify that clearing autofill form data works.
 TEST_F(BrowsingDataRemoverTest, AutofillOriginsRemovedWithHistory) {
   GetProfile()->CreateWebDataService();
   RemoveAutofillTester tester(GetProfile());
 
   tester.AddProfilesAndCards();
   EXPECT_FALSE(tester.HasOrigin(std::string()));
   EXPECT_TRUE(tester.HasOrigin(kWebOrigin));
   EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_HISTORY, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
   EXPECT_TRUE(tester.HasOrigin(std::string()));
   EXPECT_FALSE(tester.HasOrigin(kWebOrigin));
   EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin));
 }
 
 class InspectableCompletionObserver
@@ skipping 16 matching lines @@
 };
 
 TEST_F(BrowsingDataRemoverTest, CompletionInhibition) {
   // The |completion_inhibitor| on the stack should prevent removal sessions
   // from completing until after ContinueToCompletion() is called.
   BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
 
   BrowsingDataRemover* remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile());
   InspectableCompletionObserver completion_observer(remover);
-  remover->RemoveAndReply(BrowsingDataRemover::Unbounded(),
+  remover->RemoveAndReply(base::Time(), base::Time::Max(),
                           BrowsingDataRemover::REMOVE_HISTORY,
                           BrowsingDataHelper::UNPROTECTED_WEB,
                           &completion_observer);
 
   // Process messages until the inhibitor is notified, and then some, to make
   // sure we do not complete asynchronously before ContinueToCompletion() is
   // called.
   completion_inhibitor.BlockUntilNearCompletion();
   base::RunLoop().RunUntilIdle();
 
   // Verify that the removal has not yet been completed and the observer has
   // not been called.
   EXPECT_TRUE(remover->is_removing());
   EXPECT_FALSE(completion_observer.called());
 
   // Now run the removal process until completion, and verify that observers are
   // now notified, and the notifications is sent out.
   completion_inhibitor.ContinueToCompletion();
   completion_observer.BlockUntilCompletion();
 
   EXPECT_FALSE(remover->is_removing());
   EXPECT_TRUE(completion_observer.called());
 }
 
 TEST_F(BrowsingDataRemoverTest, EarlyShutdown) {
   BrowsingDataRemover* remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile());
   InspectableCompletionObserver completion_observer(remover);
   BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
-  remover->RemoveAndReply(BrowsingDataRemover::Unbounded(),
+  remover->RemoveAndReply(base::Time(), base::Time::Max(),
                           BrowsingDataRemover::REMOVE_HISTORY,
                           BrowsingDataHelper::UNPROTECTED_WEB,
                           &completion_observer);
 
   completion_inhibitor.BlockUntilNearCompletion();
 
   // Verify that the deletion has not yet been completed and the observer has
   // not been called.
   EXPECT_TRUE(remover->is_removing());
   EXPECT_FALSE(completion_observer.called());
 
   // Destroying the profile should trigger the notification.
   DestroyProfile();
 
   EXPECT_TRUE(completion_observer.called());
 
   // Finishing after shutdown shouldn't break anything.
   completion_inhibitor.ContinueToCompletion();
   completion_observer.BlockUntilCompletion();
 }
 
 TEST_F(BrowsingDataRemoverTest, ZeroSuggestCacheClear) {
   PrefService* prefs = GetProfile()->GetPrefs();
   prefs->SetString(omnibox::kZeroSuggestCachedResults,
                    "[\"\", [\"foo\", \"bar\"]]");
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
 
   // Expect the prefs to be cleared when cookies are removed.
   EXPECT_TRUE(prefs->GetString(omnibox::kZeroSuggestCachedResults).empty());
   EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 }
 
 #if defined(OS_CHROMEOS)
 TEST_F(BrowsingDataRemoverTest, ContentProtectionPlatformKeysRemoval) {
@@ skipping 10 matching lines @@
   chromeos::MockCryptohomeClient* cryptohome_client =
       new chromeos::MockCryptohomeClient;
   dbus_setter->SetCryptohomeClient(
       std::unique_ptr<chromeos::CryptohomeClient>(cryptohome_client));
 
   // Expect exactly one call.  No calls means no attempt to delete keys and more
   // than one call means a significant performance problem.
   EXPECT_CALL(*cryptohome_client, TpmAttestationDeleteKeys(_, _, _, _))
       .WillOnce(WithArgs<3>(Invoke(FakeDBusCall)));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_MEDIA_LICENSES,
                                 false);
 
   chromeos::DBusThreadManager::Shutdown();
 }
 #endif
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Null) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   EXPECT_EQ(0u, tester.clear_count());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Beacons) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Beacons_WithFilter) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   builder.AddRegisterableDomain(kTestRegisterableDomain1);
 
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_HISTORY, builder);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       builder.BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Contexts) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter()));
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_Contexts_WithFilter) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   builder.AddRegisterableDomain(kTestRegisterableDomain1);
 
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_COOKIES, builder);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
   EXPECT_TRUE(ProbablySameFilters(
       builder.BuildGeneralFilter(), tester.last_filter()));
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_ContextsWin) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_HISTORY | BrowsingDataRemover::REMOVE_COOKIES,
       false);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_ProtectedOrigins) {
   const ClearDomainReliabilityTester& tester =
       clear_domain_reliability_tester();
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, true);
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 // TODO(juliatuttle): This isn't actually testing the no-monitor case, since
 // BrowsingDataRemoverTest now creates one unconditionally, since it's needed
 // for some unrelated test cases. This should be fixed so it tests the no-
 // monitor case again.
 TEST_F(BrowsingDataRemoverTest, DISABLED_DomainReliability_NoMonitor) {
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_HISTORY | BrowsingDataRemover::REMOVE_COOKIES,
       false);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveDownloadsByTimeOnly) {
   RemoveDownloadsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(
       *tester.download_manager(),
       RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_DOWNLOADS, false);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveDownloadsByOrigin) {
   RemoveDownloadsTester tester(GetProfile());
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   builder.AddRegisterableDomain(kTestRegisterableDomain1);
   base::Callback<bool(const GURL&)> filter = builder.BuildGeneralFilter();
 
   EXPECT_CALL(
       *tester.download_manager(),
       RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _));
 
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_DOWNLOADS, builder);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemovePasswordStatistics) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter;
 
   EXPECT_CALL(*tester.store(), RemoveStatisticsByOriginAndTimeImpl(
                                    ProbablySameFilter(empty_filter),
                                    base::Time(), base::Time::Max()));
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_HISTORY, false);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemovePasswordStatisticsByOrigin) {
   RemovePasswordsTester tester(GetProfile());
 
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   builder.AddRegisterableDomain(kTestRegisterableDomain1);
   base::Callback<bool(const GURL&)> filter = builder.BuildGeneralFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveStatisticsByOriginAndTimeImpl(
                   ProbablySameFilter(filter), base::Time(), base::Time::Max()));
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_HISTORY, builder);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemovePasswordsByTimeOnly) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveLoginsByURLAndTimeImpl(ProbablySameFilter(filter), _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_PASSWORDS, false);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemovePasswordsByOrigin) {
   RemovePasswordsTester tester(GetProfile());
   RegistrableDomainFilterBuilder builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   builder.AddRegisterableDomain(kTestRegisterableDomain1);
   base::Callback<bool(const GURL&)> filter = builder.BuildGeneralFilter();
 
   EXPECT_CALL(*tester.store(),
               RemoveLoginsByURLAndTimeImpl(ProbablySameFilter(filter), _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_PASSWORDS, builder);
 }
 
 TEST_F(BrowsingDataRemoverTest, DisableAutoSignIn) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(
       *tester.store(),
       DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter)))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
 }
 
 TEST_F(BrowsingDataRemoverTest, DisableAutoSignInAfterRemovingPasswords) {
   RemovePasswordsTester tester(GetProfile());
   base::Callback<bool(const GURL&)> empty_filter =
       BrowsingDataFilterBuilder::BuildNoopFilter();
 
   EXPECT_CALL(*tester.store(), RemoveLoginsByURLAndTimeImpl(_, _, _))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
   EXPECT_CALL(
       *tester.store(),
       DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter)))
       .WillOnce(Return(password_manager::PasswordStoreChangeList()));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES |
                                     BrowsingDataRemover::REMOVE_PASSWORDS,
                                 false);
 }
 
 TEST_F(BrowsingDataRemoverTest, RemoveContentSettingsWithBlacklist) {
   // Add our settings.
   HostContentSettingsMap* host_content_settings_map =
       HostContentSettingsMapFactory::GetForProfile(GetProfile());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin1, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin2, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin3, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
   host_content_settings_map->SetWebsiteSettingDefaultScope(
       kOrigin4, GURL(), CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(),
       base::MakeUnique<base::DictionaryValue>());
 
   // Clear all except for origin1 and origin3.
   RegistrableDomainFilterBuilder filter(
       RegistrableDomainFilterBuilder::BLACKLIST);
   filter.AddRegisterableDomain(kTestRegisterableDomain1);
   filter.AddRegisterableDomain(kTestRegisterableDomain3);
-  BlockUntilOriginDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
                               filter);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_SITE_USAGE_DATA, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify we only have true, and they're origin1, origin3, and origin4.
   ContentSettingsForOneType host_settings;
   host_content_settings_map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(), &host_settings);
@@ skipping 18 matching lines @@
   durable_permission.UpdateContentSetting(kOrigin1, GURL(),
                                           CONTENT_SETTING_ALLOW);
   durable_permission.UpdateContentSetting(kOrigin2, GURL(),
                                           CONTENT_SETTING_ALLOW);
 
   // Clear all except for origin1 and origin3.
   RegistrableDomainFilterBuilder filter(
       RegistrableDomainFilterBuilder::BLACKLIST);
   filter.AddRegisterableDomain(kTestRegisterableDomain1);
   filter.AddRegisterableDomain(kTestRegisterableDomain3);
-  BlockUntilOriginDataRemoved(browsing_data::LAST_HOUR,
+  BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_DURABLE_PERMISSION,
                               filter);
 
   EXPECT_EQ(BrowsingDataRemover::REMOVE_DURABLE_PERMISSION, GetRemovalMask());
   EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
 
   // Verify we only have allow for the first origin.
   ContentSettingsForOneType host_settings;
   host_content_settings_map->GetSettingsForOneType(
       CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings);
@@ skipping 23 matching lines @@
 
   net::HttpAuthCache* http_auth_cache = http_session->http_auth_cache();
   http_auth_cache->Add(kOrigin1, kTestRealm, net::HttpAuth::AUTH_SCHEME_BASIC,
                        "test challenge",
                        net::AuthCredentials(base::ASCIIToUTF16("foo"),
                                             base::ASCIIToUTF16("bar")),
                        "/");
   CHECK(http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                 net::HttpAuth::AUTH_SCHEME_BASIC));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_COOKIES, false);
 
   EXPECT_EQ(nullptr, http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                              net::HttpAuth::AUTH_SCHEME_BASIC));
 }
 
 // Test that removing passwords clears HTTP auth data.
 TEST_F(BrowsingDataRemoverTest, ClearHttpAuthCache_RemovePasswords) {
   net::HttpNetworkSession* http_session = GetProfile()
                                               ->GetRequestContext()
                                               ->GetURLRequestContext()
                                               ->http_transaction_factory()
                                               ->GetSession();
   DCHECK(http_session);
 
   net::HttpAuthCache* http_auth_cache = http_session->http_auth_cache();
   http_auth_cache->Add(kOrigin1, kTestRealm, net::HttpAuth::AUTH_SCHEME_BASIC,
                        "test challenge",
                        net::AuthCredentials(base::ASCIIToUTF16("foo"),
                                             base::ASCIIToUTF16("bar")),
                        "/");
   CHECK(http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                 net::HttpAuth::AUTH_SCHEME_BASIC));
 
-  BlockUntilBrowsingDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_PASSWORDS, false);
 
   EXPECT_EQ(nullptr, http_auth_cache->Lookup(kOrigin1, kTestRealm,
                                              net::HttpAuth::AUTH_SCHEME_BASIC));
 }
 
 TEST_F(BrowsingDataRemoverTest, ClearPermissionPromptCounts) {
   RemovePermissionPromptCountsTest tester(GetProfile());
 
   RegistrableDomainFilterBuilder filter_builder_1(
@@ skipping 12 matching lines @@
                                      content::PermissionType::GEOLOCATION));
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin1,
                                      content::PermissionType::NOTIFICATIONS));
     tester.ShouldChangeDismissalToBlock(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX);
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin2,
                                      content::PermissionType::DURABLE_STORAGE));
     tester.ShouldChangeDismissalToBlock(kOrigin2,
                                         content::PermissionType::NOTIFICATIONS);
 
-    BlockUntilOriginDataRemoved(browsing_data::LAST_HOUR,
+    BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
                                 filter_builder_1);
 
     // kOrigin1 should be gone, but kOrigin2 remains.
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::GEOLOCATION));
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::NOTIFICATIONS));
     EXPECT_EQ(0, tester.GetDismissCount(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX));
     EXPECT_EQ(1, tester.GetIgnoreCount(
                      kOrigin2, content::PermissionType::DURABLE_STORAGE));
     EXPECT_EQ(1, tester.GetDismissCount(
                      kOrigin2, content::PermissionType::NOTIFICATIONS));
 
-    BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+    BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                   BrowsingDataRemover::REMOVE_HISTORY, false);
 
     // Everything should be gone.
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::GEOLOCATION));
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::NOTIFICATIONS));
     EXPECT_EQ(0, tester.GetDismissCount(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX));
     EXPECT_EQ(0, tester.GetIgnoreCount(
                      kOrigin2, content::PermissionType::DURABLE_STORAGE));
     EXPECT_EQ(0, tester.GetDismissCount(
                      kOrigin2, content::PermissionType::NOTIFICATIONS));
   }
   {
     // Test REMOVE_SITE_DATA.
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin1,
                                      content::PermissionType::GEOLOCATION));
     EXPECT_EQ(2, tester.RecordIgnore(kOrigin1,
                                      content::PermissionType::GEOLOCATION));
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin1,
                                      content::PermissionType::NOTIFICATIONS));
     tester.ShouldChangeDismissalToBlock(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX);
     EXPECT_EQ(1, tester.RecordIgnore(kOrigin2,
                                      content::PermissionType::DURABLE_STORAGE));
     tester.ShouldChangeDismissalToBlock(kOrigin2,
                                         content::PermissionType::NOTIFICATIONS);
 
-    BlockUntilOriginDataRemoved(browsing_data::LAST_HOUR,
+    BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(),
                                 BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
                                 filter_builder_2);
 
     // kOrigin2 should be gone, but kOrigin1 remains.
     EXPECT_EQ(2, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::GEOLOCATION));
     EXPECT_EQ(1, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::NOTIFICATIONS));
     EXPECT_EQ(1, tester.GetDismissCount(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX));
     EXPECT_EQ(0, tester.GetIgnoreCount(
                      kOrigin2, content::PermissionType::DURABLE_STORAGE));
     EXPECT_EQ(0, tester.GetDismissCount(
                      kOrigin2, content::PermissionType::NOTIFICATIONS));
 
-    BlockUntilBrowsingDataRemoved(browsing_data::LAST_HOUR,
+    BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(),
                                   BrowsingDataRemover::REMOVE_SITE_USAGE_DATA,
                                   false);
 
     // Everything should be gone.
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::GEOLOCATION));
     EXPECT_EQ(0, tester.GetIgnoreCount(kOrigin1,
                                        content::PermissionType::NOTIFICATIONS));
     EXPECT_EQ(0, tester.GetDismissCount(kOrigin1,
                                         content::PermissionType::MIDI_SYSEX));
@@ skipping 13 matching lines @@
   tester.AddDomain(kOrigin3.host());
 
   std::vector<std::string> expected = {
       kOrigin1.host(), kOrigin2.host(), kOrigin3.host() };
   EXPECT_EQ(expected, tester.GetDomains());
 
   // Delete data with a filter for the registrable domain of |kOrigin3|.
   RegistrableDomainFilterBuilder filter_builder(
       RegistrableDomainFilterBuilder::WHITELIST);
   filter_builder.AddRegisterableDomain(kTestRegisterableDomain3);
-  BlockUntilOriginDataRemoved(browsing_data::ALL_TIME,
+  BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(),
                               BrowsingDataRemover::REMOVE_PLUGIN_DATA,
                               filter_builder);
 
   // Plugin data for |kOrigin3.host()| should have been removed.
   expected.pop_back();
   EXPECT_EQ(expected, tester.GetDomains());
 
   // TODO(msramek): Mock PluginDataRemover and test the complete deletion
   // of plugin data as well.
 }
@@ skipping 64 matching lines @@
       new RegistrableDomainFilterBuilder(
           RegistrableDomainFilterBuilder::BLACKLIST));
   filter_builder_2->AddRegisterableDomain("example.com");
 
   MultipleTasksObserver observer(remover);
   BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
 
   // Test several tasks with various configuration of masks, filters, and target
   // observers.
   std::list<BrowsingDataRemover::RemovalTask> tasks;
-  tasks.emplace_back(BrowsingDataRemover::Unbounded(),
+  tasks.emplace_back(base::Time(), base::Time::Max(),
                      BrowsingDataRemover::REMOVE_HISTORY,
                      BrowsingDataHelper::UNPROTECTED_WEB,
                      base::MakeUnique<RegistrableDomainFilterBuilder>(
                          RegistrableDomainFilterBuilder::BLACKLIST),
                      observer.target_a());
-  tasks.emplace_back(BrowsingDataRemover::Unbounded(),
+  tasks.emplace_back(base::Time(), base::Time::Max(),
                      BrowsingDataRemover::REMOVE_COOKIES,
                      BrowsingDataHelper::PROTECTED_WEB,
                      base::MakeUnique<RegistrableDomainFilterBuilder>(
                          RegistrableDomainFilterBuilder::BLACKLIST),
                      nullptr);
   tasks.emplace_back(
-      BrowsingDataRemover::TimeRange(base::Time::Now(), base::Time::Max()),
+      base::Time::Now(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_PASSWORDS, BrowsingDataHelper::ALL,
       base::MakeUnique<RegistrableDomainFilterBuilder>(
           RegistrableDomainFilterBuilder::BLACKLIST),
       observer.target_b());
   tasks.emplace_back(
-      BrowsingDataRemover::TimeRange(base::Time(), base::Time::UnixEpoch()),
+      base::Time(), base::Time::UnixEpoch(),
       BrowsingDataRemover::REMOVE_WEBSQL,
       BrowsingDataHelper::UNPROTECTED_WEB,
       std::move(filter_builder_1),
       observer.target_b());
   tasks.emplace_back(
-      BrowsingDataRemover::TimeRange(
-          base::Time::UnixEpoch(), base::Time::Now()),
+      base::Time::UnixEpoch(), base::Time::Now(),
       BrowsingDataRemover::REMOVE_CHANNEL_IDS,
       BrowsingDataHelper::ALL,
       std::move(filter_builder_2),
       nullptr);
 
   for (BrowsingDataRemover::RemovalTask& task : tasks) {
     // All tasks can be directly translated to a RemoveInternal() call. Since
     // that is a private method, we must call the four public versions of
     // Remove.* instead. This also serves as a test that those methods are all
     // correctly reduced to RemoveInternal().
     if (!task.observer && task.filter_builder->IsEmptyBlacklist()) {
-      remover->Remove(task.time_range, task.remove_mask, task.origin_type_mask);
+      remover->Remove(task.delete_begin, task.delete_end,
+                      task.remove_mask, task.origin_type_mask);
     } else if (task.filter_builder->IsEmptyBlacklist()) {
-      remover->RemoveAndReply(task.time_range, task.remove_mask,
-                              task.origin_type_mask, task.observer);
+      remover->RemoveAndReply(task.delete_begin, task.delete_end,
+                              task.remove_mask, task.origin_type_mask,
+                              task.observer);
     } else if (!task.observer) {
-      remover->RemoveWithFilter(task.time_range, task.remove_mask,
-                                task.origin_type_mask,
+      remover->RemoveWithFilter(task.delete_begin, task.delete_end,
+                                task.remove_mask, task.origin_type_mask,
                                 std::move(task.filter_builder));
     } else {
-      remover->RemoveWithFilterAndReply(task.time_range, task.remove_mask,
-                                        task.origin_type_mask,
+      remover->RemoveWithFilterAndReply(task.delete_begin, task.delete_end,
+                                        task.remove_mask, task.origin_type_mask,
                                         std::move(task.filter_builder),
                                         task.observer);
     }
   }
 
   // Use the inhibitor to stop after every task and check the results.
   for (BrowsingDataRemover::RemovalTask& task : tasks) {
     EXPECT_TRUE(remover->is_removing());
     observer.ClearLastCalledTarget();
 
     // Finish the task execution synchronously.
     completion_inhibitor.BlockUntilNearCompletion();
     completion_inhibitor.ContinueToCompletion();
 
     // Observers, if any, should have been called by now (since we call
     // observers on the same thread).
     EXPECT_EQ(task.observer, observer.GetLastCalledTarget());
 
     // TODO(msramek): If BrowsingDataRemover took ownership of the last used
     // filter builder and exposed it, we could also test it here. Make it so.
     EXPECT_EQ(task.remove_mask, GetRemovalMask());
     EXPECT_EQ(task.origin_type_mask, GetOriginTypeMask());
-    EXPECT_EQ(task.time_range.begin, GetBeginTime());
+    EXPECT_EQ(task.delete_begin, GetBeginTime());
   }
 
   EXPECT_FALSE(remover->is_removing());
 }
 
 // The previous test, BrowsingDataRemoverTest.MultipleTasks, tests that the
 // tasks are not mixed up and they are executed in a correct order. However,
 // the completion inhibitor kept synchronizing the execution in order to verify
 // the parameters. This test demonstrates that even running the tasks without
 // inhibition is executed correctly and doesn't crash.
@@ skipping 14 matching lines @@
       BrowsingDataRemover::REMOVE_COOKIES | BrowsingDataRemover::REMOVE_HISTORY,
       BrowsingDataRemover::REMOVE_COOKIES | BrowsingDataRemover::REMOVE_HISTORY,
       BrowsingDataRemover::REMOVE_COOKIES |
           BrowsingDataRemover::REMOVE_HISTORY |
           BrowsingDataRemover::REMOVE_PASSWORDS,
       BrowsingDataRemover::REMOVE_PASSWORDS,
       BrowsingDataRemover::REMOVE_PASSWORDS,
   };
 
   for (int removal_mask : test_removal_masks) {
-    remover->Remove(BrowsingDataRemover::Unbounded(), removal_mask,
+    remover->Remove(base::Time(), base::Time::Max(), removal_mask,
                     BrowsingDataHelper::UNPROTECTED_WEB);
   }
 
   EXPECT_TRUE(remover->is_removing());
 
   // Add one more deletion and wait for it.
   BlockUntilBrowsingDataRemoved(
-      browsing_data::ALL_TIME,
+      base::Time(), base::Time::Max(),
       BrowsingDataRemover::REMOVE_COOKIES,
       BrowsingDataHelper::UNPROTECTED_WEB);
 
   EXPECT_FALSE(remover->is_removing());
 }
 
 // Test that the remover clears bookmark meta data (normally added in a tab
 // helper).
 TEST_F(BrowsingDataRemoverTest, BookmarkLastVisitDatesGetCleared) {
   TestingProfile profile;
@@ skipping 23 matching lines @@
   EXPECT_THAT(ntp_snippets::GetRecentlyVisitedBookmarks(
                   bookmark_model, 2, base::Time::UnixEpoch(),
                   /*consider_visits_from_desktop=*/false),
               Not(IsEmpty()));
 
   // Inject the bookmark model into the remover.
   BrowsingDataRemover* remover =
       BrowsingDataRemoverFactory::GetForBrowserContext(&profile);
 
   BrowsingDataRemoverCompletionObserver completion_observer(remover);
-  remover->RemoveAndReply(BrowsingDataRemover::Unbounded(),
+  remover->RemoveAndReply(base::Time(), base::Time::Max(),
                           BrowsingDataRemover::REMOVE_HISTORY,
                           BrowsingDataHelper::ALL, &completion_observer);
   completion_observer.BlockUntilCompletion();
 
   // There should be no recently visited bookmarks.
   EXPECT_THAT(ntp_snippets::GetRecentlyVisitedBookmarks(
                   bookmark_model, 2, base::Time::UnixEpoch(),
                   /*consider_visits_from_desktop=*/false),
               IsEmpty());
   EXPECT_THAT(ntp_snippets::GetRecentlyVisitedBookmarks(
                   bookmark_model, 2, base::Time::UnixEpoch(),
                   /*consider_visits_from_desktop=*/true),
               IsEmpty());
 }