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