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 <stddef.h> | 5 #include <stddef.h> |
6 #include <stdint.h> | 6 #include <stdint.h> |
7 | 7 |
8 #include <list> | 8 #include <list> |
9 #include <memory> | 9 #include <memory> |
10 #include <set> | 10 #include <set> |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
60 | 60 |
61 #if BUILDFLAG(ENABLE_EXTENSIONS) | 61 #if BUILDFLAG(ENABLE_EXTENSIONS) |
62 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h" | 62 #include "chrome/browser/extensions/mock_extension_special_storage_policy.h" |
63 #endif | 63 #endif |
64 | 64 |
65 class MockExtensionSpecialStoragePolicy; | 65 class MockExtensionSpecialStoragePolicy; |
66 | 66 |
67 using content::BrowserThread; | 67 using content::BrowserThread; |
68 using content::BrowserContext; | 68 using content::BrowserContext; |
69 using content::BrowsingDataFilterBuilder; | 69 using content::BrowsingDataFilterBuilder; |
| 70 using content::BrowsingDataType; |
70 using content::StoragePartition; | 71 using content::StoragePartition; |
71 using testing::_; | 72 using testing::_; |
72 using testing::ByRef; | 73 using testing::ByRef; |
73 using testing::Eq; | 74 using testing::Eq; |
74 using testing::Invoke; | 75 using testing::Invoke; |
75 using testing::IsEmpty; | 76 using testing::IsEmpty; |
76 using testing::Matcher; | 77 using testing::Matcher; |
77 using testing::MakeMatcher; | 78 using testing::MakeMatcher; |
78 using testing::MatcherInterface; | 79 using testing::MatcherInterface; |
79 using testing::MatchResultListener; | 80 using testing::MatchResultListener; |
(...skipping 221 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
301 | 302 |
302 inline Matcher<const base::Callback<bool(const GURL&)>&> ProbablySameFilter( | 303 inline Matcher<const base::Callback<bool(const GURL&)>&> ProbablySameFilter( |
303 const base::Callback<bool(const GURL&)>& filter) { | 304 const base::Callback<bool(const GURL&)>& filter) { |
304 return MakeMatcher(new ProbablySameFilterMatcher(filter)); | 305 return MakeMatcher(new ProbablySameFilterMatcher(filter)); |
305 } | 306 } |
306 | 307 |
307 base::Time AnHourAgo() { | 308 base::Time AnHourAgo() { |
308 return base::Time::Now() - base::TimeDelta::FromHours(1); | 309 return base::Time::Now() - base::TimeDelta::FromHours(1); |
309 } | 310 } |
310 | 311 |
| 312 const std::set<const BrowsingDataType*> kQuotaMask = { |
| 313 &content::kBrowsingDataTypeFileSystems, |
| 314 &content::kBrowsingDataTypeWebSQL, |
| 315 &content::kBrowsingDataTypeAppCache, |
| 316 &content::kBrowsingDataTypeServiceWorkers, |
| 317 &content::kBrowsingDataTypeCacheStorage, |
| 318 &content::kBrowsingDataTypeIndexedDB}; |
| 319 |
| 320 // A wrapper to typecast a const initializer to std::set in ambiguous |
| 321 // situations, such as the EXPECT macros. |
| 322 inline const std::set<const BrowsingDataType*> Mask( |
| 323 const std::set<const BrowsingDataType*> mask) { |
| 324 return mask; |
| 325 } |
| 326 |
311 } // namespace | 327 } // namespace |
312 | 328 |
313 // Testers ------------------------------------------------------------------- | 329 // Testers ------------------------------------------------------------------- |
314 | 330 |
315 class RemoveCookieTester { | 331 class RemoveCookieTester { |
316 public: | 332 public: |
317 RemoveCookieTester() {} | 333 RemoveCookieTester() {} |
318 | 334 |
319 // Returns true, if the given cookie exists in the cookie store. | 335 // Returns true, if the given cookie exists in the cookie store. |
320 bool ContainsCookie() { | 336 bool ContainsCookie() { |
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
556 | 572 |
557 // BrowserContext contains a DOMStorageContext. BrowserContext's | 573 // BrowserContext contains a DOMStorageContext. BrowserContext's |
558 // destructor posts a message to the WEBKIT thread to delete some of its | 574 // destructor posts a message to the WEBKIT thread to delete some of its |
559 // member variables. We need to ensure that the browser context is | 575 // member variables. We need to ensure that the browser context is |
560 // destroyed, and that the message loop is cleared out, before destroying | 576 // destroyed, and that the message loop is cleared out, before destroying |
561 // the threads and loop. Otherwise we leak memory. | 577 // the threads and loop. Otherwise we leak memory. |
562 browser_context_.reset(); | 578 browser_context_.reset(); |
563 base::RunLoop().RunUntilIdle(); | 579 base::RunLoop().RunUntilIdle(); |
564 } | 580 } |
565 | 581 |
566 void BlockUntilBrowsingDataRemoved(const base::Time& delete_begin, | 582 void BlockUntilBrowsingDataRemoved( |
567 const base::Time& delete_end, | 583 const base::Time& delete_begin, |
568 int remove_mask, | 584 const base::Time& delete_end, |
569 bool include_protected_origins) { | 585 const std::set<const BrowsingDataType*> remove_mask, |
| 586 bool include_protected_origins) { |
570 TestStoragePartition storage_partition; | 587 TestStoragePartition storage_partition; |
571 remover_->OverrideStoragePartitionForTesting(&storage_partition); | 588 remover_->OverrideStoragePartitionForTesting(&storage_partition); |
572 | 589 |
573 int origin_type_mask = BrowsingDataHelper::UNPROTECTED_WEB; | 590 int origin_type_mask = BrowsingDataHelper::UNPROTECTED_WEB; |
574 if (include_protected_origins) | 591 if (include_protected_origins) |
575 origin_type_mask |= BrowsingDataHelper::PROTECTED_WEB; | 592 origin_type_mask |= BrowsingDataHelper::PROTECTED_WEB; |
576 | 593 |
577 BrowsingDataRemoverCompletionObserver completion_observer(remover_); | 594 BrowsingDataRemoverCompletionObserver completion_observer(remover_); |
578 remover_->RemoveAndReply( | 595 remover_->RemoveAndReply( |
579 delete_begin, delete_end, remove_mask, origin_type_mask, | 596 delete_begin, delete_end, remove_mask, origin_type_mask, |
580 &completion_observer); | 597 &completion_observer); |
581 completion_observer.BlockUntilCompletion(); | 598 completion_observer.BlockUntilCompletion(); |
582 | 599 |
583 // Save so we can verify later. | 600 // Save so we can verify later. |
584 storage_partition_removal_data_ = | 601 storage_partition_removal_data_ = |
585 storage_partition.GetStoragePartitionRemovalData(); | 602 storage_partition.GetStoragePartitionRemovalData(); |
586 } | 603 } |
587 | 604 |
588 void BlockUntilOriginDataRemoved( | 605 void BlockUntilOriginDataRemoved( |
589 const base::Time& delete_begin, | 606 const base::Time& delete_begin, |
590 const base::Time& delete_end, | 607 const base::Time& delete_end, |
591 int remove_mask, | 608 const std::set<const BrowsingDataType*> remove_mask, |
592 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) { | 609 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder) { |
593 TestStoragePartition storage_partition; | 610 TestStoragePartition storage_partition; |
594 remover_->OverrideStoragePartitionForTesting(&storage_partition); | 611 remover_->OverrideStoragePartitionForTesting(&storage_partition); |
595 | 612 |
596 BrowsingDataRemoverCompletionObserver completion_observer(remover_); | 613 BrowsingDataRemoverCompletionObserver completion_observer(remover_); |
597 remover_->RemoveWithFilterAndReply( | 614 remover_->RemoveWithFilterAndReply( |
598 delete_begin, delete_end, remove_mask, | 615 delete_begin, delete_end, remove_mask, |
599 BrowsingDataHelper::UNPROTECTED_WEB, | 616 BrowsingDataHelper::UNPROTECTED_WEB, |
600 std::move(filter_builder), &completion_observer); | 617 std::move(filter_builder), &completion_observer); |
601 completion_observer.BlockUntilCompletion(); | 618 completion_observer.BlockUntilCompletion(); |
602 | 619 |
603 // Save so we can verify later. | 620 // Save so we can verify later. |
604 storage_partition_removal_data_ = | 621 storage_partition_removal_data_ = |
605 storage_partition.GetStoragePartitionRemovalData(); | 622 storage_partition.GetStoragePartitionRemovalData(); |
606 } | 623 } |
607 | 624 |
608 BrowserContext* GetBrowserContext() { | 625 BrowserContext* GetBrowserContext() { |
609 return browser_context_.get(); | 626 return browser_context_.get(); |
610 } | 627 } |
611 | 628 |
612 void DestroyBrowserContext() { browser_context_.reset(); } | 629 void DestroyBrowserContext() { browser_context_.reset(); } |
613 | 630 |
614 const base::Time& GetBeginTime() { | 631 const base::Time& GetBeginTime() { |
615 return remover_->GetLastUsedBeginTime(); | 632 return remover_->GetLastUsedBeginTime(); |
616 } | 633 } |
617 | 634 |
618 int GetRemovalMask() { | 635 const std::set<const content::BrowsingDataType*>& GetRemovalMask() { |
619 return remover_->GetLastUsedRemovalMask(); | 636 return remover_->GetLastUsedRemovalMask(); |
620 } | 637 } |
621 | 638 |
622 int GetOriginTypeMask() { | 639 int GetOriginTypeMask() { |
623 return remover_->GetLastUsedOriginTypeMask(); | 640 return remover_->GetLastUsedOriginTypeMask(); |
624 } | 641 } |
625 | 642 |
626 StoragePartitionRemovalData GetStoragePartitionRemovalData() { | 643 StoragePartitionRemovalData GetStoragePartitionRemovalData() { |
627 return storage_partition_removal_data_; | 644 return storage_partition_removal_data_; |
628 } | 645 } |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
668 scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy_; | 685 scoped_refptr<MockExtensionSpecialStoragePolicy> mock_policy_; |
669 #endif | 686 #endif |
670 | 687 |
671 DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverImplTest); | 688 DISALLOW_COPY_AND_ASSIGN(BrowsingDataRemoverImplTest); |
672 }; | 689 }; |
673 | 690 |
674 // Tests --------------------------------------------------------------------- | 691 // Tests --------------------------------------------------------------------- |
675 | 692 |
676 TEST_F(BrowsingDataRemoverImplTest, RemoveCookieForever) { | 693 TEST_F(BrowsingDataRemoverImplTest, RemoveCookieForever) { |
677 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 694 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
678 BrowsingDataRemover::REMOVE_COOKIES, false); | 695 Mask({&content::kBrowsingDataTypeCookies}), |
| 696 false); |
679 | 697 |
680 EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask()); | 698 EXPECT_EQ(Mask({&content::kBrowsingDataTypeCookies}), GetRemovalMask()); |
681 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 699 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
682 | 700 |
683 // Verify that storage partition was instructed to remove the cookies. | 701 // Verify that storage partition was instructed to remove the cookies. |
684 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 702 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
685 EXPECT_EQ(removal_data.remove_mask, | 703 EXPECT_EQ(removal_data.remove_mask, |
686 StoragePartition::REMOVE_DATA_MASK_COOKIES); | 704 StoragePartition::REMOVE_DATA_MASK_COOKIES); |
687 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 705 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
688 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 706 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
689 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); | 707 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); |
690 } | 708 } |
691 | 709 |
692 TEST_F(BrowsingDataRemoverImplTest, RemoveCookieLastHour) { | 710 TEST_F(BrowsingDataRemoverImplTest, RemoveCookieLastHour) { |
693 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), | 711 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), |
694 BrowsingDataRemover::REMOVE_COOKIES, false); | 712 Mask({&content::kBrowsingDataTypeCookies}), |
| 713 false); |
695 | 714 |
696 EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask()); | 715 EXPECT_EQ(Mask({&content::kBrowsingDataTypeCookies}), GetRemovalMask()); |
697 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 716 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
698 | 717 |
699 // Verify that storage partition was instructed to remove the cookies. | 718 // Verify that storage partition was instructed to remove the cookies. |
700 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 719 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
701 EXPECT_EQ(removal_data.remove_mask, | 720 EXPECT_EQ(removal_data.remove_mask, |
702 StoragePartition::REMOVE_DATA_MASK_COOKIES); | 721 StoragePartition::REMOVE_DATA_MASK_COOKIES); |
703 // Removing with time period other than all time should not clear | 722 // Removing with time period other than all time should not clear |
704 // persistent storage data. | 723 // persistent storage data. |
705 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 724 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
706 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT); | 725 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT); |
707 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); | 726 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); |
708 } | 727 } |
709 | 728 |
710 TEST_F(BrowsingDataRemoverImplTest, RemoveCookiesDomainBlacklist) { | 729 TEST_F(BrowsingDataRemoverImplTest, RemoveCookiesDomainBlacklist) { |
711 std::unique_ptr<BrowsingDataFilterBuilder> filter( | 730 std::unique_ptr<BrowsingDataFilterBuilder> filter( |
712 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); | 731 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); |
713 filter->AddRegisterableDomain(kTestRegisterableDomain1); | 732 filter->AddRegisterableDomain(kTestRegisterableDomain1); |
714 filter->AddRegisterableDomain(kTestRegisterableDomain3); | 733 filter->AddRegisterableDomain(kTestRegisterableDomain3); |
715 BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(), | 734 BlockUntilOriginDataRemoved(AnHourAgo(), base::Time::Max(), |
716 BrowsingDataRemover::REMOVE_COOKIES, | 735 {&content::kBrowsingDataTypeCookies}, |
717 std::move(filter)); | 736 std::move(filter)); |
718 | 737 |
719 EXPECT_EQ(BrowsingDataRemover::REMOVE_COOKIES, GetRemovalMask()); | 738 EXPECT_EQ(Mask({&content::kBrowsingDataTypeCookies}), GetRemovalMask()); |
720 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 739 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
721 | 740 |
722 // Verify that storage partition was instructed to remove the cookies. | 741 // Verify that storage partition was instructed to remove the cookies. |
723 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 742 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
724 EXPECT_EQ(removal_data.remove_mask, | 743 EXPECT_EQ(removal_data.remove_mask, |
725 StoragePartition::REMOVE_DATA_MASK_COOKIES); | 744 StoragePartition::REMOVE_DATA_MASK_COOKIES); |
726 // Removing with time period other than all time should not clear | 745 // Removing with time period other than all time should not clear |
727 // persistent storage data. | 746 // persistent storage data. |
728 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 747 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
729 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT); | 748 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT); |
(...skipping 25 matching lines...) Expand all Loading... |
755 net::HttpAuthCache* http_auth_cache = http_session->http_auth_cache(); | 774 net::HttpAuthCache* http_auth_cache = http_session->http_auth_cache(); |
756 http_auth_cache->Add(kOrigin1, kTestRealm, net::HttpAuth::AUTH_SCHEME_BASIC, | 775 http_auth_cache->Add(kOrigin1, kTestRealm, net::HttpAuth::AUTH_SCHEME_BASIC, |
757 "test challenge", | 776 "test challenge", |
758 net::AuthCredentials(base::ASCIIToUTF16("foo"), | 777 net::AuthCredentials(base::ASCIIToUTF16("foo"), |
759 base::ASCIIToUTF16("bar")), | 778 base::ASCIIToUTF16("bar")), |
760 "/"); | 779 "/"); |
761 CHECK(http_auth_cache->Lookup(kOrigin1, kTestRealm, | 780 CHECK(http_auth_cache->Lookup(kOrigin1, kTestRealm, |
762 net::HttpAuth::AUTH_SCHEME_BASIC)); | 781 net::HttpAuth::AUTH_SCHEME_BASIC)); |
763 | 782 |
764 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 783 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
765 BrowsingDataRemover::REMOVE_COOKIES, false); | 784 {&content::kBrowsingDataTypeCookies}, false); |
766 | 785 |
767 EXPECT_EQ(nullptr, http_auth_cache->Lookup(kOrigin1, kTestRealm, | 786 EXPECT_EQ(nullptr, http_auth_cache->Lookup(kOrigin1, kTestRealm, |
768 net::HttpAuth::AUTH_SCHEME_BASIC)); | 787 net::HttpAuth::AUTH_SCHEME_BASIC)); |
769 } | 788 } |
770 | 789 |
771 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDForever) { | 790 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDForever) { |
772 RemoveChannelIDTester tester(GetBrowserContext()); | 791 RemoveChannelIDTester tester(GetBrowserContext()); |
773 | 792 |
774 tester.AddChannelID(kTestOrigin1); | 793 tester.AddChannelID(kTestOrigin1); |
775 EXPECT_EQ(0, tester.ssl_config_changed_count()); | 794 EXPECT_EQ(0, tester.ssl_config_changed_count()); |
776 EXPECT_EQ(1, tester.ChannelIDCount()); | 795 EXPECT_EQ(1, tester.ChannelIDCount()); |
777 | 796 |
778 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 797 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
779 BrowsingDataRemover::REMOVE_CHANNEL_IDS, false); | 798 {&content::kBrowsingDataTypeChannelIDs}, false); |
780 | 799 |
781 EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask()); | 800 EXPECT_EQ(Mask({&content::kBrowsingDataTypeChannelIDs}), GetRemovalMask()); |
782 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 801 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
783 EXPECT_EQ(1, tester.ssl_config_changed_count()); | 802 EXPECT_EQ(1, tester.ssl_config_changed_count()); |
784 EXPECT_EQ(0, tester.ChannelIDCount()); | 803 EXPECT_EQ(0, tester.ChannelIDCount()); |
785 } | 804 } |
786 | 805 |
787 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDLastHour) { | 806 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDLastHour) { |
788 RemoveChannelIDTester tester(GetBrowserContext()); | 807 RemoveChannelIDTester tester(GetBrowserContext()); |
789 | 808 |
790 base::Time now = base::Time::Now(); | 809 base::Time now = base::Time::Now(); |
791 tester.AddChannelID(kTestOrigin1); | 810 tester.AddChannelID(kTestOrigin1); |
792 tester.AddChannelIDWithTimes(kTestOrigin2, | 811 tester.AddChannelIDWithTimes(kTestOrigin2, |
793 now - base::TimeDelta::FromHours(2)); | 812 now - base::TimeDelta::FromHours(2)); |
794 EXPECT_EQ(0, tester.ssl_config_changed_count()); | 813 EXPECT_EQ(0, tester.ssl_config_changed_count()); |
795 EXPECT_EQ(2, tester.ChannelIDCount()); | 814 EXPECT_EQ(2, tester.ChannelIDCount()); |
796 | 815 |
797 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), | 816 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), |
798 BrowsingDataRemover::REMOVE_CHANNEL_IDS, false); | 817 {&content::kBrowsingDataTypeChannelIDs}, false); |
799 | 818 |
800 EXPECT_EQ(BrowsingDataRemover::REMOVE_CHANNEL_IDS, GetRemovalMask()); | 819 EXPECT_EQ(Mask({&content::kBrowsingDataTypeChannelIDs}), GetRemovalMask()); |
801 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 820 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
802 EXPECT_EQ(1, tester.ssl_config_changed_count()); | 821 EXPECT_EQ(1, tester.ssl_config_changed_count()); |
803 ASSERT_EQ(1, tester.ChannelIDCount()); | 822 ASSERT_EQ(1, tester.ChannelIDCount()); |
804 net::ChannelIDStore::ChannelIDList channel_ids; | 823 net::ChannelIDStore::ChannelIDList channel_ids; |
805 tester.GetChannelIDList(&channel_ids); | 824 tester.GetChannelIDList(&channel_ids); |
806 ASSERT_EQ(1U, channel_ids.size()); | 825 ASSERT_EQ(1U, channel_ids.size()); |
807 EXPECT_EQ(kTestOrigin2, channel_ids.front().server_identifier()); | 826 EXPECT_EQ(kTestOrigin2, channel_ids.front().server_identifier()); |
808 } | 827 } |
809 | 828 |
810 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDsForServerIdentifiers) { | 829 TEST_F(BrowsingDataRemoverImplTest, RemoveChannelIDsForServerIdentifiers) { |
811 RemoveChannelIDTester tester(GetBrowserContext()); | 830 RemoveChannelIDTester tester(GetBrowserContext()); |
812 | 831 |
813 tester.AddChannelID(kTestRegisterableDomain1); | 832 tester.AddChannelID(kTestRegisterableDomain1); |
814 tester.AddChannelID(kTestRegisterableDomain3); | 833 tester.AddChannelID(kTestRegisterableDomain3); |
815 EXPECT_EQ(2, tester.ChannelIDCount()); | 834 EXPECT_EQ(2, tester.ChannelIDCount()); |
816 | 835 |
817 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder( | 836 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder( |
818 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); | 837 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); |
819 filter_builder->AddRegisterableDomain(kTestRegisterableDomain1); | 838 filter_builder->AddRegisterableDomain(kTestRegisterableDomain1); |
820 | 839 |
821 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), | 840 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), |
822 BrowsingDataRemover::REMOVE_CHANNEL_IDS, | 841 {&content::kBrowsingDataTypeChannelIDs}, |
823 std::move(filter_builder)); | 842 std::move(filter_builder)); |
824 | 843 |
825 EXPECT_EQ(1, tester.ChannelIDCount()); | 844 EXPECT_EQ(1, tester.ChannelIDCount()); |
826 net::ChannelIDStore::ChannelIDList channel_ids; | 845 net::ChannelIDStore::ChannelIDList channel_ids; |
827 tester.GetChannelIDList(&channel_ids); | 846 tester.GetChannelIDList(&channel_ids); |
828 EXPECT_EQ(kTestRegisterableDomain3, channel_ids.front().server_identifier()); | 847 EXPECT_EQ(kTestRegisterableDomain3, channel_ids.front().server_identifier()); |
829 } | 848 } |
830 | 849 |
831 TEST_F(BrowsingDataRemoverImplTest, RemoveUnprotectedLocalStorageForever) { | 850 TEST_F(BrowsingDataRemoverImplTest, RemoveUnprotectedLocalStorageForever) { |
832 #if BUILDFLAG(ENABLE_EXTENSIONS) | 851 #if BUILDFLAG(ENABLE_EXTENSIONS) |
833 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); | 852 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); |
834 // Protect kOrigin1. | 853 // Protect kOrigin1. |
835 policy->AddProtected(kOrigin1.GetOrigin()); | 854 policy->AddProtected(kOrigin1.GetOrigin()); |
836 #endif | 855 #endif |
837 | 856 |
838 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 857 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
839 BrowsingDataRemover::REMOVE_LOCAL_STORAGE, | 858 {&content::kBrowsingDataTypeLocalStorage}, |
840 false); | 859 false); |
841 | 860 |
842 EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask()); | 861 EXPECT_EQ(Mask({&content::kBrowsingDataTypeLocalStorage}), GetRemovalMask()); |
843 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 862 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
844 | 863 |
845 // Verify that storage partition was instructed to remove the data correctly. | 864 // Verify that storage partition was instructed to remove the data correctly. |
846 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 865 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
847 EXPECT_EQ(removal_data.remove_mask, | 866 EXPECT_EQ(removal_data.remove_mask, |
848 StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE); | 867 StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE); |
849 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 868 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
850 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 869 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
851 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); | 870 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); |
852 | 871 |
853 // Check origin matcher. | 872 // Check origin matcher. |
854 EXPECT_EQ(ShouldRemoveForProtectedOriginOne(), | 873 EXPECT_EQ(ShouldRemoveForProtectedOriginOne(), |
855 removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 874 removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
856 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 875 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
857 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 876 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
858 EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy())); | 877 EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy())); |
859 } | 878 } |
860 | 879 |
861 TEST_F(BrowsingDataRemoverImplTest, RemoveProtectedLocalStorageForever) { | 880 TEST_F(BrowsingDataRemoverImplTest, RemoveProtectedLocalStorageForever) { |
862 #if BUILDFLAG(ENABLE_EXTENSIONS) | 881 #if BUILDFLAG(ENABLE_EXTENSIONS) |
863 // Protect kOrigin1. | 882 // Protect kOrigin1. |
864 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); | 883 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); |
865 policy->AddProtected(kOrigin1.GetOrigin()); | 884 policy->AddProtected(kOrigin1.GetOrigin()); |
866 #endif | 885 #endif |
867 | 886 |
868 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 887 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
869 BrowsingDataRemover::REMOVE_LOCAL_STORAGE, | 888 {&content::kBrowsingDataTypeLocalStorage}, |
870 true); | 889 true); |
871 | 890 |
872 EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask()); | 891 EXPECT_EQ(Mask({&content::kBrowsingDataTypeLocalStorage}), GetRemovalMask()); |
873 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB | | 892 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB | |
874 BrowsingDataHelper::PROTECTED_WEB, GetOriginTypeMask()); | 893 BrowsingDataHelper::PROTECTED_WEB, GetOriginTypeMask()); |
875 | 894 |
876 // Verify that storage partition was instructed to remove the data correctly. | 895 // Verify that storage partition was instructed to remove the data correctly. |
877 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 896 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
878 EXPECT_EQ(removal_data.remove_mask, | 897 EXPECT_EQ(removal_data.remove_mask, |
879 StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE); | 898 StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE); |
880 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 899 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
881 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 900 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
882 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); | 901 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); |
883 | 902 |
884 // Check origin matcher all http origin will match since we specified | 903 // Check origin matcher all http origin will match since we specified |
885 // both protected and unprotected. | 904 // both protected and unprotected. |
886 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 905 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
887 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 906 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
888 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 907 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
889 EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy())); | 908 EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy())); |
890 } | 909 } |
891 | 910 |
892 TEST_F(BrowsingDataRemoverImplTest, RemoveLocalStorageForLastWeek) { | 911 TEST_F(BrowsingDataRemoverImplTest, RemoveLocalStorageForLastWeek) { |
893 #if BUILDFLAG(ENABLE_EXTENSIONS) | 912 #if BUILDFLAG(ENABLE_EXTENSIONS) |
894 CreateMockPolicy(); | 913 CreateMockPolicy(); |
895 #endif | 914 #endif |
896 | 915 |
897 BlockUntilBrowsingDataRemoved( | 916 BlockUntilBrowsingDataRemoved( |
898 base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(), | 917 base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(), |
899 BrowsingDataRemover::REMOVE_LOCAL_STORAGE, false); | 918 {&content::kBrowsingDataTypeLocalStorage}, false); |
900 | 919 |
901 EXPECT_EQ(BrowsingDataRemover::REMOVE_LOCAL_STORAGE, GetRemovalMask()); | 920 EXPECT_EQ(Mask({&content::kBrowsingDataTypeLocalStorage}), GetRemovalMask()); |
902 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 921 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
903 | 922 |
904 // Verify that storage partition was instructed to remove the data correctly. | 923 // Verify that storage partition was instructed to remove the data correctly. |
905 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 924 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
906 EXPECT_EQ(removal_data.remove_mask, | 925 EXPECT_EQ(removal_data.remove_mask, |
907 StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE); | 926 StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE); |
908 // Persistent storage won't be deleted. | 927 // Persistent storage won't be deleted. |
909 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 928 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
910 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT); | 929 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT); |
911 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); | 930 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); |
912 | 931 |
913 // Check origin matcher. | 932 // Check origin matcher. |
914 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 933 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
915 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 934 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
916 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 935 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
917 EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy())); | 936 EXPECT_FALSE(removal_data.origin_matcher.Run(kOriginExt, mock_policy())); |
918 } | 937 } |
919 | 938 |
920 TEST_F(BrowsingDataRemoverImplTest, RemoveMultipleTypes) { | 939 TEST_F(BrowsingDataRemoverImplTest, RemoveMultipleTypes) { |
921 // Downloads should be deleted through the DownloadManager, assure it would | 940 // Downloads should be deleted through the DownloadManager, assure it would |
922 // be called. | 941 // be called. |
923 RemoveDownloadsTester downloads_tester(GetBrowserContext()); | 942 RemoveDownloadsTester downloads_tester(GetBrowserContext()); |
924 EXPECT_CALL(*downloads_tester.download_manager(), | 943 EXPECT_CALL(*downloads_tester.download_manager(), |
925 RemoveDownloadsByURLAndTime(_, _, _)); | 944 RemoveDownloadsByURLAndTime(_, _, _)); |
926 | 945 |
927 int removal_mask = BrowsingDataRemover::REMOVE_DOWNLOADS | | 946 std::set<const BrowsingDataType*> removal_mask = { |
928 BrowsingDataRemover::REMOVE_COOKIES; | 947 &content::kBrowsingDataTypeDownloads, &content::kBrowsingDataTypeCookies}; |
929 | 948 |
930 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 949 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
931 removal_mask, false); | 950 removal_mask, false); |
932 | 951 |
933 EXPECT_EQ(removal_mask, GetRemovalMask()); | 952 EXPECT_EQ(removal_mask, GetRemovalMask()); |
934 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 953 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
935 | 954 |
936 // The cookie would be deleted throught the StorageParition, check if the | 955 // The cookie would be deleted throught the StorageParition, check if the |
937 // partition was requested to remove cookie. | 956 // partition was requested to remove cookie. |
938 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 957 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
939 EXPECT_EQ(removal_data.remove_mask, | 958 EXPECT_EQ(removal_data.remove_mask, |
940 StoragePartition::REMOVE_DATA_MASK_COOKIES); | 959 StoragePartition::REMOVE_DATA_MASK_COOKIES); |
941 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 960 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
942 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 961 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
943 } | 962 } |
944 | 963 |
945 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForeverBoth) { | 964 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForeverBoth) { |
946 BlockUntilBrowsingDataRemoved( | 965 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
947 base::Time(), base::Time::Max(), | 966 false); |
948 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
949 BrowsingDataRemover::REMOVE_WEBSQL | | |
950 BrowsingDataRemover::REMOVE_APPCACHE | | |
951 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
952 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
953 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
954 false); | |
955 | 967 |
956 EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 968 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
957 BrowsingDataRemover::REMOVE_WEBSQL | | |
958 BrowsingDataRemover::REMOVE_APPCACHE | | |
959 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
960 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
961 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
962 GetRemovalMask()); | |
963 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 969 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
964 | 970 |
965 // Verify storage partition related stuffs. | 971 // Verify storage partition related stuffs. |
966 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 972 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
967 EXPECT_EQ(removal_data.remove_mask, | 973 EXPECT_EQ(removal_data.remove_mask, |
968 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 974 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
969 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 975 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
970 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 976 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
971 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 977 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
972 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 978 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
973 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 979 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
974 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 980 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
975 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 981 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
976 } | 982 } |
977 | 983 |
978 TEST_F(BrowsingDataRemoverImplTest, | 984 TEST_F(BrowsingDataRemoverImplTest, |
979 RemoveQuotaManagedDataForeverOnlyTemporary) { | 985 RemoveQuotaManagedDataForeverOnlyTemporary) { |
980 #if BUILDFLAG(ENABLE_EXTENSIONS) | 986 #if BUILDFLAG(ENABLE_EXTENSIONS) |
981 CreateMockPolicy(); | 987 CreateMockPolicy(); |
982 #endif | 988 #endif |
983 | 989 |
984 BlockUntilBrowsingDataRemoved( | 990 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
985 base::Time(), base::Time::Max(), | 991 false); |
986 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
987 BrowsingDataRemover::REMOVE_WEBSQL | | |
988 BrowsingDataRemover::REMOVE_APPCACHE | | |
989 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
990 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
991 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
992 false); | |
993 | 992 |
994 EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 993 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
995 BrowsingDataRemover::REMOVE_WEBSQL | | |
996 BrowsingDataRemover::REMOVE_APPCACHE | | |
997 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
998 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
999 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1000 GetRemovalMask()); | |
1001 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 994 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1002 | 995 |
1003 // Verify storage partition related stuffs. | 996 // Verify storage partition related stuffs. |
1004 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 997 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1005 | 998 |
1006 EXPECT_EQ(removal_data.remove_mask, | 999 EXPECT_EQ(removal_data.remove_mask, |
1007 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1000 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1008 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1001 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1009 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1002 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1010 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1003 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
1011 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 1004 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
1012 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 1005 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
1013 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 1006 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
1014 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 1007 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
1015 | 1008 |
1016 // Check that all related origin data would be removed, that is, origin | 1009 // Check that all related origin data would be removed, that is, origin |
1017 // matcher would match these origin. | 1010 // matcher would match these origin. |
1018 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 1011 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
1019 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 1012 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
1020 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 1013 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
1021 } | 1014 } |
1022 | 1015 |
1023 TEST_F(BrowsingDataRemoverImplTest, | 1016 TEST_F(BrowsingDataRemoverImplTest, |
1024 RemoveQuotaManagedDataForeverOnlyPersistent) { | 1017 RemoveQuotaManagedDataForeverOnlyPersistent) { |
1025 #if BUILDFLAG(ENABLE_EXTENSIONS) | 1018 #if BUILDFLAG(ENABLE_EXTENSIONS) |
1026 CreateMockPolicy(); | 1019 CreateMockPolicy(); |
1027 #endif | 1020 #endif |
1028 | 1021 |
1029 BlockUntilBrowsingDataRemoved( | 1022 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
1030 base::Time(), base::Time::Max(), | 1023 false); |
1031 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1032 BrowsingDataRemover::REMOVE_WEBSQL | | |
1033 BrowsingDataRemover::REMOVE_APPCACHE | | |
1034 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1035 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1036 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1037 false); | |
1038 | 1024 |
1039 EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 1025 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1040 BrowsingDataRemover::REMOVE_WEBSQL | | |
1041 BrowsingDataRemover::REMOVE_APPCACHE | | |
1042 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1043 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1044 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1045 GetRemovalMask()); | |
1046 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1026 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1047 | 1027 |
1048 // Verify storage partition related stuffs. | 1028 // Verify storage partition related stuffs. |
1049 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1029 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1050 | 1030 |
1051 EXPECT_EQ(removal_data.remove_mask, | 1031 EXPECT_EQ(removal_data.remove_mask, |
1052 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1032 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1053 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1033 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1054 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1034 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1055 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1035 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
1056 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 1036 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
1057 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 1037 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
1058 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 1038 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
1059 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 1039 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
1060 | 1040 |
1061 // Check that all related origin data would be removed, that is, origin | 1041 // Check that all related origin data would be removed, that is, origin |
1062 // matcher would match these origin. | 1042 // matcher would match these origin. |
1063 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 1043 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
1064 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 1044 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
1065 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 1045 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
1066 } | 1046 } |
1067 | 1047 |
1068 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForeverNeither) { | 1048 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForeverNeither) { |
1069 #if BUILDFLAG(ENABLE_EXTENSIONS) | 1049 #if BUILDFLAG(ENABLE_EXTENSIONS) |
1070 CreateMockPolicy(); | 1050 CreateMockPolicy(); |
1071 #endif | 1051 #endif |
1072 | 1052 |
1073 BlockUntilBrowsingDataRemoved( | 1053 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
1074 base::Time(), base::Time::Max(), | 1054 false); |
1075 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1076 BrowsingDataRemover::REMOVE_WEBSQL | | |
1077 BrowsingDataRemover::REMOVE_APPCACHE | | |
1078 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1079 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1080 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1081 false); | |
1082 | 1055 |
1083 EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 1056 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1084 BrowsingDataRemover::REMOVE_WEBSQL | | |
1085 BrowsingDataRemover::REMOVE_APPCACHE | | |
1086 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1087 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1088 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1089 GetRemovalMask()); | |
1090 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1057 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1091 | 1058 |
1092 // Verify storage partition related stuffs. | 1059 // Verify storage partition related stuffs. |
1093 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1060 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1094 | 1061 |
1095 EXPECT_EQ(removal_data.remove_mask, | 1062 EXPECT_EQ(removal_data.remove_mask, |
1096 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1063 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1097 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1064 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1098 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1065 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1099 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1066 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
1100 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 1067 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
1101 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 1068 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
1102 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 1069 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
1103 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 1070 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
1104 | 1071 |
1105 // Check that all related origin data would be removed, that is, origin | 1072 // Check that all related origin data would be removed, that is, origin |
1106 // matcher would match these origin. | 1073 // matcher would match these origin. |
1107 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 1074 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
1108 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 1075 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
1109 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 1076 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
1110 } | 1077 } |
1111 | 1078 |
1112 TEST_F(BrowsingDataRemoverImplTest, | 1079 TEST_F(BrowsingDataRemoverImplTest, |
1113 RemoveQuotaManagedDataForeverSpecificOrigin) { | 1080 RemoveQuotaManagedDataForeverSpecificOrigin) { |
1114 std::unique_ptr<BrowsingDataFilterBuilder> builder( | 1081 std::unique_ptr<BrowsingDataFilterBuilder> builder( |
1115 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); | 1082 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); |
1116 builder->AddRegisterableDomain(kTestRegisterableDomain1); | 1083 builder->AddRegisterableDomain(kTestRegisterableDomain1); |
1117 // Remove Origin 1. | 1084 // Remove Origin 1. |
1118 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), | 1085 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
1119 BrowsingDataRemover::REMOVE_APPCACHE | | |
1120 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1121 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1122 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1123 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1124 BrowsingDataRemover::REMOVE_WEBSQL, | |
1125 std::move(builder)); | 1086 std::move(builder)); |
1126 | 1087 |
1127 EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE | | 1088 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1128 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1129 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1130 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1131 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1132 BrowsingDataRemover::REMOVE_WEBSQL, | |
1133 GetRemovalMask()); | |
1134 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1089 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1135 | 1090 |
1136 // Verify storage partition related stuffs. | 1091 // Verify storage partition related stuffs. |
1137 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1092 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1138 | 1093 |
1139 EXPECT_EQ(removal_data.remove_mask, | 1094 EXPECT_EQ(removal_data.remove_mask, |
1140 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1095 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1141 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1096 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1142 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1097 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1143 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1098 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
1144 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 1099 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
1145 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 1100 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
1146 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 1101 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
1147 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 1102 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
1148 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 1103 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
1149 EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 1104 EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
1150 EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 1105 EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
1151 EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin4, mock_policy())); | 1106 EXPECT_FALSE(removal_data.origin_matcher.Run(kOrigin4, mock_policy())); |
1152 } | 1107 } |
1153 | 1108 |
1154 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForLastHour) { | 1109 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForLastHour) { |
1155 BlockUntilBrowsingDataRemoved( | 1110 BlockUntilBrowsingDataRemoved(AnHourAgo(), base::Time::Max(), kQuotaMask, |
1156 AnHourAgo(), base::Time::Max(), | 1111 false); |
1157 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1158 BrowsingDataRemover::REMOVE_WEBSQL | | |
1159 BrowsingDataRemover::REMOVE_APPCACHE | | |
1160 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1161 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1162 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1163 false); | |
1164 | 1112 |
1165 EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 1113 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1166 BrowsingDataRemover::REMOVE_WEBSQL | | |
1167 BrowsingDataRemover::REMOVE_APPCACHE | | |
1168 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1169 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1170 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1171 GetRemovalMask()); | |
1172 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1114 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1173 | 1115 |
1174 // Verify storage partition related stuffs. | 1116 // Verify storage partition related stuffs. |
1175 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1117 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1176 | 1118 |
1177 EXPECT_EQ(removal_data.remove_mask, | 1119 EXPECT_EQ(removal_data.remove_mask, |
1178 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1120 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1179 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1121 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1180 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1122 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1181 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1123 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
1182 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 1124 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
1183 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 1125 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
1184 | 1126 |
1185 // Persistent data would be left out since we are not removing from | 1127 // Persistent data would be left out since we are not removing from |
1186 // beginning of time. | 1128 // beginning of time. |
1187 uint32_t expected_quota_mask = | 1129 uint32_t expected_quota_mask = |
1188 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT; | 1130 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT; |
1189 EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask); | 1131 EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask); |
1190 // Check removal begin time. | 1132 // Check removal begin time. |
1191 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); | 1133 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); |
1192 } | 1134 } |
1193 | 1135 |
1194 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForLastWeek) { | 1136 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedDataForLastWeek) { |
1195 BlockUntilBrowsingDataRemoved( | 1137 BlockUntilBrowsingDataRemoved( |
1196 base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(), | 1138 base::Time::Now() - base::TimeDelta::FromDays(7), base::Time::Max(), |
1197 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 1139 kQuotaMask, false); |
1198 BrowsingDataRemover::REMOVE_WEBSQL | | |
1199 BrowsingDataRemover::REMOVE_APPCACHE | | |
1200 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1201 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1202 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1203 false); | |
1204 | 1140 |
1205 EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 1141 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1206 BrowsingDataRemover::REMOVE_WEBSQL | | |
1207 BrowsingDataRemover::REMOVE_APPCACHE | | |
1208 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1209 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1210 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1211 GetRemovalMask()); | |
1212 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1142 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1213 | 1143 |
1214 // Verify storage partition related stuffs. | 1144 // Verify storage partition related stuffs. |
1215 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1145 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1216 | 1146 |
1217 EXPECT_EQ(removal_data.remove_mask, | 1147 EXPECT_EQ(removal_data.remove_mask, |
1218 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1148 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1219 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1149 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1220 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1150 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1221 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1151 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
1222 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 1152 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
1223 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 1153 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
1224 | 1154 |
1225 // Persistent data would be left out since we are not removing from | 1155 // Persistent data would be left out since we are not removing from |
1226 // beginning of time. | 1156 // beginning of time. |
1227 uint32_t expected_quota_mask = | 1157 uint32_t expected_quota_mask = |
1228 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT; | 1158 ~StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT; |
1229 EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask); | 1159 EXPECT_EQ(removal_data.quota_storage_remove_mask, expected_quota_mask); |
1230 // Check removal begin time. | 1160 // Check removal begin time. |
1231 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); | 1161 EXPECT_EQ(removal_data.remove_begin, GetBeginTime()); |
1232 } | 1162 } |
1233 | 1163 |
1234 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedUnprotectedOrigins) { | 1164 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedUnprotectedOrigins) { |
1235 #if BUILDFLAG(ENABLE_EXTENSIONS) | 1165 #if BUILDFLAG(ENABLE_EXTENSIONS) |
1236 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); | 1166 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); |
1237 // Protect kOrigin1. | 1167 // Protect kOrigin1. |
1238 policy->AddProtected(kOrigin1.GetOrigin()); | 1168 policy->AddProtected(kOrigin1.GetOrigin()); |
1239 #endif | 1169 #endif |
1240 | 1170 |
1241 BlockUntilBrowsingDataRemoved( | 1171 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
1242 base::Time(), base::Time::Max(), | 1172 false); |
1243 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1244 BrowsingDataRemover::REMOVE_WEBSQL | | |
1245 BrowsingDataRemover::REMOVE_APPCACHE | | |
1246 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1247 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1248 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1249 false); | |
1250 | 1173 |
1251 EXPECT_EQ(BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | 1174 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1252 BrowsingDataRemover::REMOVE_WEBSQL | | |
1253 BrowsingDataRemover::REMOVE_APPCACHE | | |
1254 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1255 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1256 BrowsingDataRemover::REMOVE_INDEXEDDB, | |
1257 GetRemovalMask()); | |
1258 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1175 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1259 | 1176 |
1260 // Verify storage partition related stuffs. | 1177 // Verify storage partition related stuffs. |
1261 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1178 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1262 | 1179 |
1263 EXPECT_EQ(removal_data.remove_mask, | 1180 EXPECT_EQ(removal_data.remove_mask, |
1264 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1181 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1265 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1182 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1266 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1183 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1267 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1184 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
(...skipping 14 matching lines...) Expand all Loading... |
1282 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); | 1199 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); |
1283 // Protect kOrigin1. | 1200 // Protect kOrigin1. |
1284 policy->AddProtected(kOrigin1.GetOrigin()); | 1201 policy->AddProtected(kOrigin1.GetOrigin()); |
1285 #endif | 1202 #endif |
1286 | 1203 |
1287 std::unique_ptr<BrowsingDataFilterBuilder> builder( | 1204 std::unique_ptr<BrowsingDataFilterBuilder> builder( |
1288 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); | 1205 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); |
1289 builder->AddRegisterableDomain(kTestRegisterableDomain1); | 1206 builder->AddRegisterableDomain(kTestRegisterableDomain1); |
1290 | 1207 |
1291 // Try to remove kOrigin1. Expect failure. | 1208 // Try to remove kOrigin1. Expect failure. |
1292 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), | 1209 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
1293 BrowsingDataRemover::REMOVE_APPCACHE | | |
1294 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1295 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1296 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1297 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1298 BrowsingDataRemover::REMOVE_WEBSQL, | |
1299 std::move(builder)); | 1210 std::move(builder)); |
1300 | 1211 |
1301 EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE | | 1212 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1302 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1303 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1304 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1305 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1306 BrowsingDataRemover::REMOVE_WEBSQL, | |
1307 GetRemovalMask()); | |
1308 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1213 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1309 | 1214 |
1310 // Verify storage partition related stuffs. | 1215 // Verify storage partition related stuffs. |
1311 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1216 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1312 | 1217 |
1313 EXPECT_EQ(removal_data.remove_mask, | 1218 EXPECT_EQ(removal_data.remove_mask, |
1314 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1219 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1315 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1220 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1316 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1221 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1317 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1222 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
(...skipping 12 matching lines...) Expand all Loading... |
1330 } | 1235 } |
1331 | 1236 |
1332 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedProtectedOrigins) { | 1237 TEST_F(BrowsingDataRemoverImplTest, RemoveQuotaManagedProtectedOrigins) { |
1333 #if BUILDFLAG(ENABLE_EXTENSIONS) | 1238 #if BUILDFLAG(ENABLE_EXTENSIONS) |
1334 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); | 1239 MockExtensionSpecialStoragePolicy* policy = CreateMockPolicy(); |
1335 // Protect kOrigin1. | 1240 // Protect kOrigin1. |
1336 policy->AddProtected(kOrigin1.GetOrigin()); | 1241 policy->AddProtected(kOrigin1.GetOrigin()); |
1337 #endif | 1242 #endif |
1338 | 1243 |
1339 // Try to remove kOrigin1. Expect success. | 1244 // Try to remove kOrigin1. Expect success. |
1340 BlockUntilBrowsingDataRemoved( | 1245 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
1341 base::Time(), base::Time::Max(), | 1246 true); |
1342 BrowsingDataRemover::REMOVE_APPCACHE | | |
1343 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1344 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1345 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1346 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1347 BrowsingDataRemover::REMOVE_WEBSQL, | |
1348 true); | |
1349 | 1247 |
1350 EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE | | 1248 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1351 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1352 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1353 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1354 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1355 BrowsingDataRemover::REMOVE_WEBSQL, | |
1356 GetRemovalMask()); | |
1357 EXPECT_EQ(BrowsingDataHelper::PROTECTED_WEB | | 1249 EXPECT_EQ(BrowsingDataHelper::PROTECTED_WEB | |
1358 BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1250 BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1359 | 1251 |
1360 // Verify storage partition related stuffs. | 1252 // Verify storage partition related stuffs. |
1361 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1253 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1362 | 1254 |
1363 EXPECT_EQ(removal_data.remove_mask, | 1255 EXPECT_EQ(removal_data.remove_mask, |
1364 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1256 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1365 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1257 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1366 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1258 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1367 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1259 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
1368 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | | 1260 StoragePartition::REMOVE_DATA_MASK_CACHE_STORAGE | |
1369 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); | 1261 StoragePartition::REMOVE_DATA_MASK_INDEXEDDB); |
1370 EXPECT_EQ(removal_data.quota_storage_remove_mask, | 1262 EXPECT_EQ(removal_data.quota_storage_remove_mask, |
1371 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); | 1263 StoragePartition::QUOTA_MANAGED_STORAGE_MASK_ALL); |
1372 | 1264 |
1373 // Check OriginMatcherFunction, |kOrigin1| would match mask since we | 1265 // Check OriginMatcherFunction, |kOrigin1| would match mask since we |
1374 // would have 'protected' specified in origin_type_mask. | 1266 // would have 'protected' specified in origin_type_mask. |
1375 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); | 1267 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin1, mock_policy())); |
1376 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); | 1268 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin2, mock_policy())); |
1377 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); | 1269 EXPECT_TRUE(removal_data.origin_matcher.Run(kOrigin3, mock_policy())); |
1378 } | 1270 } |
1379 | 1271 |
1380 TEST_F(BrowsingDataRemoverImplTest, | 1272 TEST_F(BrowsingDataRemoverImplTest, |
1381 RemoveQuotaManagedIgnoreExtensionsAndDevTools) { | 1273 RemoveQuotaManagedIgnoreExtensionsAndDevTools) { |
1382 #if BUILDFLAG(ENABLE_EXTENSIONS) | 1274 #if BUILDFLAG(ENABLE_EXTENSIONS) |
1383 CreateMockPolicy(); | 1275 CreateMockPolicy(); |
1384 #endif | 1276 #endif |
1385 | 1277 |
1386 BlockUntilBrowsingDataRemoved( | 1278 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), kQuotaMask, |
1387 base::Time(), base::Time::Max(), | 1279 false); |
1388 BrowsingDataRemover::REMOVE_APPCACHE | | |
1389 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1390 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1391 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1392 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1393 BrowsingDataRemover::REMOVE_WEBSQL, | |
1394 false); | |
1395 | 1280 |
1396 EXPECT_EQ(BrowsingDataRemover::REMOVE_APPCACHE | | 1281 EXPECT_EQ(kQuotaMask, GetRemovalMask()); |
1397 BrowsingDataRemover::REMOVE_SERVICE_WORKERS | | |
1398 BrowsingDataRemover::REMOVE_CACHE_STORAGE | | |
1399 BrowsingDataRemover::REMOVE_FILE_SYSTEMS | | |
1400 BrowsingDataRemover::REMOVE_INDEXEDDB | | |
1401 BrowsingDataRemover::REMOVE_WEBSQL, | |
1402 GetRemovalMask()); | |
1403 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); | 1282 EXPECT_EQ(BrowsingDataHelper::UNPROTECTED_WEB, GetOriginTypeMask()); |
1404 | 1283 |
1405 // Verify storage partition related stuffs. | 1284 // Verify storage partition related stuffs. |
1406 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); | 1285 StoragePartitionRemovalData removal_data = GetStoragePartitionRemovalData(); |
1407 | 1286 |
1408 EXPECT_EQ(removal_data.remove_mask, | 1287 EXPECT_EQ(removal_data.remove_mask, |
1409 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | | 1288 StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS | |
1410 StoragePartition::REMOVE_DATA_MASK_WEBSQL | | 1289 StoragePartition::REMOVE_DATA_MASK_WEBSQL | |
1411 StoragePartition::REMOVE_DATA_MASK_APPCACHE | | 1290 StoragePartition::REMOVE_DATA_MASK_APPCACHE | |
1412 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | | 1291 StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS | |
(...skipping 28 matching lines...) Expand all Loading... |
1441 }; | 1320 }; |
1442 | 1321 |
1443 TEST_F(BrowsingDataRemoverImplTest, CompletionInhibition) { | 1322 TEST_F(BrowsingDataRemoverImplTest, CompletionInhibition) { |
1444 // The |completion_inhibitor| on the stack should prevent removal sessions | 1323 // The |completion_inhibitor| on the stack should prevent removal sessions |
1445 // from completing until after ContinueToCompletion() is called. | 1324 // from completing until after ContinueToCompletion() is called. |
1446 BrowsingDataRemoverCompletionInhibitor completion_inhibitor; | 1325 BrowsingDataRemoverCompletionInhibitor completion_inhibitor; |
1447 | 1326 |
1448 BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>( | 1327 BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>( |
1449 BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext())); | 1328 BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext())); |
1450 InspectableCompletionObserver completion_observer(remover); | 1329 InspectableCompletionObserver completion_observer(remover); |
1451 remover->RemoveAndReply(base::Time(), base::Time::Max(), | 1330 remover->RemoveAndReply( |
1452 BrowsingDataRemover::REMOVE_HISTORY, | 1331 base::Time(), base::Time::Max(), {&content::kBrowsingDataTypeCookies}, |
1453 BrowsingDataHelper::UNPROTECTED_WEB, | 1332 BrowsingDataHelper::UNPROTECTED_WEB, &completion_observer); |
1454 &completion_observer); | |
1455 | 1333 |
1456 // Process messages until the inhibitor is notified, and then some, to make | 1334 // Process messages until the inhibitor is notified, and then some, to make |
1457 // sure we do not complete asynchronously before ContinueToCompletion() is | 1335 // sure we do not complete asynchronously before ContinueToCompletion() is |
1458 // called. | 1336 // called. |
1459 completion_inhibitor.BlockUntilNearCompletion(); | 1337 completion_inhibitor.BlockUntilNearCompletion(); |
1460 base::RunLoop().RunUntilIdle(); | 1338 base::RunLoop().RunUntilIdle(); |
1461 | 1339 |
1462 // Verify that the removal has not yet been completed and the observer has | 1340 // Verify that the removal has not yet been completed and the observer has |
1463 // not been called. | 1341 // not been called. |
1464 EXPECT_TRUE(remover->is_removing()); | 1342 EXPECT_TRUE(remover->is_removing()); |
1465 EXPECT_FALSE(completion_observer.called()); | 1343 EXPECT_FALSE(completion_observer.called()); |
1466 | 1344 |
1467 // Now run the removal process until completion, and verify that observers are | 1345 // Now run the removal process until completion, and verify that observers are |
1468 // now notified, and the notifications is sent out. | 1346 // now notified, and the notifications is sent out. |
1469 completion_inhibitor.ContinueToCompletion(); | 1347 completion_inhibitor.ContinueToCompletion(); |
1470 completion_observer.BlockUntilCompletion(); | 1348 completion_observer.BlockUntilCompletion(); |
1471 | 1349 |
1472 EXPECT_FALSE(remover->is_removing()); | 1350 EXPECT_FALSE(remover->is_removing()); |
1473 EXPECT_TRUE(completion_observer.called()); | 1351 EXPECT_TRUE(completion_observer.called()); |
1474 } | 1352 } |
1475 | 1353 |
1476 TEST_F(BrowsingDataRemoverImplTest, EarlyShutdown) { | 1354 TEST_F(BrowsingDataRemoverImplTest, EarlyShutdown) { |
1477 BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>( | 1355 BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>( |
1478 BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext())); | 1356 BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext())); |
1479 InspectableCompletionObserver completion_observer(remover); | 1357 InspectableCompletionObserver completion_observer(remover); |
1480 BrowsingDataRemoverCompletionInhibitor completion_inhibitor; | 1358 BrowsingDataRemoverCompletionInhibitor completion_inhibitor; |
1481 remover->RemoveAndReply(base::Time(), base::Time::Max(), | 1359 remover->RemoveAndReply( |
1482 BrowsingDataRemover::REMOVE_HISTORY, | 1360 base::Time(), base::Time::Max(), {&content::kBrowsingDataTypeCookies}, |
1483 BrowsingDataHelper::UNPROTECTED_WEB, | 1361 BrowsingDataHelper::UNPROTECTED_WEB, &completion_observer); |
1484 &completion_observer); | |
1485 | 1362 |
1486 completion_inhibitor.BlockUntilNearCompletion(); | 1363 completion_inhibitor.BlockUntilNearCompletion(); |
1487 | 1364 |
1488 // Verify that the deletion has not yet been completed and the observer has | 1365 // Verify that the deletion has not yet been completed and the observer has |
1489 // not been called. | 1366 // not been called. |
1490 EXPECT_TRUE(remover->is_removing()); | 1367 EXPECT_TRUE(remover->is_removing()); |
1491 EXPECT_FALSE(completion_observer.called()); | 1368 EXPECT_FALSE(completion_observer.called()); |
1492 | 1369 |
1493 // Destroying the profile should trigger the notification. | 1370 // Destroying the profile should trigger the notification. |
1494 DestroyBrowserContext(); | 1371 DestroyBrowserContext(); |
1495 | 1372 |
1496 EXPECT_TRUE(completion_observer.called()); | 1373 EXPECT_TRUE(completion_observer.called()); |
1497 | 1374 |
1498 // Finishing after shutdown shouldn't break anything. | 1375 // Finishing after shutdown shouldn't break anything. |
1499 completion_inhibitor.ContinueToCompletion(); | 1376 completion_inhibitor.ContinueToCompletion(); |
1500 completion_observer.BlockUntilCompletion(); | 1377 completion_observer.BlockUntilCompletion(); |
1501 } | 1378 } |
1502 | 1379 |
1503 TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByTimeOnly) { | 1380 TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByTimeOnly) { |
1504 RemoveDownloadsTester tester(GetBrowserContext()); | 1381 RemoveDownloadsTester tester(GetBrowserContext()); |
1505 base::Callback<bool(const GURL&)> filter = | 1382 base::Callback<bool(const GURL&)> filter = |
1506 BrowsingDataFilterBuilder::BuildNoopFilter(); | 1383 BrowsingDataFilterBuilder::BuildNoopFilter(); |
1507 | 1384 |
1508 EXPECT_CALL( | 1385 EXPECT_CALL( |
1509 *tester.download_manager(), | 1386 *tester.download_manager(), |
1510 RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _)); | 1387 RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _)); |
1511 | 1388 |
1512 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), | 1389 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
1513 BrowsingDataRemover::REMOVE_DOWNLOADS, false); | 1390 {&content::kBrowsingDataTypeDownloads}, false); |
1514 } | 1391 } |
1515 | 1392 |
1516 TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByOrigin) { | 1393 TEST_F(BrowsingDataRemoverImplTest, RemoveDownloadsByOrigin) { |
1517 RemoveDownloadsTester tester(GetBrowserContext()); | 1394 RemoveDownloadsTester tester(GetBrowserContext()); |
1518 std::unique_ptr<BrowsingDataFilterBuilder> builder( | 1395 std::unique_ptr<BrowsingDataFilterBuilder> builder( |
1519 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); | 1396 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::WHITELIST)); |
1520 builder->AddRegisterableDomain(kTestRegisterableDomain1); | 1397 builder->AddRegisterableDomain(kTestRegisterableDomain1); |
1521 base::Callback<bool(const GURL&)> filter = builder->BuildGeneralFilter(); | 1398 base::Callback<bool(const GURL&)> filter = builder->BuildGeneralFilter(); |
1522 | 1399 |
1523 EXPECT_CALL( | 1400 EXPECT_CALL( |
1524 *tester.download_manager(), | 1401 *tester.download_manager(), |
1525 RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _)); | 1402 RemoveDownloadsByURLAndTime(ProbablySameFilter(filter), _, _)); |
1526 | 1403 |
1527 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), | 1404 BlockUntilOriginDataRemoved(base::Time(), base::Time::Max(), |
1528 BrowsingDataRemover::REMOVE_DOWNLOADS, | 1405 {&content::kBrowsingDataTypeDownloads}, |
1529 std::move(builder)); | 1406 std::move(builder)); |
1530 } | 1407 } |
1531 | 1408 |
1532 class MultipleTasksObserver { | 1409 class MultipleTasksObserver { |
1533 public: | 1410 public: |
1534 // A simple implementation of BrowsingDataRemover::Observer. | 1411 // A simple implementation of BrowsingDataRemover::Observer. |
1535 // MultipleTasksObserver will use several instances of Target to test | 1412 // MultipleTasksObserver will use several instances of Target to test |
1536 // that completion callbacks are returned to the correct one. | 1413 // that completion callbacks are returned to the correct one. |
1537 class Target : public BrowsingDataRemover::Observer { | 1414 class Target : public BrowsingDataRemover::Observer { |
1538 public: | 1415 public: |
(...skipping 53 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1592 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder_2( | 1469 std::unique_ptr<BrowsingDataFilterBuilder> filter_builder_2( |
1593 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); | 1470 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST)); |
1594 filter_builder_2->AddRegisterableDomain("example.com"); | 1471 filter_builder_2->AddRegisterableDomain("example.com"); |
1595 | 1472 |
1596 MultipleTasksObserver observer(remover); | 1473 MultipleTasksObserver observer(remover); |
1597 BrowsingDataRemoverCompletionInhibitor completion_inhibitor; | 1474 BrowsingDataRemoverCompletionInhibitor completion_inhibitor; |
1598 | 1475 |
1599 // Test several tasks with various configuration of masks, filters, and target | 1476 // Test several tasks with various configuration of masks, filters, and target |
1600 // observers. | 1477 // observers. |
1601 std::list<BrowsingDataRemoverImpl::RemovalTask> tasks; | 1478 std::list<BrowsingDataRemoverImpl::RemovalTask> tasks; |
1602 tasks.emplace_back(base::Time(), base::Time::Max(), | 1479 tasks.emplace_back( |
1603 BrowsingDataRemover::REMOVE_HISTORY, | 1480 base::Time(), base::Time::Max(), |
1604 BrowsingDataHelper::UNPROTECTED_WEB, | 1481 Mask({&content::kBrowsingDataTypeCookies}), |
1605 BrowsingDataFilterBuilder::Create( | 1482 BrowsingDataHelper::UNPROTECTED_WEB, |
1606 BrowsingDataFilterBuilder::BLACKLIST), | 1483 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST), |
1607 observer.target_a()); | 1484 observer.target_a()); |
1608 tasks.emplace_back(base::Time(), base::Time::Max(), | 1485 tasks.emplace_back( |
1609 BrowsingDataRemover::REMOVE_COOKIES, | 1486 base::Time(), base::Time::Max(), |
1610 BrowsingDataHelper::PROTECTED_WEB, | 1487 Mask({&content::kBrowsingDataTypeCookies}), |
1611 BrowsingDataFilterBuilder::Create( | 1488 BrowsingDataHelper::PROTECTED_WEB, |
1612 BrowsingDataFilterBuilder::BLACKLIST), | 1489 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST), |
1613 nullptr); | 1490 nullptr); |
1614 tasks.emplace_back( | 1491 tasks.emplace_back( |
1615 base::Time::Now(), base::Time::Max(), | 1492 base::Time::Now(), base::Time::Max(), |
1616 BrowsingDataRemover::REMOVE_PASSWORDS, BrowsingDataHelper::ALL, | 1493 Mask({&content::kBrowsingDataTypeDownloads}), BrowsingDataHelper::ALL, |
1617 BrowsingDataFilterBuilder::Create( | 1494 BrowsingDataFilterBuilder::Create(BrowsingDataFilterBuilder::BLACKLIST), |
1618 BrowsingDataFilterBuilder::BLACKLIST), | |
1619 observer.target_b()); | 1495 observer.target_b()); |
1620 tasks.emplace_back( | 1496 tasks.emplace_back(base::Time(), base::Time::UnixEpoch(), |
1621 base::Time(), base::Time::UnixEpoch(), | 1497 Mask({&content::kBrowsingDataTypeWebSQL}), |
1622 BrowsingDataRemover::REMOVE_WEBSQL, | 1498 BrowsingDataHelper::UNPROTECTED_WEB, |
1623 BrowsingDataHelper::UNPROTECTED_WEB, | 1499 std::move(filter_builder_1), observer.target_b()); |
1624 std::move(filter_builder_1), | 1500 tasks.emplace_back(base::Time::UnixEpoch(), base::Time::Now(), |
1625 observer.target_b()); | 1501 Mask({&content::kBrowsingDataTypeChannelIDs}), |
1626 tasks.emplace_back( | 1502 BrowsingDataHelper::ALL, std::move(filter_builder_2), |
1627 base::Time::UnixEpoch(), base::Time::Now(), | 1503 nullptr); |
1628 BrowsingDataRemover::REMOVE_CHANNEL_IDS, | |
1629 BrowsingDataHelper::ALL, | |
1630 std::move(filter_builder_2), | |
1631 nullptr); | |
1632 | 1504 |
1633 for (BrowsingDataRemoverImpl::RemovalTask& task : tasks) { | 1505 for (BrowsingDataRemoverImpl::RemovalTask& task : tasks) { |
1634 // All tasks can be directly translated to a RemoveInternal() call. Since | 1506 // All tasks can be directly translated to a RemoveInternal() call. Since |
1635 // that is a private method, we must call the four public versions of | 1507 // that is a private method, we must call the four public versions of |
1636 // Remove.* instead. This also serves as a test that those methods are all | 1508 // Remove.* instead. This also serves as a test that those methods are all |
1637 // correctly reduced to RemoveInternal(). | 1509 // correctly reduced to RemoveInternal(). |
1638 if (!task.observer && task.filter_builder->IsEmptyBlacklist()) { | 1510 if (!task.observer && task.filter_builder->IsEmptyBlacklist()) { |
1639 remover->Remove(task.delete_begin, task.delete_end, | 1511 remover->Remove(task.delete_begin, task.delete_end, |
1640 task.remove_mask, task.origin_type_mask); | 1512 task.remove_mask, task.origin_type_mask); |
1641 } else if (task.filter_builder->IsEmptyBlacklist()) { | 1513 } else if (task.filter_builder->IsEmptyBlacklist()) { |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1680 // The previous test, BrowsingDataRemoverTest.MultipleTasks, tests that the | 1552 // The previous test, BrowsingDataRemoverTest.MultipleTasks, tests that the |
1681 // tasks are not mixed up and they are executed in a correct order. However, | 1553 // tasks are not mixed up and they are executed in a correct order. However, |
1682 // the completion inhibitor kept synchronizing the execution in order to verify | 1554 // the completion inhibitor kept synchronizing the execution in order to verify |
1683 // the parameters. This test demonstrates that even running the tasks without | 1555 // the parameters. This test demonstrates that even running the tasks without |
1684 // inhibition is executed correctly and doesn't crash. | 1556 // inhibition is executed correctly and doesn't crash. |
1685 TEST_F(BrowsingDataRemoverImplTest, MultipleTasksInQuickSuccession) { | 1557 TEST_F(BrowsingDataRemoverImplTest, MultipleTasksInQuickSuccession) { |
1686 BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>( | 1558 BrowsingDataRemoverImpl* remover = static_cast<BrowsingDataRemoverImpl*>( |
1687 BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext())); | 1559 BrowsingDataRemoverFactory::GetForBrowserContext(GetBrowserContext())); |
1688 EXPECT_FALSE(remover->is_removing()); | 1560 EXPECT_FALSE(remover->is_removing()); |
1689 | 1561 |
1690 int test_removal_masks[] = { | 1562 std::set<const BrowsingDataType*> test_removal_masks[] = { |
1691 BrowsingDataRemover::REMOVE_COOKIES, | 1563 {&content::kBrowsingDataTypeCookies}, |
1692 BrowsingDataRemover::REMOVE_PASSWORDS, | 1564 {&content::kBrowsingDataTypeChannelIDs}, |
1693 BrowsingDataRemover::REMOVE_COOKIES, | 1565 {&content::kBrowsingDataTypeCookies}, |
1694 BrowsingDataRemover::REMOVE_COOKIES, | 1566 {&content::kBrowsingDataTypeCookies}, |
1695 BrowsingDataRemover::REMOVE_COOKIES, | 1567 {&content::kBrowsingDataTypeCookies}, |
1696 BrowsingDataRemover::REMOVE_HISTORY, | 1568 {&content::kBrowsingDataTypeDownloads}, |
1697 BrowsingDataRemover::REMOVE_HISTORY, | 1569 {&content::kBrowsingDataTypeDownloads}, |
1698 BrowsingDataRemover::REMOVE_HISTORY, | 1570 {&content::kBrowsingDataTypeDownloads}, |
1699 BrowsingDataRemover::REMOVE_COOKIES | BrowsingDataRemover::REMOVE_HISTORY, | 1571 {&content::kBrowsingDataTypeCookies, |
1700 BrowsingDataRemover::REMOVE_COOKIES | BrowsingDataRemover::REMOVE_HISTORY, | 1572 &content::kBrowsingDataTypeDownloads}, |
1701 BrowsingDataRemover::REMOVE_COOKIES | | 1573 {&content::kBrowsingDataTypeCookies, |
1702 BrowsingDataRemover::REMOVE_HISTORY | | 1574 &content::kBrowsingDataTypeDownloads}, |
1703 BrowsingDataRemover::REMOVE_PASSWORDS, | 1575 {&content::kBrowsingDataTypeCookies, &content::kBrowsingDataTypeDownloads, |
1704 BrowsingDataRemover::REMOVE_PASSWORDS, | 1576 &content::kBrowsingDataTypeChannelIDs}, |
1705 BrowsingDataRemover::REMOVE_PASSWORDS, | 1577 {&content::kBrowsingDataTypeChannelIDs}, |
| 1578 {&content::kBrowsingDataTypeChannelIDs}, |
1706 }; | 1579 }; |
1707 | 1580 |
1708 for (int removal_mask : test_removal_masks) { | 1581 for (const std::set<const BrowsingDataType*>& removal_mask : |
| 1582 test_removal_masks) { |
1709 remover->Remove(base::Time(), base::Time::Max(), removal_mask, | 1583 remover->Remove(base::Time(), base::Time::Max(), removal_mask, |
1710 BrowsingDataHelper::UNPROTECTED_WEB); | 1584 BrowsingDataHelper::UNPROTECTED_WEB); |
1711 } | 1585 } |
1712 | 1586 |
1713 EXPECT_TRUE(remover->is_removing()); | 1587 EXPECT_TRUE(remover->is_removing()); |
1714 | 1588 |
1715 // Add one more deletion and wait for it. | 1589 // Add one more deletion and wait for it. |
1716 BlockUntilBrowsingDataRemoved( | 1590 BlockUntilBrowsingDataRemoved(base::Time(), base::Time::Max(), |
1717 base::Time(), base::Time::Max(), | 1591 {&content::kBrowsingDataTypeCookies}, |
1718 BrowsingDataRemover::REMOVE_COOKIES, | 1592 BrowsingDataHelper::UNPROTECTED_WEB); |
1719 BrowsingDataHelper::UNPROTECTED_WEB); | |
1720 | 1593 |
1721 EXPECT_FALSE(remover->is_removing()); | 1594 EXPECT_FALSE(remover->is_removing()); |
1722 } | 1595 } |
OLD | NEW |