OLD | NEW |
1 // Copyright 2017 The Chromium Authors. All rights reserved. | 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h" | 5 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h" |
6 | 6 |
7 #include "base/guid.h" | 7 #include "base/guid.h" |
8 #include "base/memory/ptr_util.h" | 8 #include "base/memory/ptr_util.h" |
9 #include "base/run_loop.h" | 9 #include "base/run_loop.h" |
10 #include "base/strings/string_number_conversions.h" | 10 #include "base/strings/string_number_conversions.h" |
11 #include "base/strings/utf_string_conversions.h" | 11 #include "base/strings/utf_string_conversions.h" |
12 #include "base/test/scoped_feature_list.h" | 12 #include "base/test/scoped_feature_list.h" |
13 #include "base/time/time.h" | 13 #include "base/time/time.h" |
14 #include "chrome/browser/autofill/personal_data_manager_factory.h" | 14 #include "chrome/browser/autofill/personal_data_manager_factory.h" |
15 #include "chrome/browser/bookmarks/bookmark_model_factory.h" | 15 #include "chrome/browser/bookmarks/bookmark_model_factory.h" |
16 #include "chrome/browser/browsing_data/browsing_data_helper.h" | 16 #include "chrome/browser/browsing_data/browsing_data_helper.h" |
17 #include "chrome/browser/browsing_data/browsing_data_remover.h" | 17 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_fac
tory.h" |
18 #include "chrome/browser/browsing_data/browsing_data_remover_factory.h" | |
19 #include "chrome/browser/browsing_data/browsing_data_remover_impl.h" | |
20 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h" | |
21 #include "chrome/browser/browsing_data/chrome_browsing_data_remover_delegate.h" | |
22 #include "chrome/browser/content_settings/host_content_settings_map_factory.h" | 18 #include "chrome/browser/content_settings/host_content_settings_map_factory.h" |
23 #include "chrome/browser/domain_reliability/service_factory.h" | 19 #include "chrome/browser/domain_reliability/service_factory.h" |
24 #include "chrome/browser/download/chrome_download_manager_delegate.h" | 20 #include "chrome/browser/download/chrome_download_manager_delegate.h" |
25 #include "chrome/browser/favicon/favicon_service_factory.h" | 21 #include "chrome/browser/favicon/favicon_service_factory.h" |
26 #include "chrome/browser/history/history_service_factory.h" | 22 #include "chrome/browser/history/history_service_factory.h" |
27 #include "chrome/browser/password_manager/password_store_factory.h" | 23 #include "chrome/browser/password_manager/password_store_factory.h" |
28 #include "chrome/browser/permissions/permission_decision_auto_blocker.h" | 24 #include "chrome/browser/permissions/permission_decision_auto_blocker.h" |
29 #include "chrome/browser/safe_browsing/safe_browsing_service.h" | 25 #include "chrome/browser/safe_browsing/safe_browsing_service.h" |
30 #include "chrome/browser/storage/durable_storage_permission_context.h" | 26 #include "chrome/browser/storage/durable_storage_permission_context.h" |
31 #include "chrome/browser/translate/language_model_factory.h" | 27 #include "chrome/browser/translate/language_model_factory.h" |
(...skipping 20 matching lines...) Expand all Loading... |
52 #include "components/history/core/browser/history_service.h" | 48 #include "components/history/core/browser/history_service.h" |
53 #include "components/ntp_snippets/bookmarks/bookmark_last_visit_utils.h" | 49 #include "components/ntp_snippets/bookmarks/bookmark_last_visit_utils.h" |
54 #include "components/omnibox/browser/omnibox_pref_names.h" | 50 #include "components/omnibox/browser/omnibox_pref_names.h" |
55 #include "components/os_crypt/os_crypt_mocker.h" | 51 #include "components/os_crypt/os_crypt_mocker.h" |
56 #include "components/password_manager/core/browser/mock_password_store.h" | 52 #include "components/password_manager/core/browser/mock_password_store.h" |
57 #include "components/password_manager/core/browser/password_manager_test_utils.h
" | 53 #include "components/password_manager/core/browser/password_manager_test_utils.h
" |
58 #include "components/password_manager/core/browser/password_store_consumer.h" | 54 #include "components/password_manager/core/browser/password_store_consumer.h" |
59 #include "components/prefs/testing_pref_service.h" | 55 #include "components/prefs/testing_pref_service.h" |
60 #include "components/translate/core/browser/language_model.h" | 56 #include "components/translate/core/browser/language_model.h" |
61 #include "content/public/browser/browsing_data_filter_builder.h" | 57 #include "content/public/browser/browsing_data_filter_builder.h" |
| 58 #include "content/public/browser/browsing_data_remover.h" |
| 59 #include "content/public/test/browsing_data_remover_test_util.h" |
62 #include "content/public/test/mock_download_manager.h" | 60 #include "content/public/test/mock_download_manager.h" |
63 #include "content/public/test/test_browser_thread_bundle.h" | 61 #include "content/public/test/test_browser_thread_bundle.h" |
64 #include "content/public/test/test_utils.h" | 62 #include "content/public/test/test_utils.h" |
65 #include "net/cookies/cookie_store.h" | 63 #include "net/cookies/cookie_store.h" |
66 #include "net/http/http_transaction_factory.h" | 64 #include "net/http/http_transaction_factory.h" |
67 #include "net/url_request/url_request_context.h" | 65 #include "net/url_request/url_request_context.h" |
68 #include "net/url_request/url_request_context_getter.h" | 66 #include "net/url_request/url_request_context_getter.h" |
69 #include "third_party/skia/include/core/SkBitmap.h" | 67 #include "third_party/skia/include/core/SkBitmap.h" |
70 #include "ui/gfx/favicon_size.h" | 68 #include "ui/gfx/favicon_size.h" |
71 | 69 |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
135 const GURL kOrigin3(kTestOrigin3); | 133 const GURL kOrigin3(kTestOrigin3); |
136 const GURL kOrigin4(kTestOrigin4); | 134 const GURL kOrigin4(kTestOrigin4); |
137 | 135 |
138 const GURL kOriginExt(kTestOriginExt); | 136 const GURL kOriginExt(kTestOriginExt); |
139 const GURL kOriginDevTools(kTestOriginDevTools); | 137 const GURL kOriginDevTools(kTestOriginDevTools); |
140 | 138 |
141 // Shorthands for origin types. | 139 // Shorthands for origin types. |
142 #if BUILDFLAG(ENABLE_EXTENSIONS) | 140 #if BUILDFLAG(ENABLE_EXTENSIONS) |
143 const int kExtension = ChromeBrowsingDataRemoverDelegate::ORIGIN_TYPE_EXTENSION; | 141 const int kExtension = ChromeBrowsingDataRemoverDelegate::ORIGIN_TYPE_EXTENSION; |
144 #endif | 142 #endif |
145 const int kProtected = BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB; | 143 const int kProtected = content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB; |
146 const int kUnprotected = BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB; | 144 const int kUnprotected = |
| 145 content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB; |
147 | 146 |
148 // Testers -------------------------------------------------------------------- | 147 // Testers -------------------------------------------------------------------- |
149 | 148 |
150 #if defined(OS_ANDROID) | 149 #if defined(OS_ANDROID) |
151 class TestWebappRegistry : public WebappRegistry { | 150 class TestWebappRegistry : public WebappRegistry { |
152 public: | 151 public: |
153 TestWebappRegistry() : WebappRegistry() { } | 152 TestWebappRegistry() : WebappRegistry() { } |
154 | 153 |
155 void UnregisterWebappsForUrls( | 154 void UnregisterWebappsForUrls( |
156 const base::Callback<bool(const GURL&)>& url_filter) override { | 155 const base::Callback<bool(const GURL&)>& url_filter) override { |
(...skipping 468 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
625 ~TestBrowsingDataFlashLSOHelper() override {} | 624 ~TestBrowsingDataFlashLSOHelper() override {} |
626 | 625 |
627 DISALLOW_COPY_AND_ASSIGN(TestBrowsingDataFlashLSOHelper); | 626 DISALLOW_COPY_AND_ASSIGN(TestBrowsingDataFlashLSOHelper); |
628 }; | 627 }; |
629 | 628 |
630 class RemovePluginDataTester { | 629 class RemovePluginDataTester { |
631 public: | 630 public: |
632 explicit RemovePluginDataTester(TestingProfile* profile) | 631 explicit RemovePluginDataTester(TestingProfile* profile) |
633 : helper_(new TestBrowsingDataFlashLSOHelper(profile)) { | 632 : helper_(new TestBrowsingDataFlashLSOHelper(profile)) { |
634 static_cast<ChromeBrowsingDataRemoverDelegate*>( | 633 static_cast<ChromeBrowsingDataRemoverDelegate*>( |
635 BrowsingDataRemoverFactory::GetForBrowserContext(profile) | 634 profile->GetBrowsingDataRemoverDelegate()) |
636 ->GetEmbedderDelegate())->OverrideFlashLSOHelperForTesting(helper_); | 635 ->OverrideFlashLSOHelperForTesting(helper_); |
637 } | 636 } |
638 | 637 |
639 void AddDomain(const std::string& domain) { | 638 void AddDomain(const std::string& domain) { |
640 helper_->AddFlashLSODomain(domain); | 639 helper_->AddFlashLSODomain(domain); |
641 } | 640 } |
642 | 641 |
643 const std::vector<std::string>& GetDomains() { | 642 const std::vector<std::string>& GetDomains() { |
644 // TestBrowsingDataFlashLSOHelper is synchronous, so we can immediately | 643 // TestBrowsingDataFlashLSOHelper is synchronous, so we can immediately |
645 // return the fetched domains. | 644 // return the fetched domains. |
646 helper_->StartFetching( | 645 helper_->StartFetching( |
(...skipping 98 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
745 | 744 |
746 content::MockDownloadManager* download_manager() { return download_manager_; } | 745 content::MockDownloadManager* download_manager() { return download_manager_; } |
747 | 746 |
748 private: | 747 private: |
749 content::MockDownloadManager* download_manager_; // Owned by testing profile. | 748 content::MockDownloadManager* download_manager_; // Owned by testing profile. |
750 ChromeDownloadManagerDelegate chrome_download_manager_delegate_; | 749 ChromeDownloadManagerDelegate chrome_download_manager_delegate_; |
751 | 750 |
752 DISALLOW_COPY_AND_ASSIGN(RemoveDownloadsTester); | 751 DISALLOW_COPY_AND_ASSIGN(RemoveDownloadsTester); |
753 }; | 752 }; |
754 | 753 |
| 754 // TestingProfile does not contain ChromeBrowsingDataRemoverDelegate. Add it |
| 755 // for the purpose of this test. |
| 756 class TestingProfileWithDelegate : public TestingProfile { |
| 757 public: |
| 758 TestingProfileWithDelegate() : delegate_(this) {} |
| 759 |
| 760 content::BrowsingDataRemoverDelegate* GetBrowsingDataRemoverDelegate() |
| 761 override { |
| 762 return &delegate_; |
| 763 } |
| 764 |
| 765 private: |
| 766 ChromeBrowsingDataRemoverDelegate delegate_; |
| 767 }; |
| 768 |
755 } // namespace | 769 } // namespace |
756 | 770 |
757 // RemoveAutofillTester is not a part of the anonymous namespace above, as | 771 // RemoveAutofillTester is not a part of the anonymous namespace above, as |
758 // PersonalDataManager declares it a friend in an empty namespace. | 772 // PersonalDataManager declares it a friend in an empty namespace. |
759 class RemoveAutofillTester : public autofill::PersonalDataManagerObserver { | 773 class RemoveAutofillTester : public autofill::PersonalDataManagerObserver { |
760 public: | 774 public: |
761 explicit RemoveAutofillTester(TestingProfile* profile) | 775 explicit RemoveAutofillTester(TestingProfile* profile) |
762 : personal_data_manager_( | 776 : personal_data_manager_( |
763 autofill::PersonalDataManagerFactory::GetForProfile(profile)) { | 777 autofill::PersonalDataManagerFactory::GetForProfile(profile)) { |
764 autofill::test::DisableSystemServices(profile->GetPrefs()); | 778 autofill::test::DisableSystemServices(profile->GetPrefs()); |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
839 | 853 |
840 autofill::PersonalDataManager* personal_data_manager_; | 854 autofill::PersonalDataManager* personal_data_manager_; |
841 DISALLOW_COPY_AND_ASSIGN(RemoveAutofillTester); | 855 DISALLOW_COPY_AND_ASSIGN(RemoveAutofillTester); |
842 }; | 856 }; |
843 | 857 |
844 // Test Class ----------------------------------------------------------------- | 858 // Test Class ----------------------------------------------------------------- |
845 | 859 |
846 class ChromeBrowsingDataRemoverDelegateTest : public testing::Test { | 860 class ChromeBrowsingDataRemoverDelegateTest : public testing::Test { |
847 public: | 861 public: |
848 ChromeBrowsingDataRemoverDelegateTest() | 862 ChromeBrowsingDataRemoverDelegateTest() |
849 : profile_(new TestingProfile()), | 863 : profile_(new TestingProfileWithDelegate()), |
850 clear_domain_reliability_tester_(profile_.get()) { | 864 clear_domain_reliability_tester_(profile_.get()) { |
851 remover_ = BrowsingDataRemoverFactory::GetForBrowserContext(profile_.get()); | 865 remover_ = content::BrowserContext::GetBrowsingDataRemover(profile_.get()); |
852 | 866 |
853 #if defined(OS_ANDROID) | 867 #if defined(OS_ANDROID) |
854 static_cast<ChromeBrowsingDataRemoverDelegate*>( | 868 static_cast<ChromeBrowsingDataRemoverDelegate*>( |
855 remover_->GetEmbedderDelegate())->OverrideWebappRegistryForTesting( | 869 profile_->GetBrowsingDataRemoverDelegate()) |
| 870 ->OverrideWebappRegistryForTesting( |
856 base::WrapUnique<WebappRegistry>(new TestWebappRegistry())); | 871 base::WrapUnique<WebappRegistry>(new TestWebappRegistry())); |
857 #endif | 872 #endif |
858 } | 873 } |
859 | 874 |
860 void TearDown() override { | 875 void TearDown() override { |
861 // TestingProfile contains a DOMStorageContext. BrowserContext's destructor | 876 // TestingProfile contains a DOMStorageContext. BrowserContext's destructor |
862 // posts a message to the WEBKIT thread to delete some of its member | 877 // posts a message to the WEBKIT thread to delete some of its member |
863 // variables. We need to ensure that the profile is destroyed, and that | 878 // variables. We need to ensure that the profile is destroyed, and that |
864 // the message loop is cleared out, before destroying the threads and loop. | 879 // the message loop is cleared out, before destroying the threads and loop. |
865 // Otherwise we leak memory. | 880 // Otherwise we leak memory. |
866 profile_.reset(); | 881 profile_.reset(); |
867 base::RunLoop().RunUntilIdle(); | 882 base::RunLoop().RunUntilIdle(); |
868 | 883 |
869 TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr); | 884 TestingBrowserProcess::GetGlobal()->SetLocalState(nullptr); |
870 } | 885 } |
871 | 886 |
872 ~ChromeBrowsingDataRemoverDelegateTest() override {} | 887 ~ChromeBrowsingDataRemoverDelegateTest() override {} |
873 | 888 |
874 void BlockUntilBrowsingDataRemoved(const base::Time& delete_begin, | 889 void BlockUntilBrowsingDataRemoved(const base::Time& delete_begin, |
875 const base::Time& delete_end, | 890 const base::Time& delete_end, |
876 int remove_mask, | 891 int remove_mask, |
877 bool include_protected_origins) { | 892 bool include_protected_origins) { |
878 int origin_type_mask = BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB; | 893 int origin_type_mask = |
| 894 content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB; |
879 if (include_protected_origins) { | 895 if (include_protected_origins) { |
880 origin_type_mask |= BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB; | 896 origin_type_mask |= |
| 897 content::BrowsingDataRemover::ORIGIN_TYPE_PROTECTED_WEB; |
881 } | 898 } |
882 | 899 |
883 BrowsingDataRemoverCompletionObserver completion_observer(remover_); | 900 content::BrowsingDataRemoverCompletionObserver completion_observer( |
| 901 remover_); |
884 remover_->RemoveAndReply( | 902 remover_->RemoveAndReply( |
885 delete_begin, delete_end, remove_mask, origin_type_mask, | 903 delete_begin, delete_end, remove_mask, origin_type_mask, |
886 &completion_observer); | 904 &completion_observer); |
887 completion_observer.BlockUntilCompletion(); | 905 completion_observer.BlockUntilCompletion(); |
888 } | 906 } |
889 | 907 |
890 void BlockUntilOriginDataRemoved( | 908 void BlockUntilOriginDataRemoved( |
891 const base::Time& delete_begin, | 909 const base::Time& delete_begin, |
892 const base::Time& delete_end, | 910 const base::Time& delete_end, |
893 int remove_mask, | 911 int remove_mask, |
894 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) { | 912 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) { |
895 BrowsingDataRemoverCompletionObserver completion_observer(remover_); | 913 content::BrowsingDataRemoverCompletionObserver completion_observer( |
896 static_cast<BrowsingDataRemoverImpl*>(remover_)->RemoveWithFilterAndReply( | 914 remover_); |
| 915 remover_->RemoveWithFilterAndReply( |
897 delete_begin, delete_end, remove_mask, | 916 delete_begin, delete_end, remove_mask, |
898 BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 917 content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
899 std::move(filter_builder), &completion_observer); | 918 std::move(filter_builder), &completion_observer); |
900 completion_observer.BlockUntilCompletion(); | 919 completion_observer.BlockUntilCompletion(); |
901 } | 920 } |
902 | 921 |
903 const base::Time& GetBeginTime() { | 922 const base::Time& GetBeginTime() { |
904 return remover_->GetLastUsedBeginTime(); | 923 return remover_->GetLastUsedBeginTime(); |
905 } | 924 } |
906 | 925 |
907 int GetRemovalMask() { | 926 int GetRemovalMask() { |
908 return remover_->GetLastUsedRemovalMask(); | 927 return remover_->GetLastUsedRemovalMask(); |
(...skipping 11 matching lines...) Expand all Loading... |
920 return clear_domain_reliability_tester_; | 939 return clear_domain_reliability_tester_; |
921 } | 940 } |
922 | 941 |
923 bool Match(const GURL& origin, | 942 bool Match(const GURL& origin, |
924 int mask, | 943 int mask, |
925 storage::SpecialStoragePolicy* policy) { | 944 storage::SpecialStoragePolicy* policy) { |
926 return remover_->DoesOriginMatchMask(mask, origin, policy); | 945 return remover_->DoesOriginMatchMask(mask, origin, policy); |
927 } | 946 } |
928 | 947 |
929 private: | 948 private: |
930 // Cached pointer to BrowsingDataRemoverImpl for access to testing methods. | 949 // Cached pointer to BrowsingDataRemover for access to testing methods. |
931 BrowsingDataRemover* remover_; | 950 content::BrowsingDataRemover* remover_; |
932 | 951 |
933 content::TestBrowserThreadBundle thread_bundle_; | 952 content::TestBrowserThreadBundle thread_bundle_; |
934 std::unique_ptr<TestingProfile> profile_; | 953 std::unique_ptr<TestingProfile> profile_; |
935 | 954 |
936 // Needed to mock out DomainReliabilityService, even for unrelated tests. | 955 // Needed to mock out DomainReliabilityService, even for unrelated tests. |
937 ClearDomainReliabilityTester clear_domain_reliability_tester_; | 956 ClearDomainReliabilityTester clear_domain_reliability_tester_; |
938 | 957 |
939 DISALLOW_COPY_AND_ASSIGN(ChromeBrowsingDataRemoverDelegateTest); | 958 DISALLOW_COPY_AND_ASSIGN(ChromeBrowsingDataRemoverDelegateTest); |
940 }; | 959 }; |
941 | 960 |
942 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveSafeBrowsingCookieForever) { | 961 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveSafeBrowsingCookieForever) { |
943 RemoveSafeBrowsingCookieTester tester; | 962 RemoveSafeBrowsingCookieTester tester; |
944 | 963 |
945 tester.AddCookie(); | 964 tester.AddCookie(); |
946 ASSERT_TRUE(tester.ContainsCookie()); | 965 ASSERT_TRUE(tester.ContainsCookie()); |
947 | 966 |
948 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 967 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
949 BrowsingDataRemover::DATA_TYPE_COOKIES, false); | 968 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
| 969 false); |
950 | 970 |
951 EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); | 971 EXPECT_EQ(content::BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); |
952 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 972 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
953 GetOriginTypeMask()); | 973 GetOriginTypeMask()); |
954 EXPECT_FALSE(tester.ContainsCookie()); | 974 EXPECT_FALSE(tester.ContainsCookie()); |
955 } | 975 } |
956 | 976 |
957 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 977 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
958 RemoveSafeBrowsingCookieLastHour) { | 978 RemoveSafeBrowsingCookieLastHour) { |
959 RemoveSafeBrowsingCookieTester tester; | 979 RemoveSafeBrowsingCookieTester tester; |
960 | 980 |
961 tester.AddCookie(); | 981 tester.AddCookie(); |
962 ASSERT_TRUE(tester.ContainsCookie()); | 982 ASSERT_TRUE(tester.ContainsCookie()); |
963 | 983 |
964 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), | 984 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), |
965 BrowsingDataRemover::DATA_TYPE_COOKIES, false); | 985 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
| 986 false); |
966 | 987 |
967 EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); | 988 EXPECT_EQ(content::BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); |
968 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 989 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
969 GetOriginTypeMask()); | 990 GetOriginTypeMask()); |
970 // Removing with time period other than all time should not clear safe | 991 // Removing with time period other than all time should not clear safe |
971 // browsing cookies. | 992 // browsing cookies. |
972 EXPECT_TRUE(tester.ContainsCookie()); | 993 EXPECT_TRUE(tester.ContainsCookie()); |
973 } | 994 } |
974 | 995 |
975 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 996 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
976 RemoveSafeBrowsingCookieForeverWithPredicate) { | 997 RemoveSafeBrowsingCookieForeverWithPredicate) { |
977 RemoveSafeBrowsingCookieTester tester; | 998 RemoveSafeBrowsingCookieTester tester; |
978 | 999 |
979 tester.AddCookie(); | 1000 tester.AddCookie(); |
980 ASSERT_TRUE(tester.ContainsCookie()); | 1001 ASSERT_TRUE(tester.ContainsCookie()); |
981 std::unique_ptr<BrowsingDataFilterBuilder> filter( | 1002 std::unique_ptr<BrowsingDataFilterBuilder> filter( |
982 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); | 1003 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); |
983 filter->AddRegisterableDomain(kTestRegisterableDomain1); | 1004 filter->AddRegisterableDomain(kTestRegisterableDomain1); |
984 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), | 1005 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), |
985 BrowsingDataRemover::DATA_TYPE_COOKIES, | 1006 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
986 std::move(filter)); | 1007 std::move(filter)); |
987 | 1008 |
988 EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); | 1009 EXPECT_EQ(content::BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); |
989 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1010 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
990 GetOriginTypeMask()); | 1011 GetOriginTypeMask()); |
991 EXPECT_TRUE(tester.ContainsCookie()); | 1012 EXPECT_TRUE(tester.ContainsCookie()); |
992 | 1013 |
993 std::unique_ptr<BrowsingDataFilterBuilder> filter2( | 1014 std::unique_ptr<BrowsingDataFilterBuilder> filter2( |
994 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); | 1015 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); |
995 filter2->AddRegisterableDomain(kTestRegisterableDomain1); | 1016 filter2->AddRegisterableDomain(kTestRegisterableDomain1); |
996 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), | 1017 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), |
997 BrowsingDataRemover::DATA_TYPE_COOKIES, | 1018 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
998 std::move(filter2)); | 1019 std::move(filter2)); |
999 EXPECT_FALSE(tester.ContainsCookie()); | 1020 EXPECT_FALSE(tester.ContainsCookie()); |
1000 } | 1021 } |
1001 | 1022 |
1002 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryForever) { | 1023 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryForever) { |
1003 RemoveHistoryTester tester; | 1024 RemoveHistoryTester tester; |
1004 ASSERT_TRUE(tester.Init(GetProfile())); | 1025 ASSERT_TRUE(tester.Init(GetProfile())); |
1005 | 1026 |
1006 tester.AddHistory(kOrigin1, base::Time::Now()); | 1027 tester.AddHistory(kOrigin1, base::Time::Now()); |
1007 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1)); | 1028 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1)); |
1008 | 1029 |
1009 BlockUntilBrowsingDataRemoved( | 1030 BlockUntilBrowsingDataRemoved( |
1010 base::Time(), base::Time::Max(), | 1031 base::Time(), base::Time::Max(), |
1011 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); | 1032 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); |
1012 | 1033 |
1013 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, | 1034 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, |
1014 GetRemovalMask()); | 1035 GetRemovalMask()); |
1015 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1036 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1016 GetOriginTypeMask()); | 1037 GetOriginTypeMask()); |
1017 EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1)); | 1038 EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1)); |
1018 } | 1039 } |
1019 | 1040 |
1020 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryForLastHour) { | 1041 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryForLastHour) { |
1021 RemoveHistoryTester tester; | 1042 RemoveHistoryTester tester; |
1022 ASSERT_TRUE(tester.Init(GetProfile())); | 1043 ASSERT_TRUE(tester.Init(GetProfile())); |
1023 | 1044 |
1024 base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2); | 1045 base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2); |
1025 | 1046 |
1026 tester.AddHistory(kOrigin1, base::Time::Now()); | 1047 tester.AddHistory(kOrigin1, base::Time::Now()); |
1027 tester.AddHistory(kOrigin2, two_hours_ago); | 1048 tester.AddHistory(kOrigin2, two_hours_ago); |
1028 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1)); | 1049 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1)); |
1029 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2)); | 1050 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2)); |
1030 | 1051 |
1031 BlockUntilBrowsingDataRemoved( | 1052 BlockUntilBrowsingDataRemoved( |
1032 AnHourAgo(), base::Time::Max(), | 1053 AnHourAgo(), base::Time::Max(), |
1033 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); | 1054 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); |
1034 | 1055 |
1035 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, | 1056 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, |
1036 GetRemovalMask()); | 1057 GetRemovalMask()); |
1037 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1058 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1038 GetOriginTypeMask()); | 1059 GetOriginTypeMask()); |
1039 EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1)); | 1060 EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1)); |
1040 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2)); | 1061 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2)); |
1041 } | 1062 } |
1042 | 1063 |
1043 // This should crash (DCHECK) in Debug, but death tests don't work properly | 1064 // This should crash (DCHECK) in Debug, but death tests don't work properly |
1044 // here. | 1065 // here. |
1045 // TODO(msramek): To make this testable, the refusal to delete history should | 1066 // TODO(msramek): To make this testable, the refusal to delete history should |
1046 // be made a part of interface (e.g. a success value) as opposed to a DCHECK. | 1067 // be made a part of interface (e.g. a success value) as opposed to a DCHECK. |
1047 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON) | 1068 #if defined(NDEBUG) && !defined(DCHECK_ALWAYS_ON) |
1048 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryProhibited) { | 1069 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveHistoryProhibited) { |
1049 RemoveHistoryTester tester; | 1070 RemoveHistoryTester tester; |
1050 ASSERT_TRUE(tester.Init(GetProfile())); | 1071 ASSERT_TRUE(tester.Init(GetProfile())); |
1051 PrefService* prefs = GetProfile()->GetPrefs(); | 1072 PrefService* prefs = GetProfile()->GetPrefs(); |
1052 prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false); | 1073 prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false); |
1053 | 1074 |
1054 base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2); | 1075 base::Time two_hours_ago = base::Time::Now() - base::TimeDelta::FromHours(2); |
1055 | 1076 |
1056 tester.AddHistory(kOrigin1, base::Time::Now()); | 1077 tester.AddHistory(kOrigin1, base::Time::Now()); |
1057 tester.AddHistory(kOrigin2, two_hours_ago); | 1078 tester.AddHistory(kOrigin2, two_hours_ago); |
1058 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1)); | 1079 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin1)); |
1059 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2)); | 1080 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2)); |
1060 | 1081 |
1061 BlockUntilBrowsingDataRemoved( | 1082 BlockUntilBrowsingDataRemoved( |
1062 AnHourAgo(), base::Time::Max(), | 1083 AnHourAgo(), base::Time::Max(), |
1063 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); | 1084 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); |
1064 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, | 1085 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, |
1065 GetRemovalMask()); | 1086 GetRemovalMask()); |
1066 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1087 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1067 GetOriginTypeMask()); | 1088 GetOriginTypeMask()); |
1068 | 1089 |
1069 // Nothing should have been deleted. | 1090 // Nothing should have been deleted. |
1070 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin1)); | 1091 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin1)); |
1071 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2)); | 1092 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2)); |
1072 } | 1093 } |
1073 | 1094 |
1074 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1095 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1075 RemoveMultipleTypesHistoryProhibited) { | 1096 RemoveMultipleTypesHistoryProhibited) { |
1076 PrefService* prefs = GetProfile()->GetPrefs(); | 1097 PrefService* prefs = GetProfile()->GetPrefs(); |
1077 prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false); | 1098 prefs->SetBoolean(prefs::kAllowDeletingBrowserHistory, false); |
1078 | 1099 |
1079 // Add some history. | 1100 // Add some history. |
1080 RemoveHistoryTester history_tester; | 1101 RemoveHistoryTester history_tester; |
1081 ASSERT_TRUE(history_tester.Init(GetProfile())); | 1102 ASSERT_TRUE(history_tester.Init(GetProfile())); |
1082 history_tester.AddHistory(kOrigin1, base::Time::Now()); | 1103 history_tester.AddHistory(kOrigin1, base::Time::Now()); |
1083 ASSERT_TRUE(history_tester.HistoryContainsURL(kOrigin1)); | 1104 ASSERT_TRUE(history_tester.HistoryContainsURL(kOrigin1)); |
1084 | 1105 |
1085 // Expect that passwords will be deleted, as they do not depend | 1106 // Expect that passwords will be deleted, as they do not depend |
1086 // on |prefs::kAllowDeletingBrowserHistory|. | 1107 // on |prefs::kAllowDeletingBrowserHistory|. |
1087 RemovePasswordsTester tester(GetProfile()); | 1108 RemovePasswordsTester tester(GetProfile()); |
1088 EXPECT_CALL(*tester.store(), RemoveLoginsByURLAndTimeImpl(_, _, _)); | 1109 EXPECT_CALL(*tester.store(), RemoveLoginsByURLAndTimeImpl(_, _, _)); |
1089 | 1110 |
1090 int removal_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY | | 1111 int removal_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY | |
1091 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS; | 1112 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS; |
1092 | 1113 |
1093 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), | 1114 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), |
1094 removal_mask, false); | 1115 removal_mask, false); |
1095 EXPECT_EQ(removal_mask, GetRemovalMask()); | 1116 EXPECT_EQ(removal_mask, GetRemovalMask()); |
1096 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1117 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1097 GetOriginTypeMask()); | 1118 GetOriginTypeMask()); |
1098 | 1119 |
1099 // Verify that history was not deleted. | 1120 // Verify that history was not deleted. |
1100 EXPECT_TRUE(history_tester.HistoryContainsURL(kOrigin1)); | 1121 EXPECT_TRUE(history_tester.HistoryContainsURL(kOrigin1)); |
1101 } | 1122 } |
1102 #endif | 1123 #endif |
1103 | 1124 |
1104 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveExternalProtocolData) { | 1125 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveExternalProtocolData) { |
1105 TestingProfile* profile = GetProfile(); | 1126 TestingProfile* profile = GetProfile(); |
1106 // Add external protocol data on profile. | 1127 // Add external protocol data on profile. |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1180 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2)); | 1201 ASSERT_TRUE(tester.HistoryContainsURL(kOrigin2)); |
1181 | 1202 |
1182 std::unique_ptr<BrowsingDataFilterBuilder> builder( | 1203 std::unique_ptr<BrowsingDataFilterBuilder> builder( |
1183 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); | 1204 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); |
1184 BlockUntilOriginDataRemoved( | 1205 BlockUntilOriginDataRemoved( |
1185 AnHourAgo(), base::Time::Max(), | 1206 AnHourAgo(), base::Time::Max(), |
1186 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, std::move(builder)); | 1207 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, std::move(builder)); |
1187 | 1208 |
1188 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, | 1209 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, |
1189 GetRemovalMask()); | 1210 GetRemovalMask()); |
1190 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1211 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1191 GetOriginTypeMask()); | 1212 GetOriginTypeMask()); |
1192 EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1)); | 1213 EXPECT_FALSE(tester.HistoryContainsURL(kOrigin1)); |
1193 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2)); | 1214 EXPECT_TRUE(tester.HistoryContainsURL(kOrigin2)); |
1194 } | 1215 } |
1195 | 1216 |
1196 // Verify that clearing autofill form data works. | 1217 // Verify that clearing autofill form data works. |
1197 TEST_F(ChromeBrowsingDataRemoverDelegateTest, AutofillRemovalLastHour) { | 1218 TEST_F(ChromeBrowsingDataRemoverDelegateTest, AutofillRemovalLastHour) { |
1198 GetProfile()->CreateWebDataService(); | 1219 GetProfile()->CreateWebDataService(); |
1199 RemoveAutofillTester tester(GetProfile()); | 1220 RemoveAutofillTester tester(GetProfile()); |
1200 | 1221 |
1201 ASSERT_FALSE(tester.HasProfile()); | 1222 ASSERT_FALSE(tester.HasProfile()); |
1202 tester.AddProfilesAndCards(); | 1223 tester.AddProfilesAndCards(); |
1203 ASSERT_TRUE(tester.HasProfile()); | 1224 ASSERT_TRUE(tester.HasProfile()); |
1204 | 1225 |
1205 BlockUntilBrowsingDataRemoved( | 1226 BlockUntilBrowsingDataRemoved( |
1206 AnHourAgo(), base::Time::Max(), | 1227 AnHourAgo(), base::Time::Max(), |
1207 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, false); | 1228 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, false); |
1208 | 1229 |
1209 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, | 1230 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, |
1210 GetRemovalMask()); | 1231 GetRemovalMask()); |
1211 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1232 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1212 GetOriginTypeMask()); | 1233 GetOriginTypeMask()); |
1213 ASSERT_FALSE(tester.HasProfile()); | 1234 ASSERT_FALSE(tester.HasProfile()); |
1214 } | 1235 } |
1215 | 1236 |
1216 TEST_F(ChromeBrowsingDataRemoverDelegateTest, AutofillRemovalEverything) { | 1237 TEST_F(ChromeBrowsingDataRemoverDelegateTest, AutofillRemovalEverything) { |
1217 GetProfile()->CreateWebDataService(); | 1238 GetProfile()->CreateWebDataService(); |
1218 RemoveAutofillTester tester(GetProfile()); | 1239 RemoveAutofillTester tester(GetProfile()); |
1219 | 1240 |
1220 ASSERT_FALSE(tester.HasProfile()); | 1241 ASSERT_FALSE(tester.HasProfile()); |
1221 tester.AddProfilesAndCards(); | 1242 tester.AddProfilesAndCards(); |
1222 ASSERT_TRUE(tester.HasProfile()); | 1243 ASSERT_TRUE(tester.HasProfile()); |
1223 | 1244 |
1224 BlockUntilBrowsingDataRemoved( | 1245 BlockUntilBrowsingDataRemoved( |
1225 base::Time(), base::Time::Max(), | 1246 base::Time(), base::Time::Max(), |
1226 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, false); | 1247 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, false); |
1227 | 1248 |
1228 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, | 1249 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_FORM_DATA, |
1229 GetRemovalMask()); | 1250 GetRemovalMask()); |
1230 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1251 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1231 GetOriginTypeMask()); | 1252 GetOriginTypeMask()); |
1232 ASSERT_FALSE(tester.HasProfile()); | 1253 ASSERT_FALSE(tester.HasProfile()); |
1233 } | 1254 } |
1234 | 1255 |
1235 // Verify that clearing autofill form data works. | 1256 // Verify that clearing autofill form data works. |
1236 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1257 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1237 AutofillOriginsRemovedWithHistory) { | 1258 AutofillOriginsRemovedWithHistory) { |
1238 GetProfile()->CreateWebDataService(); | 1259 GetProfile()->CreateWebDataService(); |
1239 RemoveAutofillTester tester(GetProfile()); | 1260 RemoveAutofillTester tester(GetProfile()); |
1240 | 1261 |
1241 tester.AddProfilesAndCards(); | 1262 tester.AddProfilesAndCards(); |
1242 EXPECT_FALSE(tester.HasOrigin(std::string())); | 1263 EXPECT_FALSE(tester.HasOrigin(std::string())); |
1243 EXPECT_TRUE(tester.HasOrigin(kWebOrigin)); | 1264 EXPECT_TRUE(tester.HasOrigin(kWebOrigin)); |
1244 EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin)); | 1265 EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin)); |
1245 | 1266 |
1246 BlockUntilBrowsingDataRemoved( | 1267 BlockUntilBrowsingDataRemoved( |
1247 AnHourAgo(), base::Time::Max(), | 1268 AnHourAgo(), base::Time::Max(), |
1248 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); | 1269 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, false); |
1249 | 1270 |
1250 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, | 1271 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, |
1251 GetRemovalMask()); | 1272 GetRemovalMask()); |
1252 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1273 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1253 GetOriginTypeMask()); | 1274 GetOriginTypeMask()); |
1254 EXPECT_TRUE(tester.HasOrigin(std::string())); | 1275 EXPECT_TRUE(tester.HasOrigin(std::string())); |
1255 EXPECT_FALSE(tester.HasOrigin(kWebOrigin)); | 1276 EXPECT_FALSE(tester.HasOrigin(kWebOrigin)); |
1256 EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin)); | 1277 EXPECT_TRUE(tester.HasOrigin(autofill::kSettingsOrigin)); |
1257 } | 1278 } |
1258 | 1279 |
1259 TEST_F(ChromeBrowsingDataRemoverDelegateTest, ZeroSuggestCacheClear) { | 1280 TEST_F(ChromeBrowsingDataRemoverDelegateTest, ZeroSuggestCacheClear) { |
1260 PrefService* prefs = GetProfile()->GetPrefs(); | 1281 PrefService* prefs = GetProfile()->GetPrefs(); |
1261 prefs->SetString(omnibox::kZeroSuggestCachedResults, | 1282 prefs->SetString(omnibox::kZeroSuggestCachedResults, |
1262 "[\"\", [\"foo\", \"bar\"]]"); | 1283 "[\"\", [\"foo\", \"bar\"]]"); |
1263 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 1284 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
1264 BrowsingDataRemover::DATA_TYPE_COOKIES, false); | 1285 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
| 1286 false); |
1265 | 1287 |
1266 // Expect the prefs to be cleared when cookies are removed. | 1288 // Expect the prefs to be cleared when cookies are removed. |
1267 EXPECT_TRUE(prefs->GetString(omnibox::kZeroSuggestCachedResults).empty()); | 1289 EXPECT_TRUE(prefs->GetString(omnibox::kZeroSuggestCachedResults).empty()); |
1268 EXPECT_EQ(BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); | 1290 EXPECT_EQ(content::BrowsingDataRemover::DATA_TYPE_COOKIES, GetRemovalMask()); |
1269 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1291 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1270 GetOriginTypeMask()); | 1292 GetOriginTypeMask()); |
1271 } | 1293 } |
1272 | 1294 |
1273 #if defined(OS_CHROMEOS) | 1295 #if defined(OS_CHROMEOS) |
1274 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1296 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1275 ContentProtectionPlatformKeysRemoval) { | 1297 ContentProtectionPlatformKeysRemoval) { |
1276 chromeos::ScopedTestDeviceSettingsService test_device_settings_service; | 1298 chromeos::ScopedTestDeviceSettingsService test_device_settings_service; |
1277 chromeos::ScopedTestCrosSettings test_cros_settings; | 1299 chromeos::ScopedTestCrosSettings test_cros_settings; |
1278 chromeos::MockUserManager* mock_user_manager = | 1300 chromeos::MockUserManager* mock_user_manager = |
1279 new testing::NiceMock<chromeos::MockUserManager>(); | 1301 new testing::NiceMock<chromeos::MockUserManager>(); |
1280 mock_user_manager->SetActiveUser( | 1302 mock_user_manager->SetActiveUser( |
1281 AccountId::FromUserEmail("test@example.com")); | 1303 AccountId::FromUserEmail("test@example.com")); |
1282 chromeos::ScopedUserManagerEnabler user_manager_enabler(mock_user_manager); | 1304 chromeos::ScopedUserManagerEnabler user_manager_enabler(mock_user_manager); |
1283 | 1305 |
1284 std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter = | 1306 std::unique_ptr<chromeos::DBusThreadManagerSetter> dbus_setter = |
1285 chromeos::DBusThreadManager::GetSetterForTesting(); | 1307 chromeos::DBusThreadManager::GetSetterForTesting(); |
1286 chromeos::MockCryptohomeClient* cryptohome_client = | 1308 chromeos::MockCryptohomeClient* cryptohome_client = |
1287 new chromeos::MockCryptohomeClient; | 1309 new chromeos::MockCryptohomeClient; |
1288 dbus_setter->SetCryptohomeClient( | 1310 dbus_setter->SetCryptohomeClient( |
1289 std::unique_ptr<chromeos::CryptohomeClient>(cryptohome_client)); | 1311 std::unique_ptr<chromeos::CryptohomeClient>(cryptohome_client)); |
1290 | 1312 |
1291 // Expect exactly one call. No calls means no attempt to delete keys and more | 1313 // Expect exactly one call. No calls means no attempt to delete keys and more |
1292 // than one call means a significant performance problem. | 1314 // than one call means a significant performance problem. |
1293 EXPECT_CALL(*cryptohome_client, TpmAttestationDeleteKeys(_, _, _, _)) | 1315 EXPECT_CALL(*cryptohome_client, TpmAttestationDeleteKeys(_, _, _, _)) |
1294 .WillOnce(WithArgs<3>(Invoke(FakeDBusCall))); | 1316 .WillOnce(WithArgs<3>(Invoke(FakeDBusCall))); |
1295 | 1317 |
1296 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 1318 BlockUntilBrowsingDataRemoved( |
1297 BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES, | 1319 base::Time(), base::Time::Max(), |
1298 false); | 1320 content::BrowsingDataRemover::DATA_TYPE_MEDIA_LICENSES, false); |
1299 | 1321 |
1300 chromeos::DBusThreadManager::Shutdown(); | 1322 chromeos::DBusThreadManager::Shutdown(); |
1301 } | 1323 } |
1302 #endif | 1324 #endif |
1303 | 1325 |
1304 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Null) { | 1326 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Null) { |
1305 const ClearDomainReliabilityTester& tester = | 1327 const ClearDomainReliabilityTester& tester = |
1306 clear_domain_reliability_tester(); | 1328 clear_domain_reliability_tester(); |
1307 | 1329 |
1308 EXPECT_EQ(0u, tester.clear_count()); | 1330 EXPECT_EQ(0u, tester.clear_count()); |
(...skipping 30 matching lines...) Expand all Loading... |
1339 EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode()); | 1361 EXPECT_EQ(CLEAR_BEACONS, tester.last_clear_mode()); |
1340 EXPECT_TRUE(ProbablySameFilters( | 1362 EXPECT_TRUE(ProbablySameFilters( |
1341 builder->BuildGeneralFilter(), tester.last_filter())); | 1363 builder->BuildGeneralFilter(), tester.last_filter())); |
1342 } | 1364 } |
1343 | 1365 |
1344 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Contexts) { | 1366 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_Contexts) { |
1345 const ClearDomainReliabilityTester& tester = | 1367 const ClearDomainReliabilityTester& tester = |
1346 clear_domain_reliability_tester(); | 1368 clear_domain_reliability_tester(); |
1347 | 1369 |
1348 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 1370 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
1349 BrowsingDataRemover::DATA_TYPE_COOKIES, false); | 1371 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
| 1372 false); |
1350 EXPECT_EQ(1u, tester.clear_count()); | 1373 EXPECT_EQ(1u, tester.clear_count()); |
1351 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); | 1374 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); |
1352 EXPECT_TRUE(ProbablySameFilters( | 1375 EXPECT_TRUE(ProbablySameFilters( |
1353 BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter())); | 1376 BrowsingDataFilterBuilder::BuildNoopFilter(), tester.last_filter())); |
1354 } | 1377 } |
1355 | 1378 |
1356 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1379 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1357 DomainReliability_Contexts_WithFilter) { | 1380 DomainReliability_Contexts_WithFilter) { |
1358 const ClearDomainReliabilityTester& tester = | 1381 const ClearDomainReliabilityTester& tester = |
1359 clear_domain_reliability_tester(); | 1382 clear_domain_reliability_tester(); |
1360 | 1383 |
1361 std::unique_ptr<BrowsingDataFilterBuilder> builder( | 1384 std::unique_ptr<BrowsingDataFilterBuilder> builder( |
1362 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); | 1385 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); |
1363 builder->AddRegisterableDomain(kTestRegisterableDomain1); | 1386 builder->AddRegisterableDomain(kTestRegisterableDomain1); |
1364 | 1387 |
1365 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), | 1388 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), |
1366 BrowsingDataRemover::DATA_TYPE_COOKIES, | 1389 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
1367 builder->Copy()); | 1390 builder->Copy()); |
1368 EXPECT_EQ(1u, tester.clear_count()); | 1391 EXPECT_EQ(1u, tester.clear_count()); |
1369 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); | 1392 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); |
1370 EXPECT_TRUE(ProbablySameFilters( | 1393 EXPECT_TRUE(ProbablySameFilters( |
1371 builder->BuildGeneralFilter(), tester.last_filter())); | 1394 builder->BuildGeneralFilter(), tester.last_filter())); |
1372 } | 1395 } |
1373 | 1396 |
1374 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_ContextsWin) { | 1397 TEST_F(ChromeBrowsingDataRemoverDelegateTest, DomainReliability_ContextsWin) { |
1375 const ClearDomainReliabilityTester& tester = | 1398 const ClearDomainReliabilityTester& tester = |
1376 clear_domain_reliability_tester(); | 1399 clear_domain_reliability_tester(); |
1377 | 1400 |
1378 BlockUntilBrowsingDataRemoved( | 1401 BlockUntilBrowsingDataRemoved( |
1379 base::Time(), base::Time::Max(), | 1402 base::Time(), base::Time::Max(), |
1380 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY | | 1403 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY | |
1381 BrowsingDataRemover::DATA_TYPE_COOKIES, | 1404 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
1382 false); | 1405 false); |
1383 EXPECT_EQ(1u, tester.clear_count()); | 1406 EXPECT_EQ(1u, tester.clear_count()); |
1384 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); | 1407 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); |
1385 } | 1408 } |
1386 | 1409 |
1387 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1410 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1388 DomainReliability_ProtectedOrigins) { | 1411 DomainReliability_ProtectedOrigins) { |
1389 const ClearDomainReliabilityTester& tester = | 1412 const ClearDomainReliabilityTester& tester = |
1390 clear_domain_reliability_tester(); | 1413 clear_domain_reliability_tester(); |
1391 | 1414 |
1392 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 1415 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
1393 BrowsingDataRemover::DATA_TYPE_COOKIES, true); | 1416 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
| 1417 true); |
1394 EXPECT_EQ(1u, tester.clear_count()); | 1418 EXPECT_EQ(1u, tester.clear_count()); |
1395 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); | 1419 EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode()); |
1396 } | 1420 } |
1397 | 1421 |
1398 // TODO(juliatuttle): This isn't actually testing the no-monitor case, since | 1422 // TODO(juliatuttle): This isn't actually testing the no-monitor case, since |
1399 // BrowsingDataRemoverTest now creates one unconditionally, since it's needed | 1423 // BrowsingDataRemoverTest now creates one unconditionally, since it's needed |
1400 // for some unrelated test cases. This should be fixed so it tests the no- | 1424 // for some unrelated test cases. This should be fixed so it tests the no- |
1401 // monitor case again. | 1425 // monitor case again. |
1402 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1426 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1403 DISABLED_DomainReliability_NoMonitor) { | 1427 DISABLED_DomainReliability_NoMonitor) { |
1404 BlockUntilBrowsingDataRemoved( | 1428 BlockUntilBrowsingDataRemoved( |
1405 base::Time(), base::Time::Max(), | 1429 base::Time(), base::Time::Max(), |
1406 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY | | 1430 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY | |
1407 BrowsingDataRemover::DATA_TYPE_COOKIES, | 1431 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
1408 false); | 1432 false); |
1409 } | 1433 } |
1410 | 1434 |
1411 // Tests that the deletion of downloads completes successfully and that | 1435 // Tests that the deletion of downloads completes successfully and that |
1412 // ChromeDownloadManagerDelegate is correctly created and shut down. | 1436 // ChromeDownloadManagerDelegate is correctly created and shut down. |
1413 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveDownloads) { | 1437 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemoveDownloads) { |
1414 RemoveDownloadsTester tester(GetProfile()); | 1438 RemoveDownloadsTester tester(GetProfile()); |
1415 | 1439 |
1416 EXPECT_CALL( | 1440 EXPECT_CALL( |
1417 *tester.download_manager(), RemoveDownloadsByURLAndTime(_, _, _)); | 1441 *tester.download_manager(), RemoveDownloadsByURLAndTime(_, _, _)); |
1418 | 1442 |
1419 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 1443 BlockUntilBrowsingDataRemoved( |
1420 BrowsingDataRemover::DATA_TYPE_DOWNLOADS, | 1444 base::Time(), base::Time::Max(), |
1421 false); | 1445 content::BrowsingDataRemover::DATA_TYPE_DOWNLOADS, false); |
1422 } | 1446 } |
1423 | 1447 |
1424 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemovePasswordStatistics) { | 1448 TEST_F(ChromeBrowsingDataRemoverDelegateTest, RemovePasswordStatistics) { |
1425 RemovePasswordsTester tester(GetProfile()); | 1449 RemovePasswordsTester tester(GetProfile()); |
1426 base::Callback<bool(const GURL&)> empty_filter; | 1450 base::Callback<bool(const GURL&)> empty_filter; |
1427 | 1451 |
1428 EXPECT_CALL(*tester.store(), RemoveStatisticsByOriginAndTimeImpl( | 1452 EXPECT_CALL(*tester.store(), RemoveStatisticsByOriginAndTimeImpl( |
1429 ProbablySameFilter(empty_filter), | 1453 ProbablySameFilter(empty_filter), |
1430 base::Time(), base::Time::Max())); | 1454 base::Time(), base::Time::Max())); |
1431 BlockUntilBrowsingDataRemoved( | 1455 BlockUntilBrowsingDataRemoved( |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1487 RemovePasswordsTester tester(GetProfile()); | 1511 RemovePasswordsTester tester(GetProfile()); |
1488 base::Callback<bool(const GURL&)> empty_filter = | 1512 base::Callback<bool(const GURL&)> empty_filter = |
1489 BrowsingDataFilterBuilder::BuildNoopFilter(); | 1513 BrowsingDataFilterBuilder::BuildNoopFilter(); |
1490 | 1514 |
1491 EXPECT_CALL( | 1515 EXPECT_CALL( |
1492 *tester.store(), | 1516 *tester.store(), |
1493 DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter))) | 1517 DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter))) |
1494 .WillOnce(Return(password_manager::PasswordStoreChangeList())); | 1518 .WillOnce(Return(password_manager::PasswordStoreChangeList())); |
1495 | 1519 |
1496 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 1520 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
1497 BrowsingDataRemover::DATA_TYPE_COOKIES, false); | 1521 content::BrowsingDataRemover::DATA_TYPE_COOKIES, |
| 1522 false); |
1498 } | 1523 } |
1499 | 1524 |
1500 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1525 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1501 DisableAutoSignInAfterRemovingPasswords) { | 1526 DisableAutoSignInAfterRemovingPasswords) { |
1502 RemovePasswordsTester tester(GetProfile()); | 1527 RemovePasswordsTester tester(GetProfile()); |
1503 base::Callback<bool(const GURL&)> empty_filter = | 1528 base::Callback<bool(const GURL&)> empty_filter = |
1504 BrowsingDataFilterBuilder::BuildNoopFilter(); | 1529 BrowsingDataFilterBuilder::BuildNoopFilter(); |
1505 | 1530 |
1506 EXPECT_CALL(*tester.store(), RemoveLoginsByURLAndTimeImpl(_, _, _)) | 1531 EXPECT_CALL(*tester.store(), RemoveLoginsByURLAndTimeImpl(_, _, _)) |
1507 .WillOnce(Return(password_manager::PasswordStoreChangeList())); | 1532 .WillOnce(Return(password_manager::PasswordStoreChangeList())); |
1508 EXPECT_CALL( | 1533 EXPECT_CALL( |
1509 *tester.store(), | 1534 *tester.store(), |
1510 DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter))) | 1535 DisableAutoSignInForOriginsImpl(ProbablySameFilter(empty_filter))) |
1511 .WillOnce(Return(password_manager::PasswordStoreChangeList())); | 1536 .WillOnce(Return(password_manager::PasswordStoreChangeList())); |
1512 | 1537 |
1513 BlockUntilBrowsingDataRemoved( | 1538 BlockUntilBrowsingDataRemoved( |
1514 base::Time(), base::Time::Max(), | 1539 base::Time(), base::Time::Max(), |
1515 BrowsingDataRemover::DATA_TYPE_COOKIES | | 1540 content::BrowsingDataRemover::DATA_TYPE_COOKIES | |
1516 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS, | 1541 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PASSWORDS, |
1517 false); | 1542 false); |
1518 } | 1543 } |
1519 | 1544 |
1520 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1545 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1521 RemoveContentSettingsWithBlacklist) { | 1546 RemoveContentSettingsWithBlacklist) { |
1522 // Add our settings. | 1547 // Add our settings. |
1523 HostContentSettingsMap* host_content_settings_map = | 1548 HostContentSettingsMap* host_content_settings_map = |
1524 HostContentSettingsMapFactory::GetForProfile(GetProfile()); | 1549 HostContentSettingsMapFactory::GetForProfile(GetProfile()); |
1525 host_content_settings_map->SetWebsiteSettingDefaultScope( | 1550 host_content_settings_map->SetWebsiteSettingDefaultScope( |
(...skipping 14 matching lines...) Expand all Loading... |
1540 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); | 1565 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); |
1541 filter->AddRegisterableDomain(kTestRegisterableDomain1); | 1566 filter->AddRegisterableDomain(kTestRegisterableDomain1); |
1542 filter->AddRegisterableDomain(kTestRegisterableDomain3); | 1567 filter->AddRegisterableDomain(kTestRegisterableDomain3); |
1543 BlockUntilOriginDataRemoved( | 1568 BlockUntilOriginDataRemoved( |
1544 AnHourAgo(), base::Time::Max(), | 1569 AnHourAgo(), base::Time::Max(), |
1545 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA, | 1570 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA, |
1546 std::move(filter)); | 1571 std::move(filter)); |
1547 | 1572 |
1548 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA, | 1573 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_USAGE_DATA, |
1549 GetRemovalMask()); | 1574 GetRemovalMask()); |
1550 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1575 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1551 GetOriginTypeMask()); | 1576 GetOriginTypeMask()); |
1552 | 1577 |
1553 // Verify we only have true, and they're origin1, origin3, and origin4. | 1578 // Verify we only have true, and they're origin1, origin3, and origin4. |
1554 ContentSettingsForOneType host_settings; | 1579 ContentSettingsForOneType host_settings; |
1555 host_content_settings_map->GetSettingsForOneType( | 1580 host_content_settings_map->GetSettingsForOneType( |
1556 CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(), &host_settings); | 1581 CONTENT_SETTINGS_TYPE_SITE_ENGAGEMENT, std::string(), &host_settings); |
1557 EXPECT_EQ(3u, host_settings.size()); | 1582 EXPECT_EQ(3u, host_settings.size()); |
1558 EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1), | 1583 EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1), |
1559 host_settings[0].primary_pattern) | 1584 host_settings[0].primary_pattern) |
1560 << host_settings[0].primary_pattern.ToString(); | 1585 << host_settings[0].primary_pattern.ToString(); |
(...skipping 21 matching lines...) Expand all Loading... |
1582 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); | 1607 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); |
1583 filter->AddRegisterableDomain(kTestRegisterableDomain1); | 1608 filter->AddRegisterableDomain(kTestRegisterableDomain1); |
1584 filter->AddRegisterableDomain(kTestRegisterableDomain3); | 1609 filter->AddRegisterableDomain(kTestRegisterableDomain3); |
1585 BlockUntilOriginDataRemoved( | 1610 BlockUntilOriginDataRemoved( |
1586 AnHourAgo(), base::Time::Max(), | 1611 AnHourAgo(), base::Time::Max(), |
1587 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_DURABLE_PERMISSION, | 1612 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_DURABLE_PERMISSION, |
1588 std::move(filter)); | 1613 std::move(filter)); |
1589 | 1614 |
1590 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_DURABLE_PERMISSION, | 1615 EXPECT_EQ(ChromeBrowsingDataRemoverDelegate::DATA_TYPE_DURABLE_PERMISSION, |
1591 GetRemovalMask()); | 1616 GetRemovalMask()); |
1592 EXPECT_EQ(BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, | 1617 EXPECT_EQ(content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, |
1593 GetOriginTypeMask()); | 1618 GetOriginTypeMask()); |
1594 | 1619 |
1595 // Verify we only have allow for the first origin. | 1620 // Verify we only have allow for the first origin. |
1596 ContentSettingsForOneType host_settings; | 1621 ContentSettingsForOneType host_settings; |
1597 host_content_settings_map->GetSettingsForOneType( | 1622 host_content_settings_map->GetSettingsForOneType( |
1598 CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings); | 1623 CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings); |
1599 | 1624 |
1600 ASSERT_EQ(2u, host_settings.size()); | 1625 ASSERT_EQ(2u, host_settings.size()); |
1601 // Only the first should should have a setting. | 1626 // Only the first should should have a setting. |
1602 EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1), | 1627 EXPECT_EQ(ContentSettingsPattern::FromURLNoWildcard(kOrigin1), |
(...skipping 15 matching lines...) Expand all Loading... |
1618 DurableStoragePermissionContext durable_permission(GetProfile()); | 1643 DurableStoragePermissionContext durable_permission(GetProfile()); |
1619 durable_permission.UpdateContentSetting(kOrigin1, GURL(), | 1644 durable_permission.UpdateContentSetting(kOrigin1, GURL(), |
1620 CONTENT_SETTING_ALLOW); | 1645 CONTENT_SETTING_ALLOW); |
1621 ContentSettingsForOneType host_settings; | 1646 ContentSettingsForOneType host_settings; |
1622 host_content_settings_map->GetSettingsForOneType( | 1647 host_content_settings_map->GetSettingsForOneType( |
1623 CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings); | 1648 CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings); |
1624 EXPECT_EQ(2u, host_settings.size()); | 1649 EXPECT_EQ(2u, host_settings.size()); |
1625 | 1650 |
1626 BlockUntilBrowsingDataRemoved( | 1651 BlockUntilBrowsingDataRemoved( |
1627 base::Time(), base::Time::Max(), | 1652 base::Time(), base::Time::Max(), |
1628 BrowsingDataRemover::DATA_TYPE_EMBEDDER_DOM_STORAGE, false); | 1653 content::BrowsingDataRemover::DATA_TYPE_EMBEDDER_DOM_STORAGE, false); |
1629 | 1654 |
1630 // After the deletion, only the wildcard should remain. | 1655 // After the deletion, only the wildcard should remain. |
1631 host_content_settings_map->GetSettingsForOneType( | 1656 host_content_settings_map->GetSettingsForOneType( |
1632 CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings); | 1657 CONTENT_SETTINGS_TYPE_DURABLE_STORAGE, std::string(), &host_settings); |
1633 EXPECT_EQ(1u, host_settings.size()); | 1658 EXPECT_EQ(1u, host_settings.size()); |
1634 EXPECT_EQ(ContentSettingsPattern::Wildcard(), | 1659 EXPECT_EQ(ContentSettingsPattern::Wildcard(), |
1635 host_settings[0].primary_pattern) | 1660 host_settings[0].primary_pattern) |
1636 << host_settings[0].primary_pattern.ToString(); | 1661 << host_settings[0].primary_pattern.ToString(); |
1637 } | 1662 } |
1638 | 1663 |
(...skipping 187 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1826 | 1851 |
1827 // TODO(msramek): Mock PluginDataRemover and test the complete deletion | 1852 // TODO(msramek): Mock PluginDataRemover and test the complete deletion |
1828 // of plugin data as well. | 1853 // of plugin data as well. |
1829 } | 1854 } |
1830 #endif | 1855 #endif |
1831 | 1856 |
1832 // Test that the remover clears bookmark meta data (normally added in a tab | 1857 // Test that the remover clears bookmark meta data (normally added in a tab |
1833 // helper). | 1858 // helper). |
1834 TEST_F(ChromeBrowsingDataRemoverDelegateTest, | 1859 TEST_F(ChromeBrowsingDataRemoverDelegateTest, |
1835 BookmarkLastVisitDatesGetCleared) { | 1860 BookmarkLastVisitDatesGetCleared) { |
1836 TestingProfile profile; | 1861 GetProfile()->CreateBookmarkModel(true); |
1837 profile.CreateBookmarkModel(true); | |
1838 | 1862 |
1839 bookmarks::BookmarkModel* bookmark_model = | 1863 bookmarks::BookmarkModel* bookmark_model = |
1840 BookmarkModelFactory::GetForBrowserContext(&profile); | 1864 BookmarkModelFactory::GetForBrowserContext(GetProfile()); |
1841 bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model); | 1865 bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model); |
1842 | 1866 |
1843 const base::Time delete_begin = | 1867 const base::Time delete_begin = |
1844 base::Time::Now() - base::TimeDelta::FromDays(1); | 1868 base::Time::Now() - base::TimeDelta::FromDays(1); |
1845 | 1869 |
1846 // Create a couple of bookmarks. | 1870 // Create a couple of bookmarks. |
1847 bookmark_model->AddURL(bookmark_model->bookmark_bar_node(), 0, | 1871 bookmark_model->AddURL(bookmark_model->bookmark_bar_node(), 0, |
1848 base::string16(), | 1872 base::string16(), |
1849 GURL("http://foo.org/desktop")); | 1873 GURL("http://foo.org/desktop")); |
1850 bookmark_model->AddURL(bookmark_model->mobile_node(), 0, | 1874 bookmark_model->AddURL(bookmark_model->mobile_node(), 0, |
(...skipping 18 matching lines...) Expand all Loading... |
1869 GURL("http://foo-2.org/"), delete_begin - base::TimeDelta::FromDays(1), | 1893 GURL("http://foo-2.org/"), delete_begin - base::TimeDelta::FromDays(1), |
1870 &meta_info); | 1894 &meta_info); |
1871 | 1895 |
1872 // There should be some recently visited bookmarks. | 1896 // There should be some recently visited bookmarks. |
1873 EXPECT_THAT(ntp_snippets::GetRecentlyVisitedBookmarks( | 1897 EXPECT_THAT(ntp_snippets::GetRecentlyVisitedBookmarks( |
1874 bookmark_model, 2, base::Time::UnixEpoch(), | 1898 bookmark_model, 2, base::Time::UnixEpoch(), |
1875 /*consider_visits_from_desktop=*/false), | 1899 /*consider_visits_from_desktop=*/false), |
1876 Not(IsEmpty())); | 1900 Not(IsEmpty())); |
1877 | 1901 |
1878 // Inject the bookmark model into the remover. | 1902 // Inject the bookmark model into the remover. |
1879 BrowsingDataRemover* remover = | 1903 content::BrowsingDataRemover* remover = |
1880 BrowsingDataRemoverFactory::GetForBrowserContext(&profile); | 1904 content::BrowserContext::GetBrowsingDataRemover(GetProfile()); |
1881 | 1905 |
1882 BrowsingDataRemoverCompletionObserver completion_observer(remover); | 1906 content::BrowsingDataRemoverCompletionObserver completion_observer(remover); |
1883 remover->RemoveAndReply(delete_begin, base::Time::Max(), | 1907 remover->RemoveAndReply(delete_begin, base::Time::Max(), |
1884 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, | 1908 ChromeBrowsingDataRemoverDelegate::DATA_TYPE_HISTORY, |
1885 ChromeBrowsingDataRemoverDelegate::ALL_ORIGIN_TYPES, | 1909 ChromeBrowsingDataRemoverDelegate::ALL_ORIGIN_TYPES, |
1886 &completion_observer); | 1910 &completion_observer); |
1887 completion_observer.BlockUntilCompletion(); | 1911 completion_observer.BlockUntilCompletion(); |
1888 | 1912 |
1889 // There should be only 1 recently visited bookmarks. | 1913 // There should be only 1 recently visited bookmarks. |
1890 std::vector<const bookmarks::BookmarkNode*> remaining_nodes = | 1914 std::vector<const bookmarks::BookmarkNode*> remaining_nodes = |
1891 ntp_snippets::GetRecentlyVisitedBookmarks( | 1915 ntp_snippets::GetRecentlyVisitedBookmarks( |
1892 bookmark_model, 3, base::Time::UnixEpoch(), | 1916 bookmark_model, 3, base::Time::UnixEpoch(), |
(...skipping 96 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1989 EXPECT_FALSE(Match(kOrigin1, kProtected, nullptr)); | 2013 EXPECT_FALSE(Match(kOrigin1, kProtected, nullptr)); |
1990 EXPECT_FALSE(Match(kOriginExt, kProtected, nullptr)); | 2014 EXPECT_FALSE(Match(kOriginExt, kProtected, nullptr)); |
1991 EXPECT_FALSE(Match(kOriginDevTools, kProtected, nullptr)); | 2015 EXPECT_FALSE(Match(kOriginDevTools, kProtected, nullptr)); |
1992 | 2016 |
1993 #if BUILDFLAG(ENABLE_EXTENSIONS) | 2017 #if BUILDFLAG(ENABLE_EXTENSIONS) |
1994 EXPECT_FALSE(Match(kOrigin1, kExtension, nullptr)); | 2018 EXPECT_FALSE(Match(kOrigin1, kExtension, nullptr)); |
1995 EXPECT_TRUE(Match(kOriginExt, kExtension, nullptr)); | 2019 EXPECT_TRUE(Match(kOriginExt, kExtension, nullptr)); |
1996 EXPECT_FALSE(Match(kOriginDevTools, kExtension, nullptr)); | 2020 EXPECT_FALSE(Match(kOriginDevTools, kExtension, nullptr)); |
1997 #endif | 2021 #endif |
1998 } | 2022 } |
OLD | NEW |