| // Copyright 2022 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/json/json_file_value_serializer.h" |
| #include "base/json/values_util.h" |
| #include "base/path_service.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "chrome/browser/browsing_topics/browsing_topics_service_factory.h" |
| #include "chrome/browser/history/history_service_factory.h" |
| #include "chrome/browser/optimization_guide/browser_test_util.h" |
| #include "chrome/browser/optimization_guide/optimization_guide_keyed_service.h" |
| #include "chrome/browser/optimization_guide/optimization_guide_keyed_service_factory.h" |
| #include "chrome/browser/optimization_guide/page_content_annotations_service_factory.h" |
| #include "chrome/browser/privacy_sandbox/privacy_sandbox_settings_factory.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "chrome/test/base/in_process_browser_test.h" |
| #include "chrome/test/base/ui_test_utils.h" |
| #include "components/browsing_topics/browsing_topics_service.h" |
| #include "components/browsing_topics/browsing_topics_service_impl.h" |
| #include "components/browsing_topics/epoch_topics.h" |
| #include "components/browsing_topics/test_util.h" |
| #include "components/content_settings/browser/page_specific_content_settings.h" |
| #include "components/keyed_service/content/browser_context_dependency_manager.h" |
| #include "components/optimization_guide/content/browser/page_content_annotations_service.h" |
| #include "components/optimization_guide/content/browser/test_page_content_annotator.h" |
| #include "components/optimization_guide/core/test_model_info_builder.h" |
| #include "components/optimization_guide/core/test_optimization_guide_model_provider.h" |
| #include "components/privacy_sandbox/privacy_sandbox_settings.h" |
| #include "components/ukm/test_ukm_recorder.h" |
| #include "content/public/browser/browsing_topics_site_data_manager.h" |
| #include "content/public/browser/storage_partition.h" |
| #include "content/public/common/content_features.h" |
| #include "content/public/test/back_forward_cache_util.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/browsing_topics_test_util.h" |
| #include "content/public/test/fenced_frame_test_util.h" |
| #include "content/public/test/prerender_test_util.h" |
| #include "content/public/test/test_navigation_observer.h" |
| #include "net/dns/mock_host_resolver.h" |
| #include "net/test/embedded_test_server/request_handler_util.h" |
| #include "services/metrics/public/cpp/ukm_builders.h" |
| #include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h" |
| #include "third_party/blink/public/common/features.h" |
| |
| namespace browsing_topics { |
| |
| namespace { |
| |
| constexpr browsing_topics::HmacKey kTestKey = {1}; |
| |
| constexpr base::Time kTime1 = |
| base::Time::FromDeltaSinceWindowsEpoch(base::Days(1)); |
| constexpr base::Time kTime2 = |
| base::Time::FromDeltaSinceWindowsEpoch(base::Days(2)); |
| |
| constexpr size_t kTaxonomySize = 349; |
| constexpr int kTaxonomyVersion = 1; |
| constexpr int64_t kModelVersion = 2; |
| constexpr size_t kPaddedTopTopicsStartIndex = 5; |
| constexpr Topic kExpectedTopic1 = Topic(1); |
| constexpr Topic kExpectedTopic2 = Topic(10); |
| constexpr char kExpectedResultOrder1[] = |
| "[{\"configVersion\":\"chrome.1\",\"modelVersion\":\"2\"," |
| "\"taxonomyVersion\":\"1\",\"topic\":1,\"version\":\"chrome.1:1:2\"};{" |
| "\"configVersion\":\"chrome.1\",\"modelVersion\":\"2\"," |
| "\"taxonomyVersion\":\"1\",\"topic\":10,\"version\":\"chrome.1:1:2\"};]"; |
| |
| constexpr char kExpectedResultOrder2[] = |
| "[{\"configVersion\":\"chrome.1\",\"modelVersion\":\"2\"," |
| "\"taxonomyVersion\":\"1\",\"topic\":10,\"version\":\"chrome.1:1:2\"};{" |
| "\"configVersion\":\"chrome.1\",\"modelVersion\":\"2\"," |
| "\"taxonomyVersion\":\"1\",\"topic\":1,\"version\":\"chrome.1:1:2\"};]"; |
| |
| EpochTopics CreateTestEpochTopics( |
| const std::vector<std::pair<Topic, std::set<HashedDomain>>>& topics, |
| base::Time calculation_time) { |
| DCHECK_EQ(topics.size(), 5u); |
| |
| std::vector<TopicAndDomains> top_topics_and_observing_domains; |
| for (size_t i = 0; i < 5; ++i) { |
| top_topics_and_observing_domains.emplace_back(topics[i].first, |
| topics[i].second); |
| } |
| |
| return EpochTopics(std::move(top_topics_and_observing_domains), |
| kPaddedTopTopicsStartIndex, kTaxonomySize, |
| kTaxonomyVersion, kModelVersion, calculation_time); |
| } |
| |
| class PortalActivationWaiter : public content::WebContentsObserver { |
| public: |
| explicit PortalActivationWaiter(content::WebContents* portal_contents) |
| : content::WebContentsObserver(portal_contents) {} |
| |
| void Wait() { |
| if (!web_contents()->IsPortal()) |
| return; |
| |
| base::RunLoop run_loop; |
| quit_closure_ = run_loop.QuitClosure(); |
| run_loop.Run(); |
| } |
| |
| // content::WebContentsObserver: |
| void DidActivatePortal(content::WebContents* predecessor_contents, |
| base::TimeTicks activation_time) override { |
| if (quit_closure_) |
| std::move(quit_closure_).Run(); |
| } |
| |
| private: |
| base::OnceClosure quit_closure_; |
| }; |
| |
| } // namespace |
| |
| // A tester class that allows waiting for the first calculation to finish. |
| class TesterBrowsingTopicsService : public BrowsingTopicsServiceImpl { |
| public: |
| TesterBrowsingTopicsService( |
| const base::FilePath& profile_path, |
| privacy_sandbox::PrivacySandboxSettings* privacy_sandbox_settings, |
| history::HistoryService* history_service, |
| content::BrowsingTopicsSiteDataManager* site_data_manager, |
| optimization_guide::PageContentAnnotationsService* annotations_service, |
| base::OnceClosure calculation_finish_callback) |
| : BrowsingTopicsServiceImpl(profile_path, |
| privacy_sandbox_settings, |
| history_service, |
| site_data_manager, |
| annotations_service), |
| calculation_finish_callback_(std::move(calculation_finish_callback)) {} |
| |
| ~TesterBrowsingTopicsService() override = default; |
| |
| TesterBrowsingTopicsService(const TesterBrowsingTopicsService&) = delete; |
| TesterBrowsingTopicsService& operator=(const TesterBrowsingTopicsService&) = |
| delete; |
| TesterBrowsingTopicsService(TesterBrowsingTopicsService&&) = delete; |
| TesterBrowsingTopicsService& operator=(TesterBrowsingTopicsService&&) = |
| delete; |
| |
| const BrowsingTopicsState& browsing_topics_state() override { |
| return BrowsingTopicsServiceImpl::browsing_topics_state(); |
| } |
| |
| void OnCalculateBrowsingTopicsCompleted(EpochTopics epoch_topics) override { |
| BrowsingTopicsServiceImpl::OnCalculateBrowsingTopicsCompleted( |
| std::move(epoch_topics)); |
| |
| if (calculation_finish_callback_) |
| std::move(calculation_finish_callback_).Run(); |
| } |
| |
| private: |
| base::OnceClosure calculation_finish_callback_; |
| }; |
| |
| class BrowsingTopicsBrowserTestBase : public InProcessBrowserTest { |
| public: |
| void SetUpOnMainThread() override { |
| host_resolver()->AddRule("*", "127.0.0.1"); |
| https_server_.SetSSLConfig(net::EmbeddedTestServer::CERT_TEST_NAMES); |
| https_server_.AddDefaultHandlers(GetChromeTestDataDir()); |
| |
| content::SetupCrossSiteRedirector(&https_server_); |
| ASSERT_TRUE(https_server_.Start()); |
| |
| content::SetupCrossSiteRedirector(embedded_test_server()); |
| ASSERT_TRUE(embedded_test_server()->Start()); |
| } |
| |
| ~BrowsingTopicsBrowserTestBase() override = default; |
| |
| std::string InvokeTopicsAPI(const content::ToRenderFrameHost& adapter) { |
| return EvalJs(adapter, R"( |
| if (!(document.browsingTopics instanceof Function)) { |
| 'not a function'; |
| } else { |
| document.browsingTopics() |
| .then(topics => { |
| let result = "["; |
| for (const topic of topics) { |
| result += JSON.stringify(topic, Object.keys(topic).sort()) + ";" |
| } |
| result += "]"; |
| return result; |
| }) |
| .catch(error => error.message); |
| } |
| )") |
| .ExtractString(); |
| } |
| |
| content::WebContents* web_contents() { |
| return browser()->tab_strip_model()->GetActiveWebContents(); |
| } |
| |
| protected: |
| net::EmbeddedTestServer https_server_{ |
| net::test_server::EmbeddedTestServer::TYPE_HTTPS}; |
| }; |
| |
| class BrowsingTopicsDisabledBrowserTest : public BrowsingTopicsBrowserTestBase { |
| public: |
| BrowsingTopicsDisabledBrowserTest() { |
| scoped_feature_list_.InitWithFeatures( |
| /*enabled_features=*/{}, |
| /*disabled_features=*/{blink::features::kBrowsingTopics}); |
| } |
| |
| protected: |
| base::test::ScopedFeatureList scoped_feature_list_; |
| }; |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsDisabledBrowserTest, |
| NoBrowsingTopicsService) { |
| EXPECT_FALSE( |
| BrowsingTopicsServiceFactory::GetForProfile(browser()->profile())); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsDisabledBrowserTest, NoTopicsAPI) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| EXPECT_EQ("not a function", InvokeTopicsAPI(web_contents())); |
| } |
| |
| class BrowsingTopicsBrowserTest : public BrowsingTopicsBrowserTestBase { |
| public: |
| BrowsingTopicsBrowserTest() |
| : prerender_helper_( |
| base::BindRepeating(&BrowsingTopicsBrowserTest::web_contents, |
| base::Unretained(this))) { |
| scoped_feature_list_.InitWithFeatures( |
| /*enabled_features=*/ |
| {blink::features::kBrowsingTopics, |
| blink::features::kBrowsingTopicsBypassIPIsPubliclyRoutableCheck, |
| features::kPrivacySandboxAdsAPIsOverride, blink::features::kPortals}, |
| /*disabled_features=*/{}); |
| } |
| |
| ~BrowsingTopicsBrowserTest() override = default; |
| |
| void SetUpOnMainThread() override { |
| prerender_helper_.SetUp(&https_server_); |
| |
| BrowsingTopicsBrowserTestBase::SetUpOnMainThread(); |
| |
| for (auto& profile_and_calculation_finish_waiter : |
| calculation_finish_waiters_) { |
| profile_and_calculation_finish_waiter.second->Run(); |
| } |
| } |
| |
| // BrowserTestBase::SetUpInProcessBrowserTestFixture |
| void SetUpInProcessBrowserTestFixture() override { |
| subscription_ = |
| BrowserContextDependencyManager::GetInstance() |
| ->RegisterCreateServicesCallbackForTesting(base::BindRepeating( |
| &BrowsingTopicsBrowserTest::OnWillCreateBrowserContextServices, |
| base::Unretained(this))); |
| } |
| |
| protected: |
| void ExpectResultTopicsEqual( |
| const std::vector<TopicAndDomains>& result, |
| std::vector<std::pair<Topic, std::set<HashedDomain>>> expected) { |
| DCHECK_EQ(expected.size(), 5u); |
| EXPECT_EQ(result.size(), 5u); |
| |
| for (int i = 0; i < 5; ++i) { |
| EXPECT_EQ(result[i].topic(), expected[i].first); |
| EXPECT_EQ(result[i].hashed_domains(), expected[i].second); |
| } |
| } |
| |
| HashedDomain GetHashedDomain(const std::string& domain) { |
| return HashContextDomainForStorage(kTestKey, domain); |
| } |
| |
| void CreateBrowsingTopicsStateFile( |
| const base::FilePath& profile_path, |
| const std::vector<EpochTopics>& epochs, |
| base::Time next_scheduled_calculation_time) { |
| base::Value::List epochs_list; |
| for (const EpochTopics& epoch : epochs) { |
| epochs_list.Append(epoch.ToDictValue()); |
| } |
| |
| base::Value::Dict dict; |
| dict.Set("epochs", std::move(epochs_list)); |
| dict.Set("next_scheduled_calculation_time", |
| base::TimeToValue(next_scheduled_calculation_time)); |
| dict.Set("hex_encoded_hmac_key", base::HexEncode(kTestKey)); |
| dict.Set("config_version", 1); |
| |
| JSONFileValueSerializer( |
| profile_path.Append(FILE_PATH_LITERAL("BrowsingTopicsState"))) |
| .Serialize(dict); |
| } |
| |
| content::BrowsingTopicsSiteDataManager* browsing_topics_site_data_manager() { |
| return browser() |
| ->profile() |
| ->GetDefaultStoragePartition() |
| ->GetBrowsingTopicsSiteDataManager(); |
| } |
| |
| TesterBrowsingTopicsService* browsing_topics_service() { |
| return static_cast<TesterBrowsingTopicsService*>( |
| BrowsingTopicsServiceFactory::GetForProfile(browser()->profile())); |
| } |
| |
| const BrowsingTopicsState& browsing_topics_state() { |
| return browsing_topics_service()->browsing_topics_state(); |
| } |
| |
| content::test::PrerenderTestHelper& prerender_helper() { |
| return prerender_helper_; |
| } |
| |
| std::vector<optimization_guide::WeightedIdentifier> TopicsAndWeight( |
| const std::vector<int32_t>& topics, |
| double weight) { |
| std::vector<optimization_guide::WeightedIdentifier> result; |
| for (int32_t topic : topics) { |
| result.emplace_back(topic, weight); |
| } |
| |
| return result; |
| } |
| |
| void OnWillCreateBrowserContextServices(content::BrowserContext* context) { |
| PageContentAnnotationsServiceFactory::GetInstance()->SetTestingFactory( |
| context, |
| base::BindRepeating( |
| &BrowsingTopicsBrowserTest::CreatePageContentAnnotationsService, |
| base::Unretained(this))); |
| |
| browsing_topics::BrowsingTopicsServiceFactory::GetInstance() |
| ->SetTestingFactory( |
| context, |
| base::BindRepeating( |
| &BrowsingTopicsBrowserTest::CreateBrowsingTopicsService, |
| base::Unretained(this))); |
| } |
| |
| std::unique_ptr<KeyedService> CreatePageContentAnnotationsService( |
| content::BrowserContext* context) { |
| Profile* profile = Profile::FromBrowserContext(context); |
| |
| history::HistoryService* history_service = |
| HistoryServiceFactory::GetForProfile( |
| profile, ServiceAccessType::IMPLICIT_ACCESS); |
| |
| DCHECK(!base::Contains(optimization_guide_model_providers_, profile)); |
| optimization_guide_model_providers_.emplace( |
| profile, std::make_unique< |
| optimization_guide::TestOptimizationGuideModelProvider>()); |
| |
| auto page_content_annotations_service = |
| std::make_unique<optimization_guide::PageContentAnnotationsService>( |
| "en-US", optimization_guide_model_providers_.at(profile).get(), |
| history_service, nullptr, base::FilePath(), nullptr, nullptr); |
| |
| page_content_annotations_service->OverridePageContentAnnotatorForTesting( |
| &test_page_content_annotator_); |
| |
| return page_content_annotations_service; |
| } |
| |
| void InitializePreexistingState( |
| history::HistoryService* history_service, |
| content::BrowsingTopicsSiteDataManager* site_data_manager, |
| const base::FilePath& profile_path) { |
| // Configure the (mock) model. |
| test_page_content_annotator_.UsePageTopics( |
| *optimization_guide::TestModelInfoBuilder().SetVersion(1).Build(), |
| {{"foo6.com", TopicsAndWeight({1, 2, 3, 4, 5, 6}, 0.1)}, |
| {"foo5.com", TopicsAndWeight({2, 3, 4, 5, 6}, 0.1)}, |
| {"foo4.com", TopicsAndWeight({3, 4, 5, 6}, 0.1)}, |
| {"foo3.com", TopicsAndWeight({4, 5, 6}, 0.1)}, |
| {"foo2.com", TopicsAndWeight({5, 6}, 0.1)}, |
| {"foo1.com", TopicsAndWeight({6}, 0.1)}}); |
| |
| // Add some initial history. |
| history::HistoryAddPageArgs add_page_args; |
| add_page_args.time = base::Time::Now(); |
| add_page_args.context_id = reinterpret_cast<history::ContextID>(1); |
| add_page_args.nav_entry_id = 1; |
| |
| // Note: foo6.com isn't in the initial history. |
| for (int i = 1; i <= 5; ++i) { |
| add_page_args.url = |
| GURL(base::StrCat({"https://foo", base::NumberToString(i), ".com"})); |
| history_service->AddPage(add_page_args); |
| history_service->SetBrowsingTopicsAllowed(add_page_args.context_id, |
| add_page_args.nav_entry_id, |
| add_page_args.url); |
| } |
| |
| // Add some API usage contexts data. |
| site_data_manager->OnBrowsingTopicsApiUsed( |
| HashMainFrameHostForStorage("foo1.com"), {HashedDomain(1)}, |
| base::Time::Now()); |
| |
| // Initialize the `BrowsingTopicsState`. |
| std::vector<EpochTopics> preexisting_epochs; |
| preexisting_epochs.push_back( |
| CreateTestEpochTopics({{Topic(1), {GetHashedDomain("a.test")}}, |
| {Topic(2), {GetHashedDomain("a.test")}}, |
| {Topic(3), {GetHashedDomain("a.test")}}, |
| {Topic(4), {GetHashedDomain("a.test")}}, |
| {Topic(5), {GetHashedDomain("a.test")}}}, |
| kTime1)); |
| preexisting_epochs.push_back( |
| CreateTestEpochTopics({{Topic(6), {GetHashedDomain("a.test")}}, |
| {Topic(7), {GetHashedDomain("a.test")}}, |
| {Topic(8), {GetHashedDomain("a.test")}}, |
| {Topic(9), {GetHashedDomain("a.test")}}, |
| {Topic(10), {GetHashedDomain("a.test")}}}, |
| kTime2)); |
| |
| CreateBrowsingTopicsStateFile( |
| profile_path, std::move(preexisting_epochs), |
| /*next_scheduled_calculation_time=*/base::Time::Now() - base::Days(1)); |
| } |
| |
| std::unique_ptr<KeyedService> CreateBrowsingTopicsService( |
| content::BrowserContext* context) { |
| Profile* profile = Profile::FromBrowserContext(context); |
| |
| privacy_sandbox::PrivacySandboxSettings* privacy_sandbox_settings = |
| PrivacySandboxSettingsFactory::GetForProfile(profile); |
| |
| history::HistoryService* history_service = |
| HistoryServiceFactory::GetForProfile( |
| profile, ServiceAccessType::IMPLICIT_ACCESS); |
| |
| content::BrowsingTopicsSiteDataManager* site_data_manager = |
| context->GetDefaultStoragePartition() |
| ->GetBrowsingTopicsSiteDataManager(); |
| |
| optimization_guide::PageContentAnnotationsService* annotations_service = |
| PageContentAnnotationsServiceFactory::GetForProfile(profile); |
| |
| InitializePreexistingState(history_service, site_data_manager, |
| profile->GetPath()); |
| |
| DCHECK(!base::Contains(calculation_finish_waiters_, profile)); |
| calculation_finish_waiters_.emplace(profile, |
| std::make_unique<base::RunLoop>()); |
| |
| if (!ukm_recorder_) |
| ukm_recorder_ = std::make_unique<ukm::TestAutoSetUkmRecorder>(); |
| |
| return std::make_unique<TesterBrowsingTopicsService>( |
| profile->GetPath(), privacy_sandbox_settings, history_service, |
| site_data_manager, annotations_service, |
| calculation_finish_waiters_.at(profile)->QuitClosure()); |
| } |
| |
| content::test::FencedFrameTestHelper fenced_frame_test_helper_; |
| |
| content::test::PrerenderTestHelper prerender_helper_; |
| |
| base::test::ScopedFeatureList scoped_feature_list_; |
| |
| std::map< |
| Profile*, |
| std::unique_ptr<optimization_guide::TestOptimizationGuideModelProvider>> |
| optimization_guide_model_providers_; |
| |
| std::map<Profile*, std::unique_ptr<base::RunLoop>> |
| calculation_finish_waiters_; |
| |
| optimization_guide::TestPageContentAnnotator test_page_content_annotator_; |
| |
| std::unique_ptr<ukm::TestAutoSetUkmRecorder> ukm_recorder_; |
| |
| base::CallbackListSubscription subscription_; |
| }; |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, HasBrowsingTopicsService) { |
| EXPECT_TRUE(browsing_topics_service()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, NoServiceInIncognitoMode) { |
| CreateIncognitoBrowser(browser()->profile()); |
| |
| EXPECT_TRUE(browser()->profile()->HasPrimaryOTRProfile()); |
| |
| Profile* incognito_profile = |
| browser()->profile()->GetPrimaryOTRProfile(/*create_if_needed=*/false); |
| EXPECT_TRUE(incognito_profile); |
| |
| BrowsingTopicsService* incognito_browsing_topics_service = |
| BrowsingTopicsServiceFactory::GetForProfile(incognito_profile); |
| EXPECT_FALSE(incognito_browsing_topics_service); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, BrowsingTopicsStateOnStart) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| base::Time now = base::Time::Now(); |
| |
| EXPECT_EQ(browsing_topics_state().epochs().size(), 3u); |
| EXPECT_EQ(browsing_topics_state().epochs()[0].calculation_time(), kTime1); |
| EXPECT_EQ(browsing_topics_state().epochs()[1].calculation_time(), kTime2); |
| EXPECT_GT(browsing_topics_state().epochs()[2].calculation_time(), |
| now - base::Minutes(1)); |
| EXPECT_LT(browsing_topics_state().epochs()[2].calculation_time(), now); |
| |
| ExpectResultTopicsEqual( |
| browsing_topics_state().epochs()[0].top_topics_and_observing_domains(), |
| {{Topic(1), {GetHashedDomain("a.test")}}, |
| {Topic(2), {GetHashedDomain("a.test")}}, |
| {Topic(3), {GetHashedDomain("a.test")}}, |
| {Topic(4), {GetHashedDomain("a.test")}}, |
| {Topic(5), {GetHashedDomain("a.test")}}}); |
| |
| ExpectResultTopicsEqual( |
| browsing_topics_state().epochs()[1].top_topics_and_observing_domains(), |
| {{Topic(6), {GetHashedDomain("a.test")}}, |
| {Topic(7), {GetHashedDomain("a.test")}}, |
| {Topic(8), {GetHashedDomain("a.test")}}, |
| {Topic(9), {GetHashedDomain("a.test")}}, |
| {Topic(10), {GetHashedDomain("a.test")}}}); |
| |
| ExpectResultTopicsEqual( |
| browsing_topics_state().epochs()[2].top_topics_and_observing_domains(), |
| {{Topic(6), {HashedDomain(1)}}, |
| {Topic(5), {}}, |
| {Topic(4), {}}, |
| {Topic(3), {}}, |
| {Topic(2), {}}}); |
| |
| EXPECT_GT(browsing_topics_state().next_scheduled_calculation_time(), |
| now + base::Days(7) - base::Minutes(1)); |
| EXPECT_LT(browsing_topics_state().next_scheduled_calculation_time(), |
| now + base::Days(7)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, CalculationResultUkm) { |
| auto entries = ukm_recorder_->GetEntriesByName( |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult::kEntryName); |
| |
| // The number of entries should equal the number of profiles, which could be |
| // greater than 1 on some platform. |
| EXPECT_EQ(optimization_guide_model_providers_.size(), entries.size()); |
| |
| for (auto* entry : entries) { |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kTopTopic0Name, |
| 6); |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kTopTopic1Name, |
| 5); |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kTopTopic2Name, |
| 4); |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kTopTopic3Name, |
| 3); |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kTopTopic4Name, |
| 2); |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kTaxonomyVersionName, |
| 1); |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kModelVersionName, |
| 1); |
| ukm_recorder_->ExpectEntryMetric( |
| entry, |
| ukm::builders::BrowsingTopics_EpochTopicsCalculationResult:: |
| kPaddedTopicsStartIndexName, |
| 5); |
| } |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, ApiResultUkm) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| InvokeTopicsAPI(web_contents()); |
| |
| auto entries = ukm_recorder_->GetEntriesByName( |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kEntryName); |
| EXPECT_EQ(1u, entries.size()); |
| |
| ukm_recorder_->ExpectEntrySourceHasUrl(entries.back(), main_frame_url); |
| |
| const int64_t* topic0_metric = ukm_recorder_->GetEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic0Name); |
| const int64_t* topic1_metric = ukm_recorder_->GetEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic1Name); |
| |
| EXPECT_TRUE(topic0_metric); |
| EXPECT_TRUE(topic1_metric); |
| |
| EXPECT_TRUE((*topic0_metric == kExpectedTopic1.value() && |
| *topic1_metric == kExpectedTopic2.value()) || |
| (*topic0_metric == kExpectedTopic2.value() && |
| *topic1_metric == kExpectedTopic1.value())); |
| |
| ukm_recorder_->ExpectEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic0IsTrueTopTopicName, |
| true); |
| ukm_recorder_->ExpectEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic0ModelVersionName, |
| 2); |
| ukm_recorder_->ExpectEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic0TaxonomyVersionName, |
| 1); |
| |
| ukm_recorder_->ExpectEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic1IsTrueTopTopicName, |
| true); |
| ukm_recorder_->ExpectEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic1ModelVersionName, |
| 2); |
| ukm_recorder_->ExpectEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic1TaxonomyVersionName, |
| 1); |
| |
| EXPECT_FALSE(ukm_recorder_->GetEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kReturnedTopic2Name)); |
| EXPECT_FALSE(ukm_recorder_->GetEntryMetric( |
| entries.back(), |
| ukm::builders::BrowsingTopics_DocumentBrowsingTopicsApiResult:: |
| kEmptyReasonName)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, PageLoadUkm) { |
| // The test assumes pages gets deleted after navigation, triggering metrics |
| // recording. Disable back/forward cache to ensure that pages don't get |
| // preserved in the cache. |
| content::DisableBackForwardCacheForTesting( |
| web_contents(), content::BackForwardCache::TEST_REQUIRES_NO_CACHING); |
| |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| InvokeTopicsAPI(web_contents()); |
| |
| ASSERT_TRUE( |
| ui_test_utils::NavigateToURL(browser(), GURL(url::kAboutBlankURL))); |
| |
| auto entries = ukm_recorder_->GetEntriesByName( |
| ukm::builders::BrowsingTopics_PageLoad::kEntryName); |
| EXPECT_EQ(1u, entries.size()); |
| |
| ukm_recorder_->ExpectEntrySourceHasUrl(entries.back(), main_frame_url); |
| |
| ukm_recorder_->ExpectEntryMetric(entries.back(), |
| ukm::builders::BrowsingTopics_PageLoad:: |
| kTopicsRequestingContextDomainsCountName, |
| 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, GetTopicsForSiteForDisplay) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| std::vector<privacy_sandbox::CanonicalTopic> result = |
| browsing_topics_service()->GetTopicsForSiteForDisplay( |
| web_contents()->GetPrimaryMainFrame()->GetLastCommittedOrigin()); |
| |
| // Epoch switch time has not arrived. So expect one topic from each of the |
| // first two epochs. |
| EXPECT_EQ(result.size(), 2u); |
| EXPECT_EQ(result[0].topic_id(), Topic(1)); |
| EXPECT_EQ(result[0].taxonomy_version(), 1); |
| EXPECT_EQ(result[1].topic_id(), Topic(10)); |
| EXPECT_EQ(result[1].taxonomy_version(), 1); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, GetTopTopicsForDisplay) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| std::vector<privacy_sandbox::CanonicalTopic> result = |
| browsing_topics_service()->GetTopTopicsForDisplay(); |
| |
| EXPECT_EQ(result.size(), 15u); |
| EXPECT_EQ(result[0].topic_id(), Topic(1)); |
| EXPECT_EQ(result[1].topic_id(), Topic(2)); |
| EXPECT_EQ(result[2].topic_id(), Topic(3)); |
| EXPECT_EQ(result[3].topic_id(), Topic(4)); |
| EXPECT_EQ(result[4].topic_id(), Topic(5)); |
| EXPECT_EQ(result[5].topic_id(), Topic(6)); |
| EXPECT_EQ(result[6].topic_id(), Topic(7)); |
| EXPECT_EQ(result[7].topic_id(), Topic(8)); |
| EXPECT_EQ(result[8].topic_id(), Topic(9)); |
| EXPECT_EQ(result[9].topic_id(), Topic(10)); |
| EXPECT_EQ(result[10].topic_id(), Topic(6)); |
| EXPECT_EQ(result[11].topic_id(), Topic(5)); |
| EXPECT_EQ(result[12].topic_id(), Topic(4)); |
| EXPECT_EQ(result[13].topic_id(), Topic(3)); |
| EXPECT_EQ(result[14].topic_id(), Topic(2)); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPI_ContextDomainNotFiltered_FromMainFrame) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| std::string result = InvokeTopicsAPI(web_contents()); |
| |
| EXPECT_TRUE(result == kExpectedResultOrder1 || |
| result == kExpectedResultOrder2); |
| |
| // Ensure access has been reported to the Page Specific Content Settings. |
| auto* pscs = content_settings::PageSpecificContentSettings::GetForPage( |
| web_contents()->GetPrimaryPage()); |
| EXPECT_TRUE(pscs->HasAccessedTopics()); |
| auto topics = pscs->GetAccessedTopics(); |
| ASSERT_EQ(2u, topics.size()); |
| |
| // No ordering is enforced by the PSCS. |
| ASSERT_NE(topics[0].topic_id(), topics[1].topic_id()); |
| ASSERT_TRUE(topics[0].topic_id() == kExpectedTopic1 || |
| topics[0].topic_id() == kExpectedTopic2); |
| ASSERT_TRUE(topics[1].topic_id() == kExpectedTopic1 || |
| topics[1].topic_id() == kExpectedTopic2); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPI_ContextDomainNotFiltered_FromSubframe) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| GURL subframe_url = |
| https_server_.GetURL("a.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(content::NavigateIframeToURL(web_contents(), |
| /*iframe_id=*/"frame", |
| subframe_url)); |
| |
| std::string result = InvokeTopicsAPI( |
| content::ChildFrameAt(web_contents()->GetPrimaryMainFrame(), 0)); |
| |
| EXPECT_TRUE(result == kExpectedResultOrder1 || |
| result == kExpectedResultOrder2); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPI_ContextDomainFiltered) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| GURL subframe_url = |
| https_server_.GetURL("b.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(content::NavigateIframeToURL(web_contents(), |
| /*iframe_id=*/"frame", |
| subframe_url)); |
| |
| // b.test has yet to call the API so it shouldn't receive a topic. |
| EXPECT_EQ("[]", InvokeTopicsAPI(content::ChildFrameAt( |
| web_contents()->GetPrimaryMainFrame(), 0))); |
| auto* pscs = content_settings::PageSpecificContentSettings::GetForPage( |
| web_contents()->GetPrimaryPage()); |
| EXPECT_FALSE(pscs->HasAccessedTopics()); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPI_ContextDomainTracked) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| GURL subframe_url = |
| https_server_.GetURL("b.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(content::NavigateIframeToURL(web_contents(), |
| /*iframe_id=*/"frame", |
| subframe_url)); |
| |
| // The usage is not tracked before the API call. The returned entry was from |
| // the pre-existing storage. |
| std::vector<ApiUsageContext> api_usage_contexts = |
| content::GetBrowsingTopicsApiUsage(browsing_topics_site_data_manager()); |
| EXPECT_EQ(api_usage_contexts.size(), 1u); |
| |
| EXPECT_EQ("[]", InvokeTopicsAPI(content::ChildFrameAt( |
| web_contents()->GetPrimaryMainFrame(), 0))); |
| |
| api_usage_contexts = |
| content::GetBrowsingTopicsApiUsage(browsing_topics_site_data_manager()); |
| |
| // The usage is tracked after the API call. |
| EXPECT_EQ(api_usage_contexts.size(), 2u); |
| EXPECT_EQ(api_usage_contexts[0].hashed_main_frame_host, |
| HashMainFrameHostForStorage("foo1.com")); |
| EXPECT_EQ(api_usage_contexts[0].hashed_context_domain, HashedDomain(1)); |
| |
| EXPECT_EQ( |
| api_usage_contexts[1].hashed_main_frame_host, |
| HashMainFrameHostForStorage(https_server_.GetURL("a.test", "/").host())); |
| EXPECT_EQ(api_usage_contexts[1].hashed_context_domain, |
| GetHashedDomain("b.test")); |
| } |
| |
| IN_PROC_BROWSER_TEST_F( |
| BrowsingTopicsBrowserTest, |
| EmptyPage_PermissionsPolicyBrowsingTopicsNone_TopicsAPI) { |
| GURL main_frame_url = https_server_.GetURL( |
| "a.test", "/browsing_topics/empty_page_browsing_topics_none.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| EXPECT_EQ( |
| "The \"browsing-topics\" Permissions Policy denied the use of " |
| "document.browsingTopics().", |
| InvokeTopicsAPI(web_contents())); |
| } |
| |
| IN_PROC_BROWSER_TEST_F( |
| BrowsingTopicsBrowserTest, |
| EmptyPage_PermissionsPolicyInterestCohortNone_TopicsAPI) { |
| GURL main_frame_url = https_server_.GetURL( |
| "a.test", "/browsing_topics/empty_page_interest_cohort_none.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| EXPECT_EQ( |
| "The \"interest-cohort\" Permissions Policy denied the use of " |
| "document.browsingTopics().", |
| InvokeTopicsAPI(web_contents())); |
| } |
| |
| IN_PROC_BROWSER_TEST_F( |
| BrowsingTopicsBrowserTest, |
| OneIframePage_SubframePermissionsPolicyBrowsingTopicsNone_TopicsAPI) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| GURL subframe_url = https_server_.GetURL( |
| "a.test", "/browsing_topics/empty_page_browsing_topics_none.html"); |
| |
| ASSERT_TRUE(content::NavigateIframeToURL(web_contents(), |
| /*iframe_id=*/"frame", |
| subframe_url)); |
| |
| std::string result = InvokeTopicsAPI(web_contents()); |
| EXPECT_TRUE(result == kExpectedResultOrder1 || |
| result == kExpectedResultOrder2); |
| |
| EXPECT_EQ( |
| "The \"browsing-topics\" Permissions Policy denied the use of " |
| "document.browsingTopics().", |
| InvokeTopicsAPI( |
| content::ChildFrameAt(web_contents()->GetPrimaryMainFrame(), 0))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| PermissionsPolicyAllowCertainOrigin_TopicsAPI) { |
| base::StringPairs port_replacement; |
| port_replacement.push_back( |
| std::make_pair("{{PORT}}", base::NumberToString(https_server_.port()))); |
| |
| GURL main_frame_url = https_server_.GetURL( |
| "a.test", net::test_server::GetFilePathWithReplacements( |
| "/browsing_topics/" |
| "one_iframe_page_browsing_topics_allow_certain_origin.html", |
| port_replacement)); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| std::string result = InvokeTopicsAPI(web_contents()); |
| EXPECT_TRUE(result == kExpectedResultOrder1 || |
| result == kExpectedResultOrder2); |
| |
| GURL subframe_url = |
| https_server_.GetURL("c.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(content::NavigateIframeToURL(web_contents(), |
| /*iframe_id=*/"frame", |
| subframe_url)); |
| EXPECT_EQ("[]", InvokeTopicsAPI(content::ChildFrameAt( |
| web_contents()->GetPrimaryMainFrame(), 0))); |
| |
| subframe_url = |
| https_server_.GetURL("b.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_TRUE(content::NavigateIframeToURL(web_contents(), |
| /*iframe_id=*/"frame", |
| subframe_url)); |
| |
| EXPECT_EQ( |
| "The \"browsing-topics\" Permissions Policy denied the use of " |
| "document.browsingTopics().", |
| InvokeTopicsAPI( |
| content::ChildFrameAt(web_contents()->GetPrimaryMainFrame(), 0))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPINotAllowedInInsecureContext) { |
| GURL main_frame_url = embedded_test_server()->GetURL( |
| "a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| // Navigate the iframe to a https site. |
| GURL subframe_url = https_server_.GetURL("b.test", "/empty_page.html"); |
| content::NavigateIframeToURL(web_contents(), |
| /*iframe_id=*/"frame", subframe_url); |
| |
| // Both the main frame and the subframe are insecure context because the main |
| // frame is loaded over HTTP. Expect that the API isn't available in either |
| // frame. |
| EXPECT_EQ("not a function", InvokeTopicsAPI(web_contents())); |
| EXPECT_EQ("not a function", InvokeTopicsAPI(content::ChildFrameAt( |
| web_contents()->GetPrimaryMainFrame(), 0))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPINotAllowedInDetachedDocument) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| EXPECT_EQ( |
| "Failed to execute 'browsingTopics' on 'Document': A browsing " |
| "context is required when calling document.browsingTopics().", |
| EvalJs(web_contents(), R"( |
| const iframe = document.getElementById('frame'); |
| const childDocument = iframe.contentWindow.document; |
| iframe.remove(); |
| |
| childDocument.browsingTopics() |
| .then(topics => "success") |
| .catch(error => error.message); |
| )")); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPINotAllowedInOpaqueOriginDocument) { |
| GURL main_frame_url = https_server_.GetURL( |
| "a.test", "/browsing_topics/one_sandboxed_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| EXPECT_EQ( |
| "document.browsingTopics() is not allowed in an opaque origin context.", |
| InvokeTopicsAPI( |
| content::ChildFrameAt(web_contents()->GetPrimaryMainFrame(), 0))); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPINotAllowedInFencedFrame) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| GURL fenced_frame_url = |
| https_server_.GetURL("b.test", "/fenced_frames/title1.html"); |
| |
| content::RenderFrameHostWrapper fenced_frame_rfh_wrapper( |
| fenced_frame_test_helper_.CreateFencedFrame( |
| web_contents()->GetPrimaryMainFrame(), fenced_frame_url)); |
| |
| EXPECT_EQ("document.browsingTopics() is not allowed in a fenced frame.", |
| InvokeTopicsAPI(fenced_frame_rfh_wrapper.get())); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, |
| TopicsAPINotAllowedInPrerenderedPage) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| GURL prerender_url = |
| https_server_.GetURL("a.test", "/browsing_topics/empty_page.html"); |
| |
| int host_id = prerender_helper().AddPrerender(prerender_url); |
| |
| content::RenderFrameHost* prerender_host = |
| prerender_helper().GetPrerenderedMainFrameHost(host_id); |
| EXPECT_EQ( |
| "document.browsingTopics() is not allowed when the page is being " |
| "prerendered.", |
| InvokeTopicsAPI(prerender_host)); |
| |
| // Activate the prerendered page. The API call should succeed. |
| content::test::PrerenderHostObserver prerender_observer(*web_contents(), |
| prerender_url); |
| prerender_helper().NavigatePrimaryPage(prerender_url); |
| prerender_observer.WaitForActivation(); |
| |
| std::string result = InvokeTopicsAPI(web_contents()); |
| |
| EXPECT_TRUE(result == kExpectedResultOrder1 || |
| result == kExpectedResultOrder2); |
| } |
| |
| IN_PROC_BROWSER_TEST_F(BrowsingTopicsBrowserTest, TopicsAPINotAllowedInPortal) { |
| GURL main_frame_url = |
| https_server_.GetURL("a.test", "/browsing_topics/one_iframe_page.html"); |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| GURL portal_url = |
| https_server_.GetURL("a.test", "/browsing_topics/empty_page.html"); |
| |
| ASSERT_EQ(true, content::EvalJs(web_contents()->GetPrimaryMainFrame(), |
| content::JsReplace(R"( |
| new Promise((resolve) => { |
| let portal = document.createElement('portal'); |
| portal.src = $1; |
| portal.onload = () => { resolve(true); } |
| document.body.appendChild(portal); |
| }); |
| )", |
| portal_url))); |
| |
| std::vector<content::WebContents*> inner_web_contents = |
| web_contents()->GetInnerWebContents(); |
| EXPECT_EQ(1u, inner_web_contents.size()); |
| content::WebContents* portal_contents = inner_web_contents[0]; |
| |
| EXPECT_EQ( |
| "document.browsingTopics() is only allowed in the outermost page and " |
| "when the page is active.", |
| InvokeTopicsAPI(portal_contents)); |
| |
| // Activate the portal. The API call should succeed. |
| PortalActivationWaiter activation_waiter(portal_contents); |
| content::ExecuteScriptAsync(web_contents()->GetPrimaryMainFrame(), |
| "document.querySelector('portal').activate();"); |
| activation_waiter.Wait(); |
| |
| EXPECT_EQ(portal_contents, web_contents()); |
| |
| std::string result = InvokeTopicsAPI(web_contents()); |
| |
| EXPECT_TRUE(result == kExpectedResultOrder1 || |
| result == kExpectedResultOrder2); |
| } |
| |
| // Regression test for crbug/1339735. |
| IN_PROC_BROWSER_TEST_F( |
| BrowsingTopicsBrowserTest, |
| TopicsAPIInvokedInMainFrameUnloadHandler_NoRendererCrash) { |
| GURL main_frame_url = https_server_.GetURL( |
| "a.test", "/browsing_topics/get_topics_during_unload.html"); |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), main_frame_url)); |
| |
| // A renderer crash won't always be captured if the renderer is also shutting |
| // down naturally around the same time. Thus, we create a new page in the same |
| // renderer process to keep the renderer process alive when the page navigates |
| // away later. |
| content::TestNavigationObserver popup_observer(main_frame_url); |
| popup_observer.StartWatchingNewWebContents(); |
| EXPECT_TRUE( |
| ExecuteScript(web_contents()->GetPrimaryMainFrame(), |
| content::JsReplace("window.open($1)", main_frame_url))); |
| popup_observer.Wait(); |
| |
| GURL new_url = |
| https_server_.GetURL("b.test", "/browsing_topics/empty_page.html"); |
| ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), new_url)); |
| } |
| |
| } // namespace browsing_topics |
