| Index: chrome/browser/browsing_data/browsing_data_remover_unittest.cc
|
| diff --git a/chrome/browser/browsing_data/browsing_data_remover_unittest.cc b/chrome/browser/browsing_data/browsing_data_remover_unittest.cc
|
| deleted file mode 100644
|
| index 446d9b8dcc46bc05fbc277f2cbc7bd73ec575377..0000000000000000000000000000000000000000
|
| --- a/chrome/browser/browsing_data/browsing_data_remover_unittest.cc
|
| +++ /dev/null
|
| @@ -1,3138 +0,0 @@
|
| -// 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/"));
|
| -}
|
|
|
Chromium Code Reviews
Issue 2641853002:
Split BrowsingDataRemoverTest into two tests for Impl and Delegate. (Closed)
