Revert of Split BrowsingDataRemoverTest into two tests for Impl and Delegate.

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 <stddef.h>
+#include <stdint.h>
+
+#include <list>
+#include <memory>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/guid.h"
+#include "base/location.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/memory/ptr_util.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/task/cancelable_task_tracker.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "build/build_config.h"
+#include "chrome/browser/autofill/personal_data_manager_factory.h"
+#include "chrome/browser/bookmarks/bookmark_model_factory.h"
+#include "chrome/browser/browsing_data/browsing_data_filter_builder.h"
+#include "chrome/browser/browsing_data/browsing_data_helper.h"
+#include "chrome/browser/browsing_data/browsing_data_remover.h"
+#include "chrome/browser/browsing_data/browsing_data_remover_factory.h"
+#include "chrome/browser/browsing_data/browsing_data_remover_impl.h"
+#include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
+#include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h"
+#include "chrome/browser/browsing_data/registrable_domain_filter_builder.h"
+#include "chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "chrome/browser/domain_reliability/service_factory.h"
+#include "chrome/browser/download/chrome_download_manager_delegate.h"
+#include "chrome/browser/favicon/favicon_service_factory.h"
+#include "chrome/browser/history/history_service_factory.h"
+#include "chrome/browser/password_manager/password_store_factory.h"
+#include "chrome/browser/permissions/permission_decision_auto_blocker.h"
+#include "chrome/browser/safe_browsing/safe_browsing_service.h"
+#include "chrome/browser/storage/durable_storage_permission_context.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_profile.h"
+#include "components/autofill/core/browser/autofill_profile.h"
+#include "components/autofill/core/browser/autofill_test_utils.h"
+#include "components/autofill/core/browser/credit_card.h"
+#include "components/autofill/core/browser/personal_data_manager.h"
+#include "components/autofill/core/browser/personal_data_manager_observer.h"
+#include "components/autofill/core/common/autofill_constants.h"
+#include "components/bookmarks/browser/bookmark_model.h"
+#include "components/bookmarks/test/bookmark_test_helpers.h"
+#include "components/browsing_data/core/browsing_data_utils.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/domain_reliability/clear_mode.h"
+#include "components/domain_reliability/monitor.h"
+#include "components/domain_reliability/service.h"
+#include "components/favicon/core/favicon_service.h"
+#include "components/history/core/browser/history_service.h"
+#include "components/ntp_snippets/bookmarks/bookmark_last_visit_utils.h"
+#include "components/omnibox/browser/omnibox_pref_names.h"
+#include "components/os_crypt/os_crypt_mocker.h"
+#include "components/password_manager/core/browser/mock_password_store.h"
+#include "components/password_manager/core/browser/password_manager_test_utils.h"
+#include "components/password_manager/core/browser/password_store_consumer.h"
+#include "components/prefs/testing_pref_service.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/cookie_store_factory.h"
+#include "content/public/browser/dom_storage_context.h"
+#include "content/public/browser/local_storage_usage_info.h"
+#include "content/public/browser/permission_type.h"
+#include "content/public/browser/storage_partition.h"
+#include "content/public/test/mock_download_manager.h"
+#include "content/public/test/test_browser_thread.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "content/public/test/test_utils.h"
+#include "extensions/features/features.h"
+#include "net/cookies/cookie_store.h"
+#include "net/http/http_network_session.h"
+#include "net/http/http_transaction_factory.h"
+#include "net/ssl/channel_id_service.h"
+#include "net/ssl/channel_id_store.h"
+#include "net/ssl/ssl_client_cert_type.h"
+#include "net/url_request/url_request_context.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "ppapi/features/features.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/skia/include/core/SkBitmap.h"
+#include "ui/gfx/favicon_size.h"
+#include "url/origin.h"
+
+#if defined(OS_ANDROID)
+#include "chrome/browser/android/webapps/webapp_registry.h"
+#endif
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/login/users/mock_user_manager.h"
+#include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
+#include "chrome/browser/chromeos/settings/cros_settings.h"
+#include "chrome/browser/chromeos/settings/device_settings_service.h"
+#include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/mock_cryptohome_client.h"
+#include "components/signin/core/account_id/account_id.h"
+#endif
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/mock_extension_special_storage_policy.h"
+#endif
+
+#if BUILDFLAG(ENABLE_PLUGINS)
+#include "chrome/browser/browsing_data/mock_browsing_data_flash_lso_helper.h"
+#endif
+
+class MockExtensionSpecialStoragePolicy;
+
+using content::BrowserThread;
+using content::StoragePartition;
+using domain_reliability::CLEAR_BEACONS;
+using domain_reliability::CLEAR_CONTEXTS;
+using domain_reliability::DomainReliabilityClearMode;
+using domain_reliability::DomainReliabilityMonitor;
+using domain_reliability::DomainReliabilityService;
+using domain_reliability::DomainReliabilityServiceFactory;
+using testing::_;
+using testing::ByRef;
+using testing::Eq;
+using testing::Invoke;
+using testing::IsEmpty;
+using testing::Matcher;
+using testing::MakeMatcher;
+using testing::MatcherInterface;
+using testing::MatchResultListener;
+using testing::Not;
+using testing::Return;
+using testing::SizeIs;
+using testing::WithArgs;
+
+namespace {
+
+const char kTestOrigin1[] = "http://host1.com:1/";
+const char kTestRegisterableDomain1[] = "host1.com";
+const char kTestOrigin2[] = "http://host2.com:1/";
+const char kTestOrigin3[] = "http://host3.com:1/";
+const char kTestRegisterableDomain3[] = "host3.com";
+const char kTestOrigin4[] = "https://host3.com:1/";
+const char kTestOriginExt[] = "chrome-extension://abcdefghijklmnopqrstuvwxyz/";
+const char kTestOriginDevTools[] = "chrome-devtools://abcdefghijklmnopqrstuvw/";
+
+// For Autofill.
+const char kWebOrigin[] = "https://www.example.com/";
+
+// For HTTP auth.
+const char kTestRealm[] = "TestRealm";
+
+const GURL kOrigin1(kTestOrigin1);
+const GURL kOrigin2(kTestOrigin2);
+const GURL kOrigin3(kTestOrigin3);
+const GURL kOrigin4(kTestOrigin4);
+const GURL kOriginExt(kTestOriginExt);
+const GURL kOriginDevTools(kTestOriginDevTools);
+
+const base::FilePath::CharType kDomStorageOrigin1[] =
+    FILE_PATH_LITERAL("http_host1_1.localstorage");
+
+const base::FilePath::CharType kDomStorageOrigin2[] =
+    FILE_PATH_LITERAL("http_host2_1.localstorage");
+
+const base::FilePath::CharType kDomStorageOrigin3[] =
+    FILE_PATH_LITERAL("http_host3_1.localstorage");
+
+const base::FilePath::CharType kDomStorageExt[] = FILE_PATH_LITERAL(
+    "chrome-extension_abcdefghijklmnopqrstuvwxyz_0.localstorage");
+
+#if defined(OS_CHROMEOS)
+void FakeDBusCall(const chromeos::BoolDBusMethodCallback& callback) {
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE,
+      base::Bind(callback, chromeos::DBUS_METHOD_CALL_SUCCESS, true));
+}
+#endif
+
+struct StoragePartitionRemovalData {
+  uint32_t remove_mask = 0;
+  uint32_t quota_storage_remove_mask = 0;
+  base::Time remove_begin;
+  base::Time remove_end;
+  StoragePartition::OriginMatcherFunction origin_matcher;
+  StoragePartition::CookieMatcherFunction cookie_matcher;
+
+  StoragePartitionRemovalData() {}
+};
+
+net::CanonicalCookie CreateCookieWithHost(const GURL& source) {
+  std::unique_ptr<net::CanonicalCookie> cookie(net::CanonicalCookie::Create(
+      source, "A", "1", std::string(), "/", base::Time::Now(),
+      base::Time::Now(), false, false, net::CookieSameSite::DEFAULT_MODE, false,
+      net::COOKIE_PRIORITY_MEDIUM));
+  EXPECT_TRUE(cookie);
+  return *cookie;
+}
+
+class TestStoragePartition : public StoragePartition {
+ public:
+  TestStoragePartition() {}
+  ~TestStoragePartition() override {}
+
+  // content::StoragePartition implementation.
+  base::FilePath GetPath() override { return base::FilePath(); }
+  net::URLRequestContextGetter* GetURLRequestContext() override {
+    return nullptr;
+  }
+  net::URLRequestContextGetter* GetMediaURLRequestContext() override {
+    return nullptr;
+  }
+  storage::QuotaManager* GetQuotaManager() override { return nullptr; }
+  content::AppCacheService* GetAppCacheService() override { return nullptr; }
+  storage::FileSystemContext* GetFileSystemContext() override {
+    return nullptr;
+  }
+  storage::DatabaseTracker* GetDatabaseTracker() override { return nullptr; }
+  content::DOMStorageContext* GetDOMStorageContext() override {
+    return nullptr;
+  }
+  content::IndexedDBContext* GetIndexedDBContext() override { return nullptr; }
+  content::ServiceWorkerContext* GetServiceWorkerContext() override {
+    return nullptr;
+  }
+  content::CacheStorageContext* GetCacheStorageContext() override {
+    return nullptr;
+  }
+  content::PlatformNotificationContext* GetPlatformNotificationContext()
+      override {
+    return nullptr;
+  }
+  content::HostZoomMap* GetHostZoomMap() override { return nullptr; }
+  content::HostZoomLevelContext* GetHostZoomLevelContext() override {
+    return nullptr;
+  }
+  content::ZoomLevelDelegate* GetZoomLevelDelegate() override {
+    return nullptr;
+  }
+
+  void ClearDataForOrigin(uint32_t remove_mask,
+                          uint32_t quota_storage_remove_mask,
+                          const GURL& storage_origin,
+                          net::URLRequestContextGetter* rq_context,
+                          const base::Closure& callback) override {
+    BrowserThread::PostTask(BrowserThread::UI,
+                            FROM_HERE,
+                            base::Bind(&TestStoragePartition::AsyncRunCallback,
+                                       base::Unretained(this),
+                                       callback));
+  }
+
+  void ClearData(uint32_t remove_mask,
+                 uint32_t quota_storage_remove_mask,
+                 const GURL& storage_origin,
+                 const OriginMatcherFunction& origin_matcher,
+                 const base::Time begin,
+                 const base::Time end,
+                 const base::Closure& callback) override {
+    // Store stuff to verify parameters' correctness later.
+    storage_partition_removal_data_.remove_mask = remove_mask;
+    storage_partition_removal_data_.quota_storage_remove_mask =
+        quota_storage_remove_mask;
+    storage_partition_removal_data_.remove_begin = begin;
+    storage_partition_removal_data_.remove_end = end;
+    storage_partition_removal_data_.origin_matcher = origin_matcher;
+
+    BrowserThread::PostTask(
+        BrowserThread::UI,
+        FROM_HERE,
+        base::Bind(&TestStoragePartition::AsyncRunCallback,
+                   base::Unretained(this), callback));
+  }
+
+  void ClearData(uint32_t remove_mask,
+                 uint32_t quota_storage_remove_mask,
+                 const OriginMatcherFunction& origin_matcher,
+                 const CookieMatcherFunction& cookie_matcher,
+                 const base::Time begin,
+                 const base::Time end,
+                 const base::Closure& callback) override {
+    // Store stuff to verify parameters' correctness later.
+    storage_partition_removal_data_.remove_mask = remove_mask;
+    storage_partition_removal_data_.quota_storage_remove_mask =
+        quota_storage_remove_mask;
+    storage_partition_removal_data_.remove_begin = begin;
+    storage_partition_removal_data_.remove_end = end;
+    storage_partition_removal_data_.origin_matcher = origin_matcher;
+    storage_partition_removal_data_.cookie_matcher = cookie_matcher;
+
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            base::Bind(&TestStoragePartition::AsyncRunCallback,
+                                       base::Unretained(this), callback));
+  }
+
+  void Flush() override {}
+
+  StoragePartitionRemovalData GetStoragePartitionRemovalData() {
+    return storage_partition_removal_data_;
+  }
+
+ private:
+  void AsyncRunCallback(const base::Closure& callback) {
+    callback.Run();
+  }
+
+  StoragePartitionRemovalData storage_partition_removal_data_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestStoragePartition);
+};
+
+#if defined(OS_ANDROID)
+class TestWebappRegistry : public WebappRegistry {
+ public:
+  TestWebappRegistry() : WebappRegistry() { }
+
+  void UnregisterWebappsForUrls(
+      const base::Callback<bool(const GURL&)>& url_filter) override {
+    // Mocks out a JNI call.
+  }
+
+  void ClearWebappHistoryForUrls(
+      const base::Callback<bool(const GURL&)>& url_filter) override {
+    // Mocks out a JNI call.
+  }
+};
+#endif
+
+// Custom matcher to test the equivalence of two URL filters. Since those are
+// blackbox predicates, we can only approximate the equivalence by testing
+// whether the filter give the same answer for several URLs. This is currently
+// good enough for our testing purposes, to distinguish whitelists
+// and blacklists, empty and non-empty filters and such.
+// TODO(msramek): BrowsingDataRemover and some of its backends support URL
+// filters, but its constructor currently only takes a single URL and constructs
+// its own url filter. If an url filter was directly passed to
+// BrowsingDataRemover (what should eventually be the case), we can use the same
+// instance in the test as well, and thus simply test base::Callback::Equals()
+// in this matcher.
+class ProbablySameFilterMatcher
+    : public MatcherInterface<const base::Callback<bool(const GURL&)>&> {
+ public:
+  explicit ProbablySameFilterMatcher(
+      const base::Callback<bool(const GURL&)>& filter)
+      : to_match_(filter) {
+  }
+
+  virtual bool MatchAndExplain(const base::Callback<bool(const GURL&)>& filter,
+                               MatchResultListener* listener) const {
+    if (filter.is_null() && to_match_.is_null())
+      return true;
+    if (filter.is_null() != to_match_.is_null())
+      return false;
+
+    const GURL urls_to_test_[] =
+        {kOrigin1, kOrigin2, kOrigin3, GURL("invalid spec")};
+    for (GURL url : urls_to_test_) {
+      if (filter.Run(url) != to_match_.Run(url)) {
+        if (listener)
+          *listener << "The filters differ on the URL " << url;
+        return false;
+      }
+    }
+    return true;
+  }
+
+  virtual void DescribeTo(::std::ostream* os) const {
+    *os << "is probably the same url filter as " << &to_match_;
+  }
+
+  virtual void DescribeNegationTo(::std::ostream* os) const {
+    *os << "is definitely NOT the same url filter as " << &to_match_;
+  }
+
+ private:
+  const base::Callback<bool(const GURL&)>& to_match_;
+};
+
+inline Matcher<const base::Callback<bool(const GURL&)>&> ProbablySameFilter(
+    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() {
+    scoped_refptr<content::MessageLoopRunner> message_loop_runner =
+        new content::MessageLoopRunner;
+    quit_closure_ = message_loop_runner->QuitClosure();
+    get_cookie_success_ = false;
+    cookie_store_->GetCookiesWithOptionsAsync(
+        kOrigin1, net::CookieOptions(),
+        base::Bind(&RemoveCookieTester::GetCookieCallback,
+                   base::Unretained(this)));
+    message_loop_runner->Run();
+    return get_cookie_success_;
+  }
+
+  void AddCookie() {
+    scoped_refptr<content::MessageLoopRunner> message_loop_runner =
+        new content::MessageLoopRunner;
+    quit_closure_ = message_loop_runner->QuitClosure();
+    cookie_store_->SetCookieWithOptionsAsync(
+        kOrigin1, "A=1", net::CookieOptions(),
+        base::Bind(&RemoveCookieTester::SetCookieCallback,
+                   base::Unretained(this)));
+    message_loop_runner->Run();
+  }
+
+ protected:
+  void SetCookieStore(net::CookieStore* cookie_store) {
+    cookie_store_ = cookie_store;
+  }
+
+ private:
+  void GetCookieCallback(const std::string& cookies) {
+    if (cookies == "A=1") {
+      get_cookie_success_ = true;
+    } else {
+      EXPECT_EQ("", cookies);
+      get_cookie_success_ = false;
+    }
+    quit_closure_.Run();
+  }
+
+  void SetCookieCallback(bool result) {
+    ASSERT_TRUE(result);
+    quit_closure_.Run();
+  }
+
+  bool get_cookie_success_ = false;
+  base::Closure quit_closure_;
+
+  // CookieStore must out live |this|.
+  net::CookieStore* cookie_store_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveCookieTester);
+};
+
+void RunClosureAfterCookiesCleared(const base::Closure& task,
+                                   int cookies_deleted) {
+  task.Run();
+}
+
+class RemoveSafeBrowsingCookieTester : public RemoveCookieTester {
+ public:
+  RemoveSafeBrowsingCookieTester()
+      : browser_process_(TestingBrowserProcess::GetGlobal()) {
+    scoped_refptr<safe_browsing::SafeBrowsingService> sb_service =
+        safe_browsing::SafeBrowsingService::CreateSafeBrowsingService();
+    browser_process_->SetSafeBrowsingService(sb_service.get());
+    sb_service->Initialize();
+    base::RunLoop().RunUntilIdle();
+
+    // Make sure the safe browsing cookie store has no cookies.
+    // TODO(mmenke): Is this really needed?
+    base::RunLoop run_loop;
+    net::URLRequestContext* request_context =
+        sb_service->url_request_context()->GetURLRequestContext();
+    request_context->cookie_store()->DeleteAllAsync(
+        base::Bind(&RunClosureAfterCookiesCleared, run_loop.QuitClosure()));
+    run_loop.Run();
+
+    SetCookieStore(request_context->cookie_store());
+  }
+
+  virtual ~RemoveSafeBrowsingCookieTester() {
+    browser_process_->safe_browsing_service()->ShutDown();
+    base::RunLoop().RunUntilIdle();
+    browser_process_->SetSafeBrowsingService(nullptr);
+  }
+
+ private:
+  TestingBrowserProcess* browser_process_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveSafeBrowsingCookieTester);
+};
+
+class RemoveChannelIDTester : public net::SSLConfigService::Observer {
+ public:
+  explicit RemoveChannelIDTester(TestingProfile* profile) {
+    channel_id_service_ = profile->GetRequestContext()->
+        GetURLRequestContext()->channel_id_service();
+    ssl_config_service_ = profile->GetSSLConfigService();
+    ssl_config_service_->AddObserver(this);
+  }
+
+  ~RemoveChannelIDTester() override {
+    ssl_config_service_->RemoveObserver(this);
+  }
+
+  int ChannelIDCount() { return channel_id_service_->channel_id_count(); }
+
+  // Add a server bound cert for |server| with specific creation and expiry
+  // times.  The cert and key data will be filled with dummy values.
+  void AddChannelIDWithTimes(const std::string& server_identifier,
+                             base::Time creation_time) {
+    GetChannelIDStore()->SetChannelID(
+        base::MakeUnique<net::ChannelIDStore::ChannelID>(
+            server_identifier, creation_time, crypto::ECPrivateKey::Create()));
+  }
+
+  // Add a server bound cert for |server|, with the current time as the
+  // creation time.  The cert and key data will be filled with dummy values.
+  void AddChannelID(const std::string& server_identifier) {
+    base::Time now = base::Time::Now();
+    AddChannelIDWithTimes(server_identifier, now);
+  }
+
+  void GetChannelIDList(net::ChannelIDStore::ChannelIDList* channel_ids) {
+    GetChannelIDStore()->GetAllChannelIDs(
+        base::Bind(&RemoveChannelIDTester::GetAllChannelIDsCallback,
+                   channel_ids));
+  }
+
+  net::ChannelIDStore* GetChannelIDStore() {
+    return channel_id_service_->GetChannelIDStore();
+  }
+
+  int ssl_config_changed_count() const {
+    return ssl_config_changed_count_;
+  }
+
+  // net::SSLConfigService::Observer implementation:
+  void OnSSLConfigChanged() override { ssl_config_changed_count_++; }
+
+ private:
+  static void GetAllChannelIDsCallback(
+      net::ChannelIDStore::ChannelIDList* dest,
+      const net::ChannelIDStore::ChannelIDList& result) {
+    *dest = result;
+  }
+
+  net::ChannelIDService* channel_id_service_;
+  scoped_refptr<net::SSLConfigService> ssl_config_service_;
+  int ssl_config_changed_count_ = 0;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveChannelIDTester);
+};
+
+class RemoveHistoryTester {
+ public:
+  RemoveHistoryTester() {}
+
+  bool Init(TestingProfile* profile) WARN_UNUSED_RESULT {
+    if (!profile->CreateHistoryService(true, false))
+      return false;
+    history_service_ = HistoryServiceFactory::GetForProfile(
+        profile, ServiceAccessType::EXPLICIT_ACCESS);
+    return true;
+  }
+
+  // Returns true, if the given URL exists in the history service.
+  bool HistoryContainsURL(const GURL& url) {
+    scoped_refptr<content::MessageLoopRunner> message_loop_runner =
+        new content::MessageLoopRunner;
+    quit_closure_ = message_loop_runner->QuitClosure();
+    history_service_->QueryURL(
+        url,
+        true,
+        base::Bind(&RemoveHistoryTester::SaveResultAndQuit,
+                   base::Unretained(this)),
+        &tracker_);
+    message_loop_runner->Run();
+    return query_url_success_;
+  }
+
+  void AddHistory(const GURL& url, base::Time time) {
+    history_service_->AddPage(url, time, nullptr, 0, GURL(),
+                              history::RedirectList(), ui::PAGE_TRANSITION_LINK,
+                              history::SOURCE_BROWSED, false);
+  }
+
+ private:
+  // Callback for HistoryService::QueryURL.
+  void SaveResultAndQuit(bool success,
+                         const history::URLRow&,
+                         const history::VisitVector&) {
+    query_url_success_ = success;
+    quit_closure_.Run();
+  }
+
+  // For History requests.
+  base::CancelableTaskTracker tracker_;
+  bool query_url_success_ = false;
+  base::Closure quit_closure_;
+
+  // TestingProfile owns the history service; we shouldn't delete it.
+  history::HistoryService* history_service_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveHistoryTester);
+};
+
+class RemoveFaviconTester {
+ public:
+  RemoveFaviconTester() {}
+
+  bool Init(TestingProfile* profile) WARN_UNUSED_RESULT {
+    // Create the history service if it has not been created yet.
+    history_service_ = HistoryServiceFactory::GetForProfile(
+        profile, ServiceAccessType::EXPLICIT_ACCESS);
+    if (!history_service_) {
+      if (!profile->CreateHistoryService(true, false))
+        return false;
+      history_service_ = HistoryServiceFactory::GetForProfile(
+          profile, ServiceAccessType::EXPLICIT_ACCESS);
+    }
+
+    profile->CreateFaviconService();
+    favicon_service_ = FaviconServiceFactory::GetForProfile(
+        profile, ServiceAccessType::EXPLICIT_ACCESS);
+    return true;
+  }
+
+  // Returns true if there is a favicon stored for |page_url| in the favicon
+  // database.
+  bool HasFaviconForPageURL(const GURL& page_url) {
+    RequestFaviconSyncForPageURL(page_url);
+    return got_favicon_;
+  }
+
+  // Returns true if:
+  // - There is a favicon stored for |page_url| in the favicon database.
+  // - The stored favicon is expired.
+  bool HasExpiredFaviconForPageURL(const GURL& page_url) {
+    RequestFaviconSyncForPageURL(page_url);
+    return got_expired_favicon_;
+  }
+
+  // Adds a visit to history and stores an arbitrary favicon bitmap for
+  // |page_url|.
+  void VisitAndAddFavicon(const GURL& page_url) {
+    history_service_->AddPage(page_url, base::Time::Now(), nullptr, 0, GURL(),
+        history::RedirectList(), ui::PAGE_TRANSITION_LINK,
+        history::SOURCE_BROWSED, false);
+
+    SkBitmap bitmap;
+    bitmap.allocN32Pixels(gfx::kFaviconSize, gfx::kFaviconSize);
+    bitmap.eraseColor(SK_ColorBLUE);
+    favicon_service_->SetFavicons(page_url, page_url, favicon_base::FAVICON,
+                                  gfx::Image::CreateFrom1xBitmap(bitmap));
+  }
+
+ private:
+  // Synchronously requests the favicon for |page_url| from the favicon
+  // database.
+  void RequestFaviconSyncForPageURL(const GURL& page_url) {
+    base::RunLoop run_loop;
+    quit_closure_ = run_loop.QuitClosure();
+    favicon_service_->GetRawFaviconForPageURL(
+        page_url,
+        favicon_base::FAVICON,
+        gfx::kFaviconSize,
+        base::Bind(&RemoveFaviconTester::SaveResultAndQuit,
+                   base::Unretained(this)),
+        &tracker_);
+    run_loop.Run();
+  }
+
+  // Callback for HistoryService::QueryURL.
+  void SaveResultAndQuit(const favicon_base::FaviconRawBitmapResult& result) {
+    got_favicon_ = result.is_valid();
+    got_expired_favicon_ = result.is_valid() && result.expired;
+    quit_closure_.Run();
+  }
+
+  // For favicon requests.
+  base::CancelableTaskTracker tracker_;
+  bool got_favicon_ = false;
+  bool got_expired_favicon_ = false;
+  base::Closure quit_closure_;
+
+  // Owned by TestingProfile.
+  history::HistoryService* history_service_ = nullptr;
+  favicon::FaviconService* favicon_service_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveFaviconTester);
+};
+
+class RemoveAutofillTester : public autofill::PersonalDataManagerObserver {
+ public:
+  explicit RemoveAutofillTester(TestingProfile* profile)
+      : personal_data_manager_(
+            autofill::PersonalDataManagerFactory::GetForProfile(profile)) {
+    autofill::test::DisableSystemServices(profile->GetPrefs());
+    personal_data_manager_->AddObserver(this);
+  }
+
+  ~RemoveAutofillTester() override {
+    personal_data_manager_->RemoveObserver(this);
+    autofill::test::ReenableSystemServices();
+  }
+
+  // Returns true if there are autofill profiles.
+  bool HasProfile() {
+    return !personal_data_manager_->GetProfiles().empty() &&
+           !personal_data_manager_->GetCreditCards().empty();
+  }
+
+  bool HasOrigin(const std::string& origin) {
+    const std::vector<autofill::AutofillProfile*>& profiles =
+        personal_data_manager_->GetProfiles();
+    for (const autofill::AutofillProfile* profile : profiles) {
+      if (profile->origin() == origin)
+        return true;
+    }
+
+    const std::vector<autofill::CreditCard*>& credit_cards =
+        personal_data_manager_->GetCreditCards();
+    for (const autofill::CreditCard* credit_card : credit_cards) {
+      if (credit_card->origin() == origin)
+        return true;
+    }
+
+    return false;
+  }
+
+  // Add two profiles and two credit cards to the database.  In each pair, one
+  // entry has a web origin and the other has a Chrome origin.
+  void AddProfilesAndCards() {
+    std::vector<autofill::AutofillProfile> profiles;
+    autofill::AutofillProfile profile;
+    profile.set_guid(base::GenerateGUID());
+    profile.set_origin(kWebOrigin);
+    profile.SetRawInfo(autofill::NAME_FIRST, base::ASCIIToUTF16("Bob"));
+    profile.SetRawInfo(autofill::NAME_LAST, base::ASCIIToUTF16("Smith"));
+    profile.SetRawInfo(autofill::ADDRESS_HOME_ZIP, base::ASCIIToUTF16("94043"));
+    profile.SetRawInfo(autofill::EMAIL_ADDRESS,
+                       base::ASCIIToUTF16("sue@example.com"));
+    profile.SetRawInfo(autofill::COMPANY_NAME, base::ASCIIToUTF16("Company X"));
+    profiles.push_back(profile);
+
+    profile.set_guid(base::GenerateGUID());
+    profile.set_origin(autofill::kSettingsOrigin);
+    profiles.push_back(profile);
+
+    personal_data_manager_->SetProfiles(&profiles);
+    base::RunLoop().Run();
+
+    std::vector<autofill::CreditCard> cards;
+    autofill::CreditCard card;
+    card.set_guid(base::GenerateGUID());
+    card.set_origin(kWebOrigin);
+    card.SetRawInfo(autofill::CREDIT_CARD_NUMBER,
+                    base::ASCIIToUTF16("1234-5678-9012-3456"));
+    cards.push_back(card);
+
+    card.set_guid(base::GenerateGUID());
+    card.set_origin(autofill::kSettingsOrigin);
+    cards.push_back(card);
+
+    personal_data_manager_->SetCreditCards(&cards);
+    base::RunLoop().Run();
+  }
+
+ private:
+  void OnPersonalDataChanged() override {
+    base::MessageLoop::current()->QuitWhenIdle();
+  }
+
+  autofill::PersonalDataManager* personal_data_manager_;
+  DISALLOW_COPY_AND_ASSIGN(RemoveAutofillTester);
+};
+
+class RemoveLocalStorageTester {
+ public:
+  explicit RemoveLocalStorageTester(TestingProfile* profile)
+      : profile_(profile) {
+    dom_storage_context_ =
+        content::BrowserContext::GetDefaultStoragePartition(profile)->
+            GetDOMStorageContext();
+  }
+
+  // Returns true, if the given origin URL exists.
+  bool DOMStorageExistsForOrigin(const GURL& origin) {
+    scoped_refptr<content::MessageLoopRunner> message_loop_runner =
+        new content::MessageLoopRunner;
+    quit_closure_ = message_loop_runner->QuitClosure();
+    GetLocalStorageUsage();
+    message_loop_runner->Run();
+    for (size_t i = 0; i < infos_.size(); ++i) {
+      if (origin == infos_[i].origin)
+        return true;
+    }
+    return false;
+  }
+
+  void AddDOMStorageTestData() {
+    // Note: This test depends on details of how the dom_storage library
+    // stores data in the host file system.
+    base::FilePath storage_path =
+        profile_->GetPath().AppendASCII("Local Storage");
+    base::CreateDirectory(storage_path);
+
+    // Write some files.
+    base::WriteFile(storage_path.Append(kDomStorageOrigin1), nullptr, 0);
+    base::WriteFile(storage_path.Append(kDomStorageOrigin2), nullptr, 0);
+    base::WriteFile(storage_path.Append(kDomStorageOrigin3), nullptr, 0);
+    base::WriteFile(storage_path.Append(kDomStorageExt), nullptr, 0);
+
+    // Tweak their dates.
+    base::Time now = base::Time::Now();
+    base::TouchFile(storage_path.Append(kDomStorageOrigin1), now, now);
+
+    base::Time one_day_ago = now - base::TimeDelta::FromDays(1);
+    base::TouchFile(storage_path.Append(kDomStorageOrigin2),
+                    one_day_ago, one_day_ago);
+
+    base::Time sixty_days_ago = now - base::TimeDelta::FromDays(60);
+    base::TouchFile(storage_path.Append(kDomStorageOrigin3),
+                    sixty_days_ago, sixty_days_ago);
+
+    base::TouchFile(storage_path.Append(kDomStorageExt), now, now);
+  }
+
+ private:
+  void GetLocalStorageUsage() {
+    dom_storage_context_->GetLocalStorageUsage(
+        base::Bind(&RemoveLocalStorageTester::OnGotLocalStorageUsage,
+                   base::Unretained(this)));
+  }
+  void OnGotLocalStorageUsage(
+      const std::vector<content::LocalStorageUsageInfo>& infos) {
+    infos_ = infos;
+    quit_closure_.Run();
+  }
+
+  // We don't own these pointers.
+  TestingProfile* profile_;
+  content::DOMStorageContext* dom_storage_context_ = nullptr;
+
+  std::vector<content::LocalStorageUsageInfo> infos_;
+  base::Closure quit_closure_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveLocalStorageTester);
+};
+
+class MockDomainReliabilityService : public DomainReliabilityService {
+ public:
+  MockDomainReliabilityService() {}
+
+  ~MockDomainReliabilityService() override {}
+
+  std::unique_ptr<DomainReliabilityMonitor> CreateMonitor(
+      scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
+      override {
+    NOTREACHED();
+    return std::unique_ptr<DomainReliabilityMonitor>();
+  }
+
+  void ClearBrowsingData(
+      DomainReliabilityClearMode clear_mode,
+      const base::Callback<bool(const GURL&)>& origin_filter,
+      const base::Closure& callback) override {
+    clear_count_++;
+    last_clear_mode_ = clear_mode;
+    last_filter_ = origin_filter;
+    callback.Run();
+  }
+
+  void GetWebUIData(const base::Callback<void(std::unique_ptr<base::Value>)>&
+                        callback) const override {
+    NOTREACHED();
+  }
+
+  void SetDiscardUploadsForTesting(bool discard_uploads) override {
+    NOTREACHED();
+  }
+
+  void AddContextForTesting(
+      std::unique_ptr<const domain_reliability::DomainReliabilityConfig> config)
+      override {
+    NOTREACHED();
+  }
+
+  void ForceUploadsForTesting() override { NOTREACHED(); }
+
+  int clear_count() const { return clear_count_; }
+
+  DomainReliabilityClearMode last_clear_mode() const {
+    return last_clear_mode_;
+  }
+
+  const base::Callback<bool(const GURL&)>& last_filter() const {
+    return last_filter_;
+  }
+
+ private:
+  unsigned clear_count_ = 0;
+  DomainReliabilityClearMode last_clear_mode_;
+  base::Callback<bool(const GURL&)> last_filter_;
+};
+
+struct TestingDomainReliabilityServiceFactoryUserData
+    : public base::SupportsUserData::Data {
+  TestingDomainReliabilityServiceFactoryUserData(
+      content::BrowserContext* context,
+      MockDomainReliabilityService* service)
+      : context(context),
+        service(service),
+        attached(false) {}
+  ~TestingDomainReliabilityServiceFactoryUserData() override {}
+
+  content::BrowserContext* const context;
+  MockDomainReliabilityService* const service;
+  bool attached;
+
+  static const void* kKey;
+};
+
+// static
+const void* TestingDomainReliabilityServiceFactoryUserData::kKey =
+    &TestingDomainReliabilityServiceFactoryUserData::kKey;
+
+std::unique_ptr<KeyedService> TestingDomainReliabilityServiceFactoryFunction(
+    content::BrowserContext* context) {
+  const void* kKey = TestingDomainReliabilityServiceFactoryUserData::kKey;
+
+  TestingDomainReliabilityServiceFactoryUserData* data =
+      static_cast<TestingDomainReliabilityServiceFactoryUserData*>(
+          context->GetUserData(kKey));
+  EXPECT_TRUE(data);
+  EXPECT_EQ(data->context, context);
+  EXPECT_FALSE(data->attached);
+
+  data->attached = true;
+  return base::WrapUnique(data->service);
+}
+
+class ClearDomainReliabilityTester {
+ public:
+  explicit ClearDomainReliabilityTester(TestingProfile* profile) :
+      profile_(profile),
+      mock_service_(new MockDomainReliabilityService()) {
+    AttachService();
+  }
+
+  unsigned clear_count() const { return mock_service_->clear_count(); }
+
+  DomainReliabilityClearMode last_clear_mode() const {
+    return mock_service_->last_clear_mode();
+  }
+
+  const base::Callback<bool(const GURL&)>& last_filter() const {
+    return mock_service_->last_filter();
+  }
+
+ private:
+  void AttachService() {
+    const void* kKey = TestingDomainReliabilityServiceFactoryUserData::kKey;
+
+    // Attach kludgey UserData struct to profile.
+    TestingDomainReliabilityServiceFactoryUserData* data =
+        new TestingDomainReliabilityServiceFactoryUserData(profile_,
+                                                           mock_service_);
+    EXPECT_FALSE(profile_->GetUserData(kKey));
+    profile_->SetUserData(kKey, data);
+
+    // Set and use factory that will attach service stuffed in kludgey struct.
+    DomainReliabilityServiceFactory::GetInstance()->SetTestingFactoryAndUse(
+        profile_,
+        &TestingDomainReliabilityServiceFactoryFunction);
+
+    // Verify and detach kludgey struct.
+    EXPECT_EQ(data, profile_->GetUserData(kKey));
+    EXPECT_TRUE(data->attached);
+    profile_->RemoveUserData(kKey);
+  }
+
+  TestingProfile* profile_;
+  MockDomainReliabilityService* mock_service_;
+};
+
+class RemoveDownloadsTester {
+ public:
+  explicit RemoveDownloadsTester(TestingProfile* testing_profile)
+      : download_manager_(new content::MockDownloadManager()),
+        chrome_download_manager_delegate_(testing_profile) {
+    content::BrowserContext::SetDownloadManagerForTesting(testing_profile,
+                                                          download_manager_);
+    EXPECT_EQ(download_manager_,
+              content::BrowserContext::GetDownloadManager(testing_profile));
+
+    EXPECT_CALL(*download_manager_, GetDelegate())
+        .WillOnce(Return(&chrome_download_manager_delegate_));
+    EXPECT_CALL(*download_manager_, Shutdown());
+  }
+
+  ~RemoveDownloadsTester() { chrome_download_manager_delegate_.Shutdown(); }
+
+  content::MockDownloadManager* download_manager() { return download_manager_; }
+
+ private:
+  content::MockDownloadManager* download_manager_;
+  ChromeDownloadManagerDelegate chrome_download_manager_delegate_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemoveDownloadsTester);
+};
+
+class RemovePasswordsTester {
+ public:
+  explicit RemovePasswordsTester(TestingProfile* testing_profile) {
+    PasswordStoreFactory::GetInstance()->SetTestingFactoryAndUse(
+        testing_profile,
+        password_manager::BuildPasswordStore<
+            content::BrowserContext,
+            testing::NiceMock<password_manager::MockPasswordStore>>);
+
+    store_ = static_cast<password_manager::MockPasswordStore*>(
+        PasswordStoreFactory::GetInstance()
+            ->GetForProfile(testing_profile, ServiceAccessType::EXPLICIT_ACCESS)
+            .get());
+
+    OSCryptMocker::SetUpWithSingleton();
+  }
+
+  ~RemovePasswordsTester() { OSCryptMocker::TearDown(); }
+
+  password_manager::MockPasswordStore* store() { return store_; }
+
+ private:
+  password_manager::MockPasswordStore* store_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemovePasswordsTester);
+};
+
+class RemovePermissionPromptCountsTest {
+ public:
+  explicit RemovePermissionPromptCountsTest(TestingProfile* profile)
+      : profile_(profile) {}
+
+  int GetDismissCount(const GURL& url, content::PermissionType permission) {
+    return PermissionDecisionAutoBlocker::GetDismissCount(
+        url, permission, profile_);
+  }
+
+  int GetIgnoreCount(const GURL& url, content::PermissionType permission) {
+    return PermissionDecisionAutoBlocker::GetIgnoreCount(
+        url, permission, profile_);
+  }
+
+  int RecordIgnore(const GURL& url, content::PermissionType permission) {
+    return PermissionDecisionAutoBlocker::RecordIgnore(url, permission,
+                                                       profile_);
+  }
+
+  bool ShouldChangeDismissalToBlock(const GURL& url,
+                                    content::PermissionType permission) {
+    return PermissionDecisionAutoBlocker::ShouldChangeDismissalToBlock(
+        url, permission, profile_);
+  }
+
+ private:
+  TestingProfile* profile_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemovePermissionPromptCountsTest);
+};
+
+#if BUILDFLAG(ENABLE_PLUGINS)
+// A small modification to MockBrowsingDataFlashLSOHelper so that it responds
+// immediately and does not wait for the Notify() call. Otherwise it would
+// deadlock BrowsingDataRemoverImpl::RemoveImpl.
+class TestBrowsingDataFlashLSOHelper : public MockBrowsingDataFlashLSOHelper {
+ public:
+  explicit TestBrowsingDataFlashLSOHelper(TestingProfile* profile)
+      : MockBrowsingDataFlashLSOHelper(profile) {}
+
+  void StartFetching(const GetSitesWithFlashDataCallback& callback) override {
+    MockBrowsingDataFlashLSOHelper::StartFetching(callback);
+    Notify();
+  }
+
+ private:
+  ~TestBrowsingDataFlashLSOHelper() override {}
+
+  DISALLOW_COPY_AND_ASSIGN(TestBrowsingDataFlashLSOHelper);
+};
+
+class RemovePluginDataTester {
+ public:
+  explicit RemovePluginDataTester(TestingProfile* profile)
+      : helper_(new TestBrowsingDataFlashLSOHelper(profile)) {
+    static_cast<ChromeBrowsingDataRemoverDelegate*>(
+        BrowsingDataRemoverFactory::GetForBrowserContext(profile)
+            ->GetEmbedderDelegate())->OverrideFlashLSOHelperForTesting(helper_);
+  }
+
+  void AddDomain(const std::string& domain) {
+    helper_->AddFlashLSODomain(domain);
+  }
+
+  const std::vector<std::string>& GetDomains() {
+    // TestBrowsingDataFlashLSOHelper is synchronous, so we can immediately
+    // return the fetched domains.
+    helper_->StartFetching(
+        base::Bind(&RemovePluginDataTester::OnSitesWithFlashDataFetched,
+                   base::Unretained(this)));
+    return domains_;
+  }
+
+ private:
+  void OnSitesWithFlashDataFetched(const std::vector<std::string>& sites) {
+    domains_ = sites;
+  }
+
+  std::vector<std::string> domains_;
+  scoped_refptr<TestBrowsingDataFlashLSOHelper> helper_;
+
+  DISALLOW_COPY_AND_ASSIGN(RemovePluginDataTester);
+};
+#endif
+
+// Test Class ----------------------------------------------------------------
+
+class BrowsingDataRemoverTest : public testing::Test {
+ public:
+  BrowsingDataRemoverTest()
+      : profile_(new TestingProfile()),
+        clear_domain_reliability_tester_(GetProfile()) {
+    remover_ = static_cast<BrowsingDataRemoverImpl*>(
+        BrowsingDataRemoverFactory::GetForBrowserContext(profile_.get()));
+
+#if defined(OS_ANDROID)
+    static_cast<ChromeBrowsingDataRemoverDelegate*>(
+        remover_->GetEmbedderDelegate())->OverrideWebappRegistryForTesting(
+            base::WrapUnique<WebappRegistry>(new TestWebappRegistry()));
+#endif
+  }
+
+  ~BrowsingDataRemoverTest() override {}
+
+  void TearDown() override {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+    mock_policy_ = nullptr;
+#endif
+
+    // TestingProfile contains a DOMStorageContext.  BrowserContext's destructor
+    // 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(const base::Time& delete_begin,
+                                     const base::Time& delete_end,
+                                     int remove_mask,
+                                     bool include_protected_origins) {
+    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(
+        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(
+      const base::Time& delete_begin,
+      const base::Time& delete_end,
+      int remove_mask,
+      const BrowsingDataFilterBuilder& filter_builder) {
+    TestStoragePartition storage_partition;
+    remover_->OverrideStoragePartitionForTesting(&storage_partition);
+
+    BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
+    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();
+  }
+
+  void DestroyProfile() { profile_.reset(); }
+
+  const base::Time& GetBeginTime() {
+    return remover_->GetLastUsedBeginTime();
+  }
+
+  int GetRemovalMask() {
+    return remover_->GetLastUsedRemovalMask();
+  }
+
+  int GetOriginTypeMask() {
+    return remover_->GetLastUsedOriginTypeMask();
+  }
+
+  StoragePartitionRemovalData GetStoragePartitionRemovalData() {
+    return storage_partition_removal_data_;
+  }
+
+  MockExtensionSpecialStoragePolicy* CreateMockPolicy() {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+    mock_policy_ = new MockExtensionSpecialStoragePolicy;
+    return mock_policy_.get();
+#else
+    NOTREACHED();
+    return nullptr;
+#endif
+  }
+
+  storage::SpecialStoragePolicy* mock_policy() {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+    return mock_policy_.get();
+#else
+    return nullptr;
+#endif
+  }
+
+  // If |kOrigin1| is protected when extensions are enabled, the expected
+  // result for tests where the OriginMatcherFunction result is variable.
+  bool ShouldRemoveForProtectedOriginOne() const {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+    return false;
+#else
+    return true;
+#endif
+  }
+
+  const ClearDomainReliabilityTester& clear_domain_reliability_tester() {
+    return clear_domain_reliability_tester_;
+  }
+
+ private:
+  // Cached pointer to BrowsingDataRemoverImpl for access to testing methods.
+  BrowsingDataRemoverImpl* remover_;
+
+  content::TestBrowserThreadBundle thread_bundle_;
+  std::unique_ptr<TestingProfile> profile_;
+
+  StoragePartitionRemovalData storage_partition_removal_data_;
+
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy_;
+#endif
+
+  // 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(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(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
+  // 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(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
+  // 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(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(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
+  // 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(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(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(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(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(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(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(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(
+      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(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(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(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(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);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+}
+
+// This should crash (DCHECK) in Debug, but death tests don't work properly
+// here.
+#if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON)
+TEST_F(BrowsingDataRemoverTest, RemoveMultipleTypesHistoryProhibited) {
+  PrefService* prefs = GetProfile()->GetPrefs();
+  prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false);
+
+  // 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(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 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(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(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(
+      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 |
+                BrowsingDataRemover::REMOVE_APPCACHE |
+                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_INDEXEDDB,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  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(
+      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 |
+                BrowsingDataRemover::REMOVE_APPCACHE |
+                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_INDEXEDDB,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+
+  // Check that all related origin data would be removed, that is, origin
+  // matcher would match these origin.
+  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, RemoveQuotaManagedDataForeverOnlyPersistent) {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  CreateMockPolicy();
+#endif
+
+  BlockUntilBrowsingDataRemoved(
+      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 |
+                BrowsingDataRemover::REMOVE_APPCACHE |
+                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_INDEXEDDB,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+
+  // Check that all related origin data would be removed, that is, origin
+  // matcher would match these origin.
+  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, RemoveQuotaManagedDataForeverNeither) {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  CreateMockPolicy();
+#endif
+
+  BlockUntilBrowsingDataRemoved(
+      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 |
+                BrowsingDataRemover::REMOVE_APPCACHE |
+                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_INDEXEDDB,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+
+  // Check that all related origin data would be removed, that is, origin
+  // matcher would match these origin.
+  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(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 |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+                BrowsingDataRemover::REMOVE_INDEXEDDB |
+                BrowsingDataRemover::REMOVE_WEBSQL,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  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(
+      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 |
+                BrowsingDataRemover::REMOVE_APPCACHE |
+                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_INDEXEDDB,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+
+  // Persistent data would be left out since we are not removing from
+  // 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(
+      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 |
+                BrowsingDataRemover::REMOVE_APPCACHE |
+                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_INDEXEDDB,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+
+  // Persistent data would be left out since we are not removing from
+  // 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, RemoveQuotaManagedUnprotectedOrigins) {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
+  // Protect kOrigin1.
+  policy->AddProtected(kOrigin1.GetOrigin());
+#endif
+
+  BlockUntilBrowsingDataRemoved(
+      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 |
+                BrowsingDataRemover::REMOVE_APPCACHE |
+                BrowsingDataRemover::REMOVE_SERVICE_WORKERS |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_INDEXEDDB,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+
+  // Check OriginMatcherFunction.
+  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()));
+}
+
+TEST_F(BrowsingDataRemoverTest, RemoveQuotaManagedProtectedSpecificOrigin) {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy();
+  // Protect kOrigin1.
+  policy->AddProtected(kOrigin1.GetOrigin());
+#endif
+
+  RegistrableDomainFilterBuilder builder(
+      RegistrableDomainFilterBuilder::WHITELIST);
+  builder.AddRegisterableDomain(kTestRegisterableDomain1);
+
+  // Try to remove kOrigin1. Expect failure.
+  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 |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+                BrowsingDataRemover::REMOVE_INDEXEDDB |
+                BrowsingDataRemover::REMOVE_WEBSQL,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+
+  // Check OriginMatcherFunction.
+  EXPECT_EQ(ShouldRemoveForProtectedOriginOne(),
+            removal_data.origin_matcher.Run(kOrigin1, mock_policy()));
+  // Since we use the matcher function to validate origins now, this should
+  // return false for the origins we're not trying to clear.
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin2, mock_policy()));
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin3, mock_policy()));
+}
+
+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(
+      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 |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+                BrowsingDataRemover::REMOVE_INDEXEDDB |
+                BrowsingDataRemover::REMOVE_WEBSQL,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::PROTECTED_WEB |
+      BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+
+  // Check OriginMatcherFunction, |kOrigin1| would match mask since we
+  // would have 'protected' specified in origin_type_mask.
+  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, RemoveQuotaManagedIgnoreExtensionsAndDevTools) {
+#if BUILDFLAG(ENABLE_EXTENSIONS)
+  CreateMockPolicy();
+#endif
+
+  BlockUntilBrowsingDataRemoved(
+      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 |
+                BrowsingDataRemover::REMOVE_CACHE_STORAGE |
+                BrowsingDataRemover::REMOVE_FILE_SYSTEMS |
+                BrowsingDataRemover::REMOVE_INDEXEDDB |
+                BrowsingDataRemover::REMOVE_WEBSQL,
+            GetRemovalMask());
+  EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask());
+
+  // Verify storage partition related stuffs.
+  StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData();
+
+  EXPECT_EQ(removal_data.remove_mask,
+            StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS |
+                StoragePartition::REMOVE_DATA_MASK_WEBSQL |
+                StoragePartition::REMOVE_DATA_MASK_APPCACHE |
+                StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS |
+                StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE |
+                StoragePartition::REMOVE_DATA_MASK_INDEXEDDB);
+  EXPECT_EQ(removal_data.quota_storage_remove_mask,
+            StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL);
+
+  // Check that extension and devtools data wouldn't be removed, that is,
+  // origin matcher would not match these origin.
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy()));
+  EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginDevTools, mock_policy()));
+}
+
+TEST_F(BrowsingDataRemoverTest, TimeBasedHistoryRemoval) {
+  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));
+
+  RegistrableDomainFilterBuilder builder(
+      RegistrableDomainFilterBuilder::BLACKLIST);
+  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(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(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(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
+    : public BrowsingDataRemoverCompletionObserver {
+ public:
+  explicit InspectableCompletionObserver(BrowsingDataRemover* remover)
+      : BrowsingDataRemoverCompletionObserver(remover) {}
+  ~InspectableCompletionObserver() override {}
+
+  bool called() { return called_; }
+
+ protected:
+  void OnBrowsingDataRemoverDone() override {
+    BrowsingDataRemoverCompletionObserver::OnBrowsingDataRemoverDone();
+    called_ = true;
+  }
+
+ private:
+  bool called_ = false;
+};
+
+TEST_F(BrowsingDataRemoverTest, CompletionInhibition) {
+  // The |completion_inhibitor| on the stack should prevent removal sessions
+  // from completing until after ContinueToCompletion() is called.
+  BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
+
+  BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
+      BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile()));
+  InspectableCompletionObserver completion_observer(remover);
+  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) {
+  BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
+      BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile()));
+  InspectableCompletionObserver completion_observer(remover);
+  BrowsingDataRemoverCompletionInhibitor completion_inhibitor;
+  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(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) {
+  chromeos::ScopedTestDeviceSettingsService test_device_settings_service;
+  chromeos::ScopedTestCrosSettings test_cros_settings;
+  chromeos::MockUserManager* mock_user_manager =
+      new testing::NiceMock<chromeos::MockUserManager>();
+  mock_user_manager->SetActiveUser(
+      AccountId::FromUserEmail("test@example.com"));
+  chromeos::ScopedUserManagerEnabler user_manager_enabler(mock_user_manager);
+
+  std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter =
+      chromeos::DBusThreadManager::GetSetterForTesting();
+  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(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(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(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(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(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(
+      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(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(
+      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(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(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(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(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(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(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(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(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(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);
+  EXPECT_EQ(3u, host_settings.size());
+  EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1),
+            host_settings[0].primary_pattern)
+      << host_settings[0].primary_pattern.ToString();
+  EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin4),
+            host_settings[1].primary_pattern)
+      << host_settings[1].primary_pattern.ToString();
+  EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin3),
+            host_settings[2].primary_pattern)
+      << host_settings[2].primary_pattern.ToString();
+}
+
+TEST_F(BrowsingDataRemoverTest, RemoveDurablePermission) {
+  // Add our settings.
+  HostContentSettingsMap* host_content_settings_map =
+      HostContentSettingsMapFactory::GetForProfile(GetProfile());
+
+  DurableStoragePermissionContext durable_permission(GetProfile());
+  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(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);
+
+  ASSERT_EQ(2u, host_settings.size());
+  // Only the first should should have a setting.
+  EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1),
+            host_settings[0].primary_pattern)
+      << host_settings[0].primary_pattern.ToString();
+  EXPECT_EQ(CONTENT_SETTING_ALLOW, host_settings[0].setting);
+
+  // And our wildcard.
+  EXPECT_EQ(ContentSettingsPattern::Wildcard(),
+            host_settings[1].primary_pattern)
+      << host_settings[1].primary_pattern.ToString();
+  EXPECT_EQ(CONTENT_SETTING_ASK, host_settings[1].setting);
+}
+
+// Test that removing cookies clears HTTP auth data.
+TEST_F(BrowsingDataRemoverTest, ClearHttpAuthCache_RemoveCookies) {
+  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(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(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(
+      RegistrableDomainFilterBuilder::WHITELIST);
+  filter_builder_1.AddRegisterableDomain(kTestRegisterableDomain1);
+
+  RegistrableDomainFilterBuilder filter_builder_2(
+      RegistrableDomainFilterBuilder::BLACKLIST);
+  filter_builder_2.AddRegisterableDomain(kTestRegisterableDomain1);
+
+  {
+    // Test REMOVE_HISTORY.
+    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(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(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(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(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));
+    EXPECT_EQ(0, tester.GetIgnoreCount(
+                     kOrigin2, content::PermissionType::DURABLE_STORAGE));
+    EXPECT_EQ(0, tester.GetDismissCount(
+                     kOrigin2, content::PermissionType::NOTIFICATIONS));
+  }
+}
+
+#if BUILDFLAG(ENABLE_PLUGINS)
+TEST_F(BrowsingDataRemoverTest, RemovePluginData) {
+  RemovePluginDataTester tester(GetProfile());
+
+  tester.AddDomain(kOrigin1.host());
+  tester.AddDomain(kOrigin2.host());
+  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(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.
+}
+#endif
+
+class MultipleTasksObserver {
+ public:
+  // A simple implementation of BrowsingDataRemover::Observer.
+  // MultipleTasksObserver will use several instances of Target to test
+  // that completion callbacks are returned to the correct one.
+  class Target : public BrowsingDataRemover::Observer {
+   public:
+    Target(MultipleTasksObserver* parent, BrowsingDataRemover* remover)
+        : parent_(parent),
+          observer_(this) {
+      observer_.Add(remover);
+    }
+    ~Target() override {}
+
+    void OnBrowsingDataRemoverDone() override {
+      parent_->SetLastCalledTarget(this);
+    }
+
+   private:
+    MultipleTasksObserver* parent_;
+    ScopedObserver<BrowsingDataRemover, BrowsingDataRemover::Observer>
+        observer_;
+  };
+
+  explicit MultipleTasksObserver(BrowsingDataRemover* remover)
+      : target_a_(this, remover),
+        target_b_(this, remover),
+        last_called_target_(nullptr) {}
+  ~MultipleTasksObserver() {}
+
+  void ClearLastCalledTarget() {
+    last_called_target_ = nullptr;
+  }
+
+  Target* GetLastCalledTarget() {
+    return last_called_target_;
+  }
+
+  Target* target_a() { return &target_a_; }
+  Target* target_b() { return &target_b_; }
+
+ private:
+  void SetLastCalledTarget(Target* target) {
+    DCHECK(!last_called_target_)
+        << "Call ClearLastCalledTarget() before every removal task.";
+    last_called_target_ = target;
+  }
+
+  Target target_a_;
+  Target target_b_;
+  Target* last_called_target_;
+};
+
+TEST_F(BrowsingDataRemoverTest, MultipleTasks) {
+  BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
+      BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile()));
+  EXPECT_FALSE(remover->is_removing());
+
+  std::unique_ptr<RegistrableDomainFilterBuilder> filter_builder_1(
+      new RegistrableDomainFilterBuilder(
+          RegistrableDomainFilterBuilder::WHITELIST));
+  std::unique_ptr<RegistrableDomainFilterBuilder> filter_builder_2(
+      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<BrowsingDataRemoverImpl::RemovalTask> tasks;
+  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(base::Time(), base::Time::Max(),
+                     BrowsingDataRemover::REMOVE_COOKIES,
+                     BrowsingDataHelper::PROTECTED_WEB,
+                     base::MakeUnique<RegistrableDomainFilterBuilder>(
+                         RegistrableDomainFilterBuilder::BLACKLIST),
+                     nullptr);
+  tasks.emplace_back(
+      base::Time::Now(), base::Time::Max(),
+      BrowsingDataRemover::REMOVE_PASSWORDS, BrowsingDataHelper::ALL,
+      base::MakeUnique<RegistrableDomainFilterBuilder>(
+          RegistrableDomainFilterBuilder::BLACKLIST),
+      observer.target_b());
+  tasks.emplace_back(
+      base::Time(), base::Time::UnixEpoch(),
+      BrowsingDataRemover::REMOVE_WEBSQL,
+      BrowsingDataHelper::UNPROTECTED_WEB,
+      std::move(filter_builder_1),
+      observer.target_b());
+  tasks.emplace_back(
+      base::Time::UnixEpoch(), base::Time::Now(),
+      BrowsingDataRemover::REMOVE_CHANNEL_IDS,
+      BrowsingDataHelper::ALL,
+      std::move(filter_builder_2),
+      nullptr);
+
+  for (BrowsingDataRemoverImpl::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.delete_begin, task.delete_end,
+                      task.remove_mask, task.origin_type_mask);
+    } else if (task.filter_builder->IsEmptyBlacklist()) {
+      remover->RemoveAndReply(task.delete_begin, task.delete_end,
+                              task.remove_mask, task.origin_type_mask,
+                              task.observer);
+    } else if (!task.observer) {
+      remover->RemoveWithFilter(task.delete_begin, task.delete_end,
+                                task.remove_mask, task.origin_type_mask,
+                                std::move(task.filter_builder));
+    } else {
+      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 (BrowsingDataRemoverImpl::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.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.
+TEST_F(BrowsingDataRemoverTest, MultipleTasksInQuickSuccession) {
+  BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>(
+      BrowsingDataRemoverFactory::GetForBrowserContext(GetProfile()));
+  EXPECT_FALSE(remover->is_removing());
+
+  int test_removal_masks[] = {
+      BrowsingDataRemover::REMOVE_COOKIES,
+      BrowsingDataRemover::REMOVE_PASSWORDS,
+      BrowsingDataRemover::REMOVE_COOKIES,
+      BrowsingDataRemover::REMOVE_COOKIES,
+      BrowsingDataRemover::REMOVE_COOKIES,
+      BrowsingDataRemover::REMOVE_HISTORY,
+      BrowsingDataRemover::REMOVE_HISTORY,
+      BrowsingDataRemover::REMOVE_HISTORY,
+      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(base::Time(), base::Time::Max(), removal_mask,
+                    BrowsingDataHelper::UNPROTECTED_WEB);
+  }
+
+  EXPECT_TRUE(remover->is_removing());
+
+  // Add one more deletion and wait for it.
+  BlockUntilBrowsingDataRemoved(
+      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;
+  profile.CreateBookmarkModel(true);
+
+  bookmarks::BookmarkModel* bookmark_model =
+      BookmarkModelFactory::GetForBrowserContext(&profile);
+  bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model);
+
+  const base::Time delete_begin =
+      base::Time::Now() - base::TimeDelta::FromDays(1);
+
+  // Create a couple of bookmarks.
+  bookmark_model->AddURL(bookmark_model->bookmark_bar_node(), 0,
+                         base::string16(),
+                         GURL("http://foo.org/desktop"));
+  bookmark_model->AddURL(bookmark_model->mobile_node(), 0,
+                         base::string16(),
+                         GURL("http://foo.org/mobile"));
+
+  // Simulate their visits (this is using Time::Now() as timestamps).
+  ntp_snippets::UpdateBookmarkOnURLVisitedInMainFrame(
+      bookmark_model, GURL("http://foo.org/desktop"),
+      /*is_mobile_platform=*/false);
+  ntp_snippets::UpdateBookmarkOnURLVisitedInMainFrame(
+      bookmark_model, GURL("http://foo.org/mobile"),
+      /*is_mobile_platform=*/true);
+
+  // Add a bookmark with a visited timestamp before the deletion interval.
+  bookmarks::BookmarkNode::MetaInfoMap meta_info = {
+      {"last_visited",
+       base::Int64ToString((delete_begin - base::TimeDelta::FromSeconds(1))
+                               .ToInternalValue())}};
+  bookmark_model->AddURLWithCreationTimeAndMetaInfo(
+      bookmark_model->mobile_node(), 0, base::ASCIIToUTF16("my title"),
+      GURL("http://foo-2.org/"), delete_begin - base::TimeDelta::FromDays(1),
+      &meta_info);
+
+  // There should be some recently visited bookmarks.
+  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(delete_begin, base::Time::Max(),
+                          BrowsingDataRemover::REMOVE_HISTORY,
+                          BrowsingDataHelper::ALL, &completion_observer);
+  completion_observer.BlockUntilCompletion();
+
+  // There should be only 1 recently visited bookmarks.
+  std::vector<const bookmarks::BookmarkNode*> remaining_nodes =
+      ntp_snippets::GetRecentlyVisitedBookmarks(
+          bookmark_model, 3, base::Time::UnixEpoch(),
+          /*consider_visits_from_desktop=*/true);
+  EXPECT_THAT(remaining_nodes, SizeIs(1));
+  EXPECT_THAT(remaining_nodes[0]->url().spec(), Eq("http://foo-2.org/"));
+}