third_party/blink/renderer/modules/content_extraction/frame_metadata_observer_registry_unittest.cc - chromium/src - Git at Google

 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "third_party/blink/renderer/modules/content_extraction/frame_metadata_observer_registry.h"

 #include "base/test/test_future.h"
 #include "mojo/public/cpp/bindings/receiver.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/public/mojom/content_extraction/ai_page_content_metadata.mojom-blink.h"
 #include "third_party/blink/public/mojom/content_extraction/frame_metadata_observer_registry.mojom-blink.h"
 #include "third_party/blink/renderer/core/dom/create_element_flags.h"
 #include "third_party/blink/renderer/core/dom/document.h"
 #include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/html/html_head_element.h"
 #include "third_party/blink/renderer/core/html/html_meta_element.h"
 #include "third_party/blink/renderer/core/html/html_script_element.h"
 #include "third_party/blink/renderer/platform/testing/task_environment.h"
 #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
 #include "third_party/blink/renderer/platform/testing/url_test_helpers.h"

 namespace blink {

 namespace {

 class MockPaidContentMetadataObserver
     : public mojom::blink::PaidContentMetadataObserver {
  public:
   MockPaidContentMetadataObserver() = default;
   ~MockPaidContentMetadataObserver() override = default;

   mojo::PendingRemote<mojom::blink::PaidContentMetadataObserver>
   BindNewPipeAndPassRemote() {
     return receiver_.BindNewPipeAndPassRemote();
   }

   // mojom::blink::PaidContentMetadataObserver:
   void OnPaidContentMetadataChanged(bool has_paid_content) override {
     future_.SetValue(has_paid_content);
   }

   base::test::TestFuture<bool>& future() { return future_; }

  private:
   base::test::TestFuture<bool> future_;
   mojo::Receiver<mojom::blink::PaidContentMetadataObserver> receiver_{this};
 };

 class MockMetaTagsObserver : public mojom::blink::MetaTagsObserver {
  public:
   MockMetaTagsObserver() = default;
   ~MockMetaTagsObserver() override = default;

   mojo::PendingRemote<mojom::blink::MetaTagsObserver>
   BindNewPipeAndPassRemote() {
     return receiver_.BindNewPipeAndPassRemote();
   }

   // mojom::blink::MetaTagsObserver:
   void OnMetaTagsChanged(Vector<mojom::blink::MetaTagPtr> meta_tags) override {
     future_.SetValue(std::move(meta_tags));
   }

   base::test::TestFuture<Vector<mojom::blink::MetaTagPtr>>& future() {
     return future_;
   }

  private:
   base::test::TestFuture<Vector<mojom::blink::MetaTagPtr>> future_;
   mojo::Receiver<mojom::blink::MetaTagsObserver> receiver_{this};
 };

 class FrameMetadataObserverRegistryTest : public testing::Test {
  public:
   void SetUp() override { helper_.Initialize(); }

   void BindRegistry() {
     mojo::Remote<mojom::blink::FrameMetadataObserverRegistry> remote;
     FrameMetadataObserverRegistry::BindReceiver(
         helper_.LocalMainFrame()->GetFrame(),
         remote.BindNewPipeAndPassReceiver());
     registry_ = FrameMetadataObserverRegistry::From(*GetDocument());
     ASSERT_TRUE(registry_);
   }

   void LoadHTML(const std::string& html) {
     frame_test_helpers::LoadHTMLString(
         helper_.LocalMainFrame(), html,
         url_test_helpers::ToKURL("https://example.com/"));
   }

   Document* GetDocument() {
     return helper_.LocalMainFrame()->GetFrame()->GetDocument();
   }

   void VerifyAuthorMetaTag(const Vector<mojom::blink::MetaTagPtr>& meta_tags) {
     ASSERT_EQ(meta_tags.size(), 1u);
     EXPECT_EQ(meta_tags[0]->name, "author");
     EXPECT_EQ(meta_tags[0]->content, "Gary");
   }

   void VerifyAuthorMetaTagNoContent(
       const Vector<mojom::blink::MetaTagPtr>& meta_tags) {
     ASSERT_EQ(meta_tags.size(), 1u);
     EXPECT_EQ(meta_tags[0]->name, "author");
     EXPECT_EQ(meta_tags[0]->content, "");
   }

  protected:
   test::TaskEnvironment task_environment_;
   frame_test_helpers::WebViewHelper helper_;
   Persistent<FrameMetadataObserverRegistry> registry_;
 };

 TEST_F(FrameMetadataObserverRegistryTest, PaidContent) {
   LoadHTML(R"HTML(
     <head>
       <script type="application/ld+json">{
         "@context": "http://schema.org",
         "@type": "NewsArticle",
         "isAccessibleForFree": false
       }</script>
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockPaidContentMetadataObserver observer;
   registry_->AddPaidContentMetadataObserver(
       observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Get());
 }

 TEST_F(FrameMetadataObserverRegistryTest, NoPaidContent) {
   LoadHTML("<body></body>");
   BindRegistry();

   MockPaidContentMetadataObserver observer;
   registry_->AddPaidContentMetadataObserver(
       observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   EXPECT_FALSE(observer.future().IsReady());
 }

 TEST_F(FrameMetadataObserverRegistryTest, LateObserver) {
   LoadHTML(R"HTML(
     <head>
       <script type="application/ld+json">{
         "@context": "http://schema.org",
         "@type": "NewsArticle",
         "isAccessibleForFree": false
       }</script>
     </head>
     <body></body>
   )HTML");
   // Ensure DOM is fully loaded before adding observer.
   BindRegistry();

   MockPaidContentMetadataObserver observer;
   registry_->AddPaidContentMetadataObserver(
       observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Get());
 }

 TEST_F(FrameMetadataObserverRegistryTest, PaidContentAddedDynamically) {
   LoadHTML(R"HTML(
     <head>
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockPaidContentMetadataObserver observer;
   registry_->AddPaidContentMetadataObserver(
       observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   // No paid content initially.
   EXPECT_FALSE(observer.future().IsReady());

   // Dynamically add paid content.
   auto* script = MakeGarbageCollected<HTMLScriptElement>(*GetDocument(),
                                                          CreateElementFlags());
   script->setAttribute(html_names::kTypeAttr,
                        AtomicString("application/ld+json"));
   script->setTextContent(R"JSON({
     "@context": "http://schema.org",
     "@type": "NewsArticle",
     "isAccessibleForFree": false
   })JSON");
   GetDocument()->head()->AppendChild(script);
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Get());
 }

 TEST_F(FrameMetadataObserverRegistryTest,
        PaidContentUnaffectedByOtherElements) {
   LoadHTML(R"HTML(
     <head>
       <script type="application/ld+json">{
         "@context": "http://schema.org",
         "@type": "NewsArticle",
         "isAccessibleForFree": false
       }</script>
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockPaidContentMetadataObserver observer;
   registry_->AddPaidContentMetadataObserver(
       observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Get());

   // Add a meta element, which should not trigger the observer.
   observer.future().Clear();
   auto* meta_element = MakeGarbageCollected<HTMLMetaElement>(
       *GetDocument(), CreateElementFlags());
   meta_element->setAttribute(html_names::kNameAttr, AtomicString("author"));
   meta_element->setAttribute(html_names::kContentAttr, AtomicString("Gary"));
   GetDocument()->head()->AppendChild(meta_element);
   test::RunPendingTasks();

   EXPECT_FALSE(observer.future().IsReady());
 }

 TEST_F(FrameMetadataObserverRegistryTest,
        PaidContentWithSchemaOrgTrailingSlash) {
   LoadHTML(R"HTML(
     <head>
       <script type="application/ld+json">{
         "@context": "http://schema.org/",
         "@type": "NewsArticle",
         "isAccessibleForFree": false
       }</script>
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockPaidContentMetadataObserver observer;
   registry_->AddPaidContentMetadataObserver(
       observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Get());
 }

 TEST_F(FrameMetadataObserverRegistryTest, PaidContentWithUnescapedNewlines) {
   LoadHTML(R"HTML(
     <head>
       <script type="application/ld+json">{
         "@context": "http://schema.org",
         "@type": "NewsArticle",
         "isAccessibleForFree": false,
         "description": "This is a description
 with unescaped newlines."
       }</script>
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockPaidContentMetadataObserver observer;
   registry_->AddPaidContentMetadataObserver(
       observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Get());
 }

 TEST_F(FrameMetadataObserverRegistryTest, MetaTags) {
   LoadHTML(R"HTML(
     <head>
       <meta name="author" content="Gary">
       <meta name="keywords" content="test">
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");
   names_to_observe.push_back("subject");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   auto meta_tags = observer.future().Take();
   VerifyAuthorMetaTag(meta_tags);
 }

 TEST_F(FrameMetadataObserverRegistryTest, MetaTagsLateObserver) {
   LoadHTML(R"HTML(
     <head>
       <meta name="author" content="Gary">
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");
   names_to_observe.push_back("subject");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   VerifyAuthorMetaTag(observer.future().Take());
 }

 TEST_F(FrameMetadataObserverRegistryTest, MetaTagsNameMismatch) {
   LoadHTML(R"HTML(
     <head>
       <meta name="author" content="Gary">
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("subject");
   names_to_observe.push_back("category");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Take().empty());
 }

 TEST_F(FrameMetadataObserverRegistryTest, NoMetaTags) {
   LoadHTML("<body></body>");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");
   names_to_observe.push_back("subject");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Take().empty());
 }

 TEST_F(FrameMetadataObserverRegistryTest,
        MetaTagsInitialUpdateWithNoMatchingTags) {
   LoadHTML("<body></body>");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Take().empty());
 }

 TEST_F(FrameMetadataObserverRegistryTest, MetaTagsUpdated) {
   LoadHTML(R"HTML(
     <head>
       <meta name="author" content="Gary">
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");
   names_to_observe.push_back("subject");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   // Initial state.
   ASSERT_TRUE(observer.future().IsReady());
   VerifyAuthorMetaTag(observer.future().Take());

   // Modify an existing tag.
   observer.future().Clear();
   auto* meta_element = To<HTMLMetaElement>(
       GetDocument()->head()->QuerySelector(AtomicString("meta[name=author]")));
   ASSERT_TRUE(meta_element);
   meta_element->setAttribute(html_names::kContentAttr, AtomicString("Val"));
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   auto meta_tags1 = observer.future().Take();
   EXPECT_EQ(meta_tags1.size(), 1u);
   EXPECT_EQ(meta_tags1[0]->name, "author");
   EXPECT_EQ(meta_tags1[0]->content, "Val");

   // Add a new tag.
   observer.future().Clear();
   auto* new_meta = MakeGarbageCollected<HTMLMetaElement>(*GetDocument(),
                                                          CreateElementFlags());
   new_meta->setAttribute(html_names::kNameAttr, AtomicString("subject"));
   new_meta->setAttribute(html_names::kContentAttr, AtomicString("testing"));
   GetDocument()->head()->AppendChild(new_meta);
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   auto meta_tags2 = observer.future().Take();
   EXPECT_EQ(meta_tags2.size(), 2u);
   bool author_found = false;
   bool subject_found = false;
   for (const auto& tag : meta_tags2) {
     if (tag->name == "author") {
       author_found = true;
       EXPECT_EQ(tag->content, "Val");
     } else if (tag->name == "subject") {
       subject_found = true;
       EXPECT_EQ(tag->content, "testing");
     }
   }
   EXPECT_TRUE(author_found);
   EXPECT_TRUE(subject_found);

   // Remove a tag.
   observer.future().Clear();
   meta_element = To<HTMLMetaElement>(
       GetDocument()->head()->QuerySelector(AtomicString("meta[name=author]")));
   ASSERT_TRUE(meta_element);
   meta_element->remove();
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   auto meta_tags3 = observer.future().Take();
   EXPECT_EQ(meta_tags3.size(), 1u);
   EXPECT_EQ(meta_tags3[0]->name, "subject");
   EXPECT_EQ(meta_tags3[0]->content, "testing");
 }

 TEST_F(FrameMetadataObserverRegistryTest, MetaTagsUnaffectedByOtherElements) {
   LoadHTML(R"HTML(
     <head>
       <meta name="author" content="Gary">
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   // Initial state.
   ASSERT_TRUE(observer.future().IsReady());
   VerifyAuthorMetaTag(observer.future().Take());

   // Add a script element, which should not trigger the observer.
   observer.future().Clear();
   auto* script_element = MakeGarbageCollected<HTMLScriptElement>(
       *GetDocument(), CreateElementFlags());
   script_element->setTextContent("console.log('hello');");
   GetDocument()->head()->AppendChild(script_element);
   test::RunPendingTasks();

   EXPECT_FALSE(observer.future().IsReady());
 }

 TEST_F(FrameMetadataObserverRegistryTest, MetaTagsWithNamelessTag) {
   LoadHTML(R"HTML(
     <head>
       <meta charset="UTF-8">
       <meta name="author" content="Gary">
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   VerifyAuthorMetaTag(observer.future().Take());
 }

 TEST_F(FrameMetadataObserverRegistryTest, MetaTagsWithNoContent) {
   LoadHTML(R"HTML(
     <head>
       <meta charset="UTF-8">
       <meta name="author">
     </head>
     <body></body>
   )HTML");
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   VerifyAuthorMetaTagNoContent(observer.future().Take());
 }

 // Re-enable this test once we support observing head elements that are added
 // dynamically.
 TEST_F(FrameMetadataObserverRegistryTest, MetaTagsAddedWithHead) {
   LoadHTML("<body></body>");
   // Remove the head that was automatically added by the parser, to simulate a
   // document that starts without one.
   GetDocument()->head()->remove();
   ASSERT_FALSE(GetDocument()->head());
   BindRegistry();

   MockMetaTagsObserver observer;
   Vector<String> names_to_observe;
   names_to_observe.push_back("author");

   registry_->AddMetaTagsObserver(names_to_observe,
                                  observer.BindNewPipeAndPassRemote());
   test::RunPendingTasks();

   // Initially, no head and no meta tags. An empty update should be sent.
   ASSERT_TRUE(observer.future().IsReady());
   EXPECT_TRUE(observer.future().Take().empty());

   // Dynamically add a head and meta tag.
   auto* head = MakeGarbageCollected<HTMLHeadElement>(*GetDocument());
   auto* meta = MakeGarbageCollected<HTMLMetaElement>(*GetDocument(),
                                                      CreateElementFlags());
   meta->setAttribute(html_names::kNameAttr, AtomicString("author"));
   meta->setAttribute(html_names::kContentAttr, AtomicString("Gary"));
   head->AppendChild(meta);
   GetDocument()->documentElement()->AppendChild(head);
   test::RunPendingTasks();

   ASSERT_TRUE(observer.future().IsReady());
   VerifyAuthorMetaTag(observer.future().Take());
 }

 }  // namespace

 }  // namespace blink
	// Copyright 2025 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "third_party/blink/renderer/modules/content_extraction/frame_metadata_observer_registry.h"

	#include "base/test/test_future.h"
	#include "mojo/public/cpp/bindings/receiver.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/blink/public/mojom/content_extraction/ai_page_content_metadata.mojom-blink.h"
	#include "third_party/blink/public/mojom/content_extraction/frame_metadata_observer_registry.mojom-blink.h"
	#include "third_party/blink/renderer/core/dom/create_element_flags.h"
	#include "third_party/blink/renderer/core/dom/document.h"
	#include "third_party/blink/renderer/core/frame/frame_test_helpers.h"
	#include "third_party/blink/renderer/core/frame/local_frame.h"
	#include "third_party/blink/renderer/core/html/html_head_element.h"
	#include "third_party/blink/renderer/core/html/html_meta_element.h"
	#include "third_party/blink/renderer/core/html/html_script_element.h"
	#include "third_party/blink/renderer/platform/testing/task_environment.h"
	#include "third_party/blink/renderer/platform/testing/unit_test_helpers.h"
	#include "third_party/blink/renderer/platform/testing/url_test_helpers.h"

	namespace blink {

	namespace {

	class MockPaidContentMetadataObserver
	: public mojom::blink::PaidContentMetadataObserver {
	public:
	MockPaidContentMetadataObserver() = default;
	~MockPaidContentMetadataObserver() override = default;

	mojo::PendingRemote<mojom::blink::PaidContentMetadataObserver>
	BindNewPipeAndPassRemote() {
	return receiver_.BindNewPipeAndPassRemote();
	}

	// mojom::blink::PaidContentMetadataObserver:
	void OnPaidContentMetadataChanged(bool has_paid_content) override {
	future_.SetValue(has_paid_content);
	}

	base::test::TestFuture<bool>& future() { return future_; }

	private:
	base::test::TestFuture<bool> future_;
	mojo::Receiver<mojom::blink::PaidContentMetadataObserver> receiver_{this};
	};

	class MockMetaTagsObserver : public mojom::blink::MetaTagsObserver {
	public:
	MockMetaTagsObserver() = default;
	~MockMetaTagsObserver() override = default;

	mojo::PendingRemote<mojom::blink::MetaTagsObserver>
	BindNewPipeAndPassRemote() {
	return receiver_.BindNewPipeAndPassRemote();
	}

	// mojom::blink::MetaTagsObserver:
	void OnMetaTagsChanged(Vector<mojom::blink::MetaTagPtr> meta_tags) override {
	future_.SetValue(std::move(meta_tags));
	}

	base::test::TestFuture<Vector<mojom::blink::MetaTagPtr>>& future() {
	return future_;
	}

	private:
	base::test::TestFuture<Vector<mojom::blink::MetaTagPtr>> future_;
	mojo::Receiver<mojom::blink::MetaTagsObserver> receiver_{this};
	};

	class FrameMetadataObserverRegistryTest : public testing::Test {
	public:
	void SetUp() override { helper_.Initialize(); }

	void BindRegistry() {
	mojo::Remote<mojom::blink::FrameMetadataObserverRegistry> remote;
	FrameMetadataObserverRegistry::BindReceiver(
	helper_.LocalMainFrame()->GetFrame(),
	remote.BindNewPipeAndPassReceiver());
	registry_ = FrameMetadataObserverRegistry::From(*GetDocument());
	ASSERT_TRUE(registry_);
	}

	void LoadHTML(const std::string& html) {
	frame_test_helpers::LoadHTMLString(
	helper_.LocalMainFrame(), html,
	url_test_helpers::ToKURL("https://example.com/"));
	}

	Document* GetDocument() {
	return helper_.LocalMainFrame()->GetFrame()->GetDocument();
	}

	void VerifyAuthorMetaTag(const Vector<mojom::blink::MetaTagPtr>& meta_tags) {
	ASSERT_EQ(meta_tags.size(), 1u);
	EXPECT_EQ(meta_tags[0]->name, "author");
	EXPECT_EQ(meta_tags[0]->content, "Gary");
	}

	void VerifyAuthorMetaTagNoContent(
	const Vector<mojom::blink::MetaTagPtr>& meta_tags) {
	ASSERT_EQ(meta_tags.size(), 1u);
	EXPECT_EQ(meta_tags[0]->name, "author");
	EXPECT_EQ(meta_tags[0]->content, "");
	}

	protected:
	test::TaskEnvironment task_environment_;
	frame_test_helpers::WebViewHelper helper_;
	Persistent<FrameMetadataObserverRegistry> registry_;
	};

	TEST_F(FrameMetadataObserverRegistryTest, PaidContent) {
	LoadHTML(R"HTML(
	<head>
	<script type="application/ld+json">{
	"@context": "http://schema.org",
	"@type": "NewsArticle",
	"isAccessibleForFree": false
	}</script>
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockPaidContentMetadataObserver observer;
	registry_->AddPaidContentMetadataObserver(
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Get());
	}

	TEST_F(FrameMetadataObserverRegistryTest, NoPaidContent) {
	LoadHTML("<body></body>");
	BindRegistry();

	MockPaidContentMetadataObserver observer;
	registry_->AddPaidContentMetadataObserver(
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	EXPECT_FALSE(observer.future().IsReady());
	}

	TEST_F(FrameMetadataObserverRegistryTest, LateObserver) {
	LoadHTML(R"HTML(
	<head>
	<script type="application/ld+json">{
	"@context": "http://schema.org",
	"@type": "NewsArticle",
	"isAccessibleForFree": false
	}</script>
	</head>
	<body></body>
	)HTML");
	// Ensure DOM is fully loaded before adding observer.
	BindRegistry();

	MockPaidContentMetadataObserver observer;
	registry_->AddPaidContentMetadataObserver(
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Get());
	}

	TEST_F(FrameMetadataObserverRegistryTest, PaidContentAddedDynamically) {
	LoadHTML(R"HTML(
	<head>
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockPaidContentMetadataObserver observer;
	registry_->AddPaidContentMetadataObserver(
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	// No paid content initially.
	EXPECT_FALSE(observer.future().IsReady());

	// Dynamically add paid content.
	auto* script = MakeGarbageCollected<HTMLScriptElement>(*GetDocument(),
	CreateElementFlags());
	script->setAttribute(html_names::kTypeAttr,
	AtomicString("application/ld+json"));
	script->setTextContent(R"JSON({
	"@context": "http://schema.org",
	"@type": "NewsArticle",
	"isAccessibleForFree": false
	})JSON");
	GetDocument()->head()->AppendChild(script);
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Get());
	}

	TEST_F(FrameMetadataObserverRegistryTest,
	PaidContentUnaffectedByOtherElements) {
	LoadHTML(R"HTML(
	<head>
	<script type="application/ld+json">{
	"@context": "http://schema.org",
	"@type": "NewsArticle",
	"isAccessibleForFree": false
	}</script>
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockPaidContentMetadataObserver observer;
	registry_->AddPaidContentMetadataObserver(
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Get());

	// Add a meta element, which should not trigger the observer.
	observer.future().Clear();
	auto* meta_element = MakeGarbageCollected<HTMLMetaElement>(
	*GetDocument(), CreateElementFlags());
	meta_element->setAttribute(html_names::kNameAttr, AtomicString("author"));
	meta_element->setAttribute(html_names::kContentAttr, AtomicString("Gary"));
	GetDocument()->head()->AppendChild(meta_element);
	test::RunPendingTasks();

	EXPECT_FALSE(observer.future().IsReady());
	}

	TEST_F(FrameMetadataObserverRegistryTest,
	PaidContentWithSchemaOrgTrailingSlash) {
	LoadHTML(R"HTML(
	<head>
	<script type="application/ld+json">{
	"@context": "http://schema.org/",
	"@type": "NewsArticle",
	"isAccessibleForFree": false
	}</script>
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockPaidContentMetadataObserver observer;
	registry_->AddPaidContentMetadataObserver(
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Get());
	}

	TEST_F(FrameMetadataObserverRegistryTest, PaidContentWithUnescapedNewlines) {
	LoadHTML(R"HTML(
	<head>
	<script type="application/ld+json">{
	"@context": "http://schema.org",
	"@type": "NewsArticle",
	"isAccessibleForFree": false,
	"description": "This is a description
	with unescaped newlines."
	}</script>
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockPaidContentMetadataObserver observer;
	registry_->AddPaidContentMetadataObserver(
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Get());
	}

	TEST_F(FrameMetadataObserverRegistryTest, MetaTags) {
	LoadHTML(R"HTML(
	<head>
	<meta name="author" content="Gary">
	<meta name="keywords" content="test">
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");
	names_to_observe.push_back("subject");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	auto meta_tags = observer.future().Take();
	VerifyAuthorMetaTag(meta_tags);
	}

	TEST_F(FrameMetadataObserverRegistryTest, MetaTagsLateObserver) {
	LoadHTML(R"HTML(
	<head>
	<meta name="author" content="Gary">
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");
	names_to_observe.push_back("subject");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	VerifyAuthorMetaTag(observer.future().Take());
	}

	TEST_F(FrameMetadataObserverRegistryTest, MetaTagsNameMismatch) {
	LoadHTML(R"HTML(
	<head>
	<meta name="author" content="Gary">
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("subject");
	names_to_observe.push_back("category");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Take().empty());
	}

	TEST_F(FrameMetadataObserverRegistryTest, NoMetaTags) {
	LoadHTML("<body></body>");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");
	names_to_observe.push_back("subject");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Take().empty());
	}

	TEST_F(FrameMetadataObserverRegistryTest,
	MetaTagsInitialUpdateWithNoMatchingTags) {
	LoadHTML("<body></body>");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Take().empty());
	}

	TEST_F(FrameMetadataObserverRegistryTest, MetaTagsUpdated) {
	LoadHTML(R"HTML(
	<head>
	<meta name="author" content="Gary">
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");
	names_to_observe.push_back("subject");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	// Initial state.
	ASSERT_TRUE(observer.future().IsReady());
	VerifyAuthorMetaTag(observer.future().Take());

	// Modify an existing tag.
	observer.future().Clear();
	auto* meta_element = To<HTMLMetaElement>(
	GetDocument()->head()->QuerySelector(AtomicString("meta[name=author]")));
	ASSERT_TRUE(meta_element);
	meta_element->setAttribute(html_names::kContentAttr, AtomicString("Val"));
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	auto meta_tags1 = observer.future().Take();
	EXPECT_EQ(meta_tags1.size(), 1u);
	EXPECT_EQ(meta_tags1[0]->name, "author");
	EXPECT_EQ(meta_tags1[0]->content, "Val");

	// Add a new tag.
	observer.future().Clear();
	auto* new_meta = MakeGarbageCollected<HTMLMetaElement>(*GetDocument(),
	CreateElementFlags());
	new_meta->setAttribute(html_names::kNameAttr, AtomicString("subject"));
	new_meta->setAttribute(html_names::kContentAttr, AtomicString("testing"));
	GetDocument()->head()->AppendChild(new_meta);
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	auto meta_tags2 = observer.future().Take();
	EXPECT_EQ(meta_tags2.size(), 2u);
	bool author_found = false;
	bool subject_found = false;
	for (const auto& tag : meta_tags2) {
	if (tag->name == "author") {
	author_found = true;
	EXPECT_EQ(tag->content, "Val");
	} else if (tag->name == "subject") {
	subject_found = true;
	EXPECT_EQ(tag->content, "testing");
	}
	}
	EXPECT_TRUE(author_found);
	EXPECT_TRUE(subject_found);

	// Remove a tag.
	observer.future().Clear();
	meta_element = To<HTMLMetaElement>(
	GetDocument()->head()->QuerySelector(AtomicString("meta[name=author]")));
	ASSERT_TRUE(meta_element);
	meta_element->remove();
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	auto meta_tags3 = observer.future().Take();
	EXPECT_EQ(meta_tags3.size(), 1u);
	EXPECT_EQ(meta_tags3[0]->name, "subject");
	EXPECT_EQ(meta_tags3[0]->content, "testing");
	}

	TEST_F(FrameMetadataObserverRegistryTest, MetaTagsUnaffectedByOtherElements) {
	LoadHTML(R"HTML(
	<head>
	<meta name="author" content="Gary">
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	// Initial state.
	ASSERT_TRUE(observer.future().IsReady());
	VerifyAuthorMetaTag(observer.future().Take());

	// Add a script element, which should not trigger the observer.
	observer.future().Clear();
	auto* script_element = MakeGarbageCollected<HTMLScriptElement>(
	*GetDocument(), CreateElementFlags());
	script_element->setTextContent("console.log('hello');");
	GetDocument()->head()->AppendChild(script_element);
	test::RunPendingTasks();

	EXPECT_FALSE(observer.future().IsReady());
	}

	TEST_F(FrameMetadataObserverRegistryTest, MetaTagsWithNamelessTag) {
	LoadHTML(R"HTML(
	<head>
	<meta charset="UTF-8">
	<meta name="author" content="Gary">
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	VerifyAuthorMetaTag(observer.future().Take());
	}

	TEST_F(FrameMetadataObserverRegistryTest, MetaTagsWithNoContent) {
	LoadHTML(R"HTML(
	<head>
	<meta charset="UTF-8">
	<meta name="author">
	</head>
	<body></body>
	)HTML");
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	VerifyAuthorMetaTagNoContent(observer.future().Take());
	}

	// Re-enable this test once we support observing head elements that are added
	// dynamically.
	TEST_F(FrameMetadataObserverRegistryTest, MetaTagsAddedWithHead) {
	LoadHTML("<body></body>");
	// Remove the head that was automatically added by the parser, to simulate a
	// document that starts without one.
	GetDocument()->head()->remove();
	ASSERT_FALSE(GetDocument()->head());
	BindRegistry();

	MockMetaTagsObserver observer;
	Vector<String> names_to_observe;
	names_to_observe.push_back("author");

	registry_->AddMetaTagsObserver(names_to_observe,
	observer.BindNewPipeAndPassRemote());
	test::RunPendingTasks();

	// Initially, no head and no meta tags. An empty update should be sent.
	ASSERT_TRUE(observer.future().IsReady());
	EXPECT_TRUE(observer.future().Take().empty());

	// Dynamically add a head and meta tag.
	auto* head = MakeGarbageCollected<HTMLHeadElement>(*GetDocument());
	auto* meta = MakeGarbageCollected<HTMLMetaElement>(*GetDocument(),
	CreateElementFlags());
	meta->setAttribute(html_names::kNameAttr, AtomicString("author"));
	meta->setAttribute(html_names::kContentAttr, AtomicString("Gary"));
	head->AppendChild(meta);
	GetDocument()->documentElement()->AppendChild(head);
	test::RunPendingTasks();

	ASSERT_TRUE(observer.future().IsReady());
	VerifyAuthorMetaTag(observer.future().Take());
	}

	} // namespace

	} // namespace blink