third_party/blink/renderer/modules/broadcastchannel/broadcast_channel_unittest.cc - chromium/src.git - Git at Google

 // 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 "third_party/blink/renderer/modules/broadcastchannel/broadcast_channel.h"

 #include <iterator>

 #include "base/run_loop.h"
 #include "base/task/sequenced_task_runner.h"
 #include "base/test/bind.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
 #include "third_party/blink/renderer/core/dom/events/event.h"
 #include "third_party/blink/renderer/core/dom/events/native_event_listener.h"
 #include "third_party/blink/renderer/core/event_type_names.h"
 #include "third_party/blink/renderer/core/events/message_event.h"
 #include "third_party/blink/renderer/core/execution_context/execution_context.h"
 #include "third_party/blink/renderer/core/frame/local_dom_window.h"
 #include "third_party/blink/renderer/core/frame/local_frame.h"
 #include "third_party/blink/renderer/core/messaging/blink_cloneable_message.h"
 #include "third_party/blink/renderer/core/testing/dummy_page_holder.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
 #include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_receiver.h"
 #include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_remote.h"
 #include "third_party/blink/renderer/platform/testing/task_environment.h"
 #include "v8/include/v8.h"

 namespace blink {

 class BroadcastChannelTester : public GarbageCollected<BroadcastChannelTester>,
                                public mojom::blink::BroadcastChannelClient {
  public:
   explicit BroadcastChannelTester(ExecutionContext* execution_context)
       : receiver_(this, execution_context), remote_(execution_context) {
     // Ideally, these would share a pipe. This is more convenient.
     mojo::PendingAssociatedReceiver<mojom::blink::BroadcastChannelClient>
         receiver0;
     mojo::PendingAssociatedRemote<mojom::blink::BroadcastChannelClient>
         remote0 = receiver0.InitWithNewEndpointAndPassRemote();
     receiver0.EnableUnassociatedUsage();
     mojo::PendingAssociatedReceiver<mojom::blink::BroadcastChannelClient>
         receiver1;
     mojo::PendingAssociatedRemote<mojom::blink::BroadcastChannelClient>
         remote1 = receiver1.InitWithNewEndpointAndPassRemote();
     receiver1.EnableUnassociatedUsage();

     scoped_refptr<base::SequencedTaskRunner> task_runner =
         execution_context->GetTaskRunner(TaskType::kInternalTest);
     receiver_.Bind(std::move(receiver0), task_runner);
     remote_.Bind(std::move(remote1), task_runner);
     channel_ = MakeGarbageCollected<BroadcastChannel>(
         base::PassKey<BroadcastChannelTester>(), execution_context,
         "BroadcastChannelTester", std::move(receiver1), std::move(remote0));

     auto* listener = MakeGarbageCollected<EventListener>(this);
     channel_->addEventListener(event_type_names::kMessage, listener);
     channel_->addEventListener(event_type_names::kMessageerror, listener);
   }

   BroadcastChannel* channel() const { return channel_.Get(); }
   const HeapVector<Member<MessageEvent>>& received_events() const {
     return received_events_;
   }
   const Vector<BlinkCloneableMessage>& sent_messages() const {
     return sent_messages_;
   }

   void AwaitNextUpdate(base::OnceClosure closure) {
     on_next_update_.push_back(std::move(closure));
   }

   void PostMessage(BlinkCloneableMessage message) {
     remote_->OnMessage(std::move(message));
   }

   void Trace(Visitor* visitor) const {
     visitor->Trace(channel_);
     visitor->Trace(received_events_);
     visitor->Trace(receiver_);
     visitor->Trace(remote_);
   }

   // BroadcastChannelClient
   void OnMessage(BlinkCloneableMessage message) override {
     sent_messages_.push_back(std::move(message));
     ReportUpdate();
   }

  private:
   class EventListener : public NativeEventListener {
    public:
     explicit EventListener(BroadcastChannelTester* tester) : tester_(tester) {}
     void Trace(Visitor* visitor) const override {
       NativeEventListener::Trace(visitor);
       visitor->Trace(tester_);
     }

     void Invoke(ExecutionContext*, Event* event) override {
       tester_->received_events_.push_back(static_cast<MessageEvent*>(event));
       tester_->ReportUpdate();
     }

    private:
     Member<BroadcastChannelTester> tester_;
   };

   void ReportUpdate() {
     Vector<base::OnceClosure> closures = std::move(on_next_update_);
     for (auto& closure : closures)
       std::move(closure).Run();
   }

   Member<BroadcastChannel> channel_;
   HeapVector<Member<MessageEvent>> received_events_;
   Vector<BlinkCloneableMessage> sent_messages_;
   Vector<base::OnceClosure> on_next_update_;
   HeapMojoAssociatedReceiver<mojom::blink::BroadcastChannelClient,
                              BroadcastChannelTester>
       receiver_;
   HeapMojoAssociatedRemote<mojom::blink::BroadcastChannelClient> remote_;
 };

 namespace {

 BlinkCloneableMessage MakeNullMessage() {
   BlinkCloneableMessage message;
   message.message = SerializedScriptValue::NullValue();
   message.sender_agent_cluster_id = base::UnguessableToken::Create();
   return message;
 }

 TEST(BroadcastChannelTest, DispatchMessageEvent) {
   test::TaskEnvironment task_environment;
   DummyPageHolder holder;
   ExecutionContext* execution_context = holder.GetFrame().DomWindow();
   auto* tester =
       MakeGarbageCollected<BroadcastChannelTester>(execution_context);

   base::RunLoop run_loop;
   tester->AwaitNextUpdate(run_loop.QuitClosure());
   tester->PostMessage(MakeNullMessage());
   run_loop.Run();

   ASSERT_EQ(tester->received_events().size(), 1u);
   EXPECT_EQ(tester->received_events()[0]->type(), event_type_names::kMessage);
 }

 TEST(BroadcastChannelTest, AgentClusterLockedMatch) {
   test::TaskEnvironment task_environment;
   DummyPageHolder holder;
   ExecutionContext* execution_context = holder.GetFrame().DomWindow();
   auto* tester =
       MakeGarbageCollected<BroadcastChannelTester>(execution_context);

   base::RunLoop run_loop;
   tester->AwaitNextUpdate(run_loop.QuitClosure());
   BlinkCloneableMessage message = MakeNullMessage();
   message.sender_agent_cluster_id = execution_context->GetAgentClusterID();
   message.locked_to_sender_agent_cluster = true;
   tester->PostMessage(std::move(message));
   run_loop.Run();

   ASSERT_EQ(tester->received_events().size(), 1u);
   EXPECT_EQ(tester->received_events()[0]->type(), event_type_names::kMessage);
 }

 TEST(BroadcastChannelTest, AgentClusterLockedMismatch) {
   test::TaskEnvironment task_environment;
   DummyPageHolder holder;
   ExecutionContext* execution_context = holder.GetFrame().DomWindow();
   auto* tester =
       MakeGarbageCollected<BroadcastChannelTester>(execution_context);

   base::RunLoop run_loop;
   tester->AwaitNextUpdate(run_loop.QuitClosure());
   BlinkCloneableMessage message = MakeNullMessage();
   message.locked_to_sender_agent_cluster = true;
   tester->PostMessage(std::move(message));
   run_loop.Run();

   ASSERT_EQ(tester->received_events().size(), 1u);
   EXPECT_EQ(tester->received_events()[0]->type(),
             event_type_names::kMessageerror);
 }

 TEST(BroadcastChannelTest, MessageCannotDeserialize) {
   test::TaskEnvironment task_environment;
   DummyPageHolder holder;
   LocalDOMWindow* window = holder.GetFrame().DomWindow();
   auto* tester = MakeGarbageCollected<BroadcastChannelTester>(window);

   SerializedScriptValue::ScopedOverrideCanDeserializeInForTesting
       override_can_deserialize_in(base::BindLambdaForTesting(
           [&](const SerializedScriptValue& value,
               ExecutionContext* execution_context, bool can_deserialize) {
             EXPECT_EQ(execution_context, window);
             EXPECT_TRUE(can_deserialize);
             return false;
           }));

   base::RunLoop run_loop;
   tester->AwaitNextUpdate(run_loop.QuitClosure());
   tester->PostMessage(MakeNullMessage());
   run_loop.Run();

   ASSERT_EQ(tester->received_events().size(), 1u);
   EXPECT_EQ(tester->received_events()[0]->type(),
             event_type_names::kMessageerror);
 }

 TEST(BroadcastChannelTest, OutgoingMessagesMarkedWithAgentClusterId) {
   test::TaskEnvironment task_environment;
   DummyPageHolder holder;
   ExecutionContext* execution_context = holder.GetFrame().DomWindow();
   ScriptState* script_state = ToScriptStateForMainWorld(&holder.GetFrame());
   auto* tester =
       MakeGarbageCollected<BroadcastChannelTester>(execution_context);

   base::RunLoop run_loop;
   tester->AwaitNextUpdate(run_loop.QuitClosure());
   {
     ScriptState::Scope scope(script_state);
     tester->channel()->postMessage(
         ScriptValue::CreateNull(script_state->GetIsolate()),
         ASSERT_NO_EXCEPTION);
   }
   run_loop.Run();

   ASSERT_EQ(tester->sent_messages().size(), 1u);
   EXPECT_EQ(tester->sent_messages()[0].sender_agent_cluster_id,
             execution_context->GetAgentClusterID());
   EXPECT_FALSE(tester->sent_messages()[0].locked_to_sender_agent_cluster);
 }

 // TODO(crbug.com/1413818): iOS doesn't support WebAssembly yet.
 #if BUILDFLAG(IS_IOS)
 #define MAYBE_OutgoingAgentClusterLockedMessage \
   DISABLED_OutgoingAgentClusterLockedMessage
 #else
 #define MAYBE_OutgoingAgentClusterLockedMessage \
   OutgoingAgentClusterLockedMessage
 #endif

 TEST(BroadcastChannelTest, MAYBE_OutgoingAgentClusterLockedMessage) {
   test::TaskEnvironment task_environment;
   DummyPageHolder holder;
   ExecutionContext* execution_context = holder.GetFrame().DomWindow();
   ScriptState* script_state = ToScriptStateForMainWorld(&holder.GetFrame());
   v8::Isolate* isolate = script_state->GetIsolate();
   auto* tester =
       MakeGarbageCollected<BroadcastChannelTester>(execution_context);

   base::RunLoop run_loop;
   tester->AwaitNextUpdate(run_loop.QuitClosure());
   {
     // WebAssembly modules are always agent cluster locked. This is a trivial
     // one with no functionality, just the minimal magic and version.
     static constexpr uint8_t kTrivialModuleBytes[] = {0x00, 0x61, 0x73, 0x6d,
                                                       0x01, 0x00, 0x00, 0x00};
     ScriptState::Scope scope(script_state);
     v8::Local<v8::WasmModuleObject> trivial_module =
         v8::WasmModuleObject::Compile(isolate, {std::data(kTrivialModuleBytes),
                                                 std::size(kTrivialModuleBytes)})
             .ToLocalChecked();
     tester->channel()->postMessage(ScriptValue(isolate, trivial_module),
                                    ASSERT_NO_EXCEPTION);
   }
   run_loop.Run();

   ASSERT_EQ(tester->sent_messages().size(), 1u);
   EXPECT_EQ(tester->sent_messages()[0].sender_agent_cluster_id,
             execution_context->GetAgentClusterID());
   EXPECT_TRUE(tester->sent_messages()[0].locked_to_sender_agent_cluster);
 }

 }  // namespace
 }  // namespace blink
	// 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 "third_party/blink/renderer/modules/broadcastchannel/broadcast_channel.h"

	#include <iterator>

	#include "base/run_loop.h"
	#include "base/task/sequenced_task_runner.h"
	#include "base/test/bind.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
	#include "third_party/blink/renderer/core/dom/events/event.h"
	#include "third_party/blink/renderer/core/dom/events/native_event_listener.h"
	#include "third_party/blink/renderer/core/event_type_names.h"
	#include "third_party/blink/renderer/core/events/message_event.h"
	#include "third_party/blink/renderer/core/execution_context/execution_context.h"
	#include "third_party/blink/renderer/core/frame/local_dom_window.h"
	#include "third_party/blink/renderer/core/frame/local_frame.h"
	#include "third_party/blink/renderer/core/messaging/blink_cloneable_message.h"
	#include "third_party/blink/renderer/core/testing/dummy_page_holder.h"
	#include "third_party/blink/renderer/platform/heap/garbage_collected.h"
	#include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_receiver.h"
	#include "third_party/blink/renderer/platform/mojo/heap_mojo_associated_remote.h"
	#include "third_party/blink/renderer/platform/testing/task_environment.h"
	#include "v8/include/v8.h"

	namespace blink {

	class BroadcastChannelTester : public GarbageCollected<BroadcastChannelTester>,
	public mojom::blink::BroadcastChannelClient {
	public:
	explicit BroadcastChannelTester(ExecutionContext* execution_context)
	: receiver_(this, execution_context), remote_(execution_context) {
	// Ideally, these would share a pipe. This is more convenient.
	mojo::PendingAssociatedReceiver<mojom::blink::BroadcastChannelClient>
	receiver0;
	mojo::PendingAssociatedRemote<mojom::blink::BroadcastChannelClient>
	remote0 = receiver0.InitWithNewEndpointAndPassRemote();
	receiver0.EnableUnassociatedUsage();
	mojo::PendingAssociatedReceiver<mojom::blink::BroadcastChannelClient>
	receiver1;
	mojo::PendingAssociatedRemote<mojom::blink::BroadcastChannelClient>
	remote1 = receiver1.InitWithNewEndpointAndPassRemote();
	receiver1.EnableUnassociatedUsage();

	scoped_refptr<base::SequencedTaskRunner> task_runner =
	execution_context->GetTaskRunner(TaskType::kInternalTest);
	receiver_.Bind(std::move(receiver0), task_runner);
	remote_.Bind(std::move(remote1), task_runner);
	channel_ = MakeGarbageCollected<BroadcastChannel>(
	base::PassKey<BroadcastChannelTester>(), execution_context,
	"BroadcastChannelTester", std::move(receiver1), std::move(remote0));

	auto* listener = MakeGarbageCollected<EventListener>(this);
	channel_->addEventListener(event_type_names::kMessage, listener);
	channel_->addEventListener(event_type_names::kMessageerror, listener);
	}

	BroadcastChannel* channel() const { return channel_.Get(); }
	const HeapVector<Member<MessageEvent>>& received_events() const {
	return received_events_;
	}
	const Vector<BlinkCloneableMessage>& sent_messages() const {
	return sent_messages_;
	}

	void AwaitNextUpdate(base::OnceClosure closure) {
	on_next_update_.push_back(std::move(closure));
	}

	void PostMessage(BlinkCloneableMessage message) {
	remote_->OnMessage(std::move(message));
	}

	void Trace(Visitor* visitor) const {
	visitor->Trace(channel_);
	visitor->Trace(received_events_);
	visitor->Trace(receiver_);
	visitor->Trace(remote_);
	}

	// BroadcastChannelClient
	void OnMessage(BlinkCloneableMessage message) override {
	sent_messages_.push_back(std::move(message));
	ReportUpdate();
	}

	private:
	class EventListener : public NativeEventListener {
	public:
	explicit EventListener(BroadcastChannelTester* tester) : tester_(tester) {}
	void Trace(Visitor* visitor) const override {
	NativeEventListener::Trace(visitor);
	visitor->Trace(tester_);
	}

	void Invoke(ExecutionContext, Event event) override {
	tester_->received_events_.push_back(static_cast<MessageEvent*>(event));
	tester_->ReportUpdate();
	}

	private:
	Member<BroadcastChannelTester> tester_;
	};

	void ReportUpdate() {
	Vector<base::OnceClosure> closures = std::move(on_next_update_);
	for (auto& closure : closures)
	std::move(closure).Run();
	}

	Member<BroadcastChannel> channel_;
	HeapVector<Member<MessageEvent>> received_events_;
	Vector<BlinkCloneableMessage> sent_messages_;
	Vector<base::OnceClosure> on_next_update_;
	HeapMojoAssociatedReceiver<mojom::blink::BroadcastChannelClient,
	BroadcastChannelTester>
	receiver_;
	HeapMojoAssociatedRemote<mojom::blink::BroadcastChannelClient> remote_;
	};

	namespace {

	BlinkCloneableMessage MakeNullMessage() {
	BlinkCloneableMessage message;
	message.message = SerializedScriptValue::NullValue();
	message.sender_agent_cluster_id = base::UnguessableToken::Create();
	return message;
	}

	TEST(BroadcastChannelTest, DispatchMessageEvent) {
	test::TaskEnvironment task_environment;
	DummyPageHolder holder;
	ExecutionContext* execution_context = holder.GetFrame().DomWindow();
	auto* tester =
	MakeGarbageCollected<BroadcastChannelTester>(execution_context);

	base::RunLoop run_loop;
	tester->AwaitNextUpdate(run_loop.QuitClosure());
	tester->PostMessage(MakeNullMessage());
	run_loop.Run();

	ASSERT_EQ(tester->received_events().size(), 1u);
	EXPECT_EQ(tester->received_events()[0]->type(), event_type_names::kMessage);
	}

	TEST(BroadcastChannelTest, AgentClusterLockedMatch) {
	test::TaskEnvironment task_environment;
	DummyPageHolder holder;
	ExecutionContext* execution_context = holder.GetFrame().DomWindow();
	auto* tester =
	MakeGarbageCollected<BroadcastChannelTester>(execution_context);

	base::RunLoop run_loop;
	tester->AwaitNextUpdate(run_loop.QuitClosure());
	BlinkCloneableMessage message = MakeNullMessage();
	message.sender_agent_cluster_id = execution_context->GetAgentClusterID();
	message.locked_to_sender_agent_cluster = true;
	tester->PostMessage(std::move(message));
	run_loop.Run();

	ASSERT_EQ(tester->received_events().size(), 1u);
	EXPECT_EQ(tester->received_events()[0]->type(), event_type_names::kMessage);
	}

	TEST(BroadcastChannelTest, AgentClusterLockedMismatch) {
	test::TaskEnvironment task_environment;
	DummyPageHolder holder;
	ExecutionContext* execution_context = holder.GetFrame().DomWindow();
	auto* tester =
	MakeGarbageCollected<BroadcastChannelTester>(execution_context);

	base::RunLoop run_loop;
	tester->AwaitNextUpdate(run_loop.QuitClosure());
	BlinkCloneableMessage message = MakeNullMessage();
	message.locked_to_sender_agent_cluster = true;
	tester->PostMessage(std::move(message));
	run_loop.Run();

	ASSERT_EQ(tester->received_events().size(), 1u);
	EXPECT_EQ(tester->received_events()[0]->type(),
	event_type_names::kMessageerror);
	}

	TEST(BroadcastChannelTest, MessageCannotDeserialize) {
	test::TaskEnvironment task_environment;
	DummyPageHolder holder;
	LocalDOMWindow* window = holder.GetFrame().DomWindow();
	auto* tester = MakeGarbageCollected<BroadcastChannelTester>(window);

	SerializedScriptValue::ScopedOverrideCanDeserializeInForTesting
	override_can_deserialize_in(base::BindLambdaForTesting(
	[&](const SerializedScriptValue& value,
	ExecutionContext* execution_context, bool can_deserialize) {
	EXPECT_EQ(execution_context, window);
	EXPECT_TRUE(can_deserialize);
	return false;
	}));

	base::RunLoop run_loop;
	tester->AwaitNextUpdate(run_loop.QuitClosure());
	tester->PostMessage(MakeNullMessage());
	run_loop.Run();

	ASSERT_EQ(tester->received_events().size(), 1u);
	EXPECT_EQ(tester->received_events()[0]->type(),
	event_type_names::kMessageerror);
	}

	TEST(BroadcastChannelTest, OutgoingMessagesMarkedWithAgentClusterId) {
	test::TaskEnvironment task_environment;
	DummyPageHolder holder;
	ExecutionContext* execution_context = holder.GetFrame().DomWindow();
	ScriptState* script_state = ToScriptStateForMainWorld(&holder.GetFrame());
	auto* tester =
	MakeGarbageCollected<BroadcastChannelTester>(execution_context);

	base::RunLoop run_loop;
	tester->AwaitNextUpdate(run_loop.QuitClosure());
	{
	ScriptState::Scope scope(script_state);
	tester->channel()->postMessage(
	ScriptValue::CreateNull(script_state->GetIsolate()),
	ASSERT_NO_EXCEPTION);
	}
	run_loop.Run();

	ASSERT_EQ(tester->sent_messages().size(), 1u);
	EXPECT_EQ(tester->sent_messages()[0].sender_agent_cluster_id,
	execution_context->GetAgentClusterID());
	EXPECT_FALSE(tester->sent_messages()[0].locked_to_sender_agent_cluster);
	}

	// TODO(crbug.com/1413818): iOS doesn't support WebAssembly yet.
	#if BUILDFLAG(IS_IOS)
	#define MAYBE_OutgoingAgentClusterLockedMessage \
	DISABLED_OutgoingAgentClusterLockedMessage
	#else
	#define MAYBE_OutgoingAgentClusterLockedMessage \
	OutgoingAgentClusterLockedMessage
	#endif

	TEST(BroadcastChannelTest, MAYBE_OutgoingAgentClusterLockedMessage) {
	test::TaskEnvironment task_environment;
	DummyPageHolder holder;
	ExecutionContext* execution_context = holder.GetFrame().DomWindow();
	ScriptState* script_state = ToScriptStateForMainWorld(&holder.GetFrame());
	v8::Isolate* isolate = script_state->GetIsolate();
	auto* tester =
	MakeGarbageCollected<BroadcastChannelTester>(execution_context);

	base::RunLoop run_loop;
	tester->AwaitNextUpdate(run_loop.QuitClosure());
	{
	// WebAssembly modules are always agent cluster locked. This is a trivial
	// one with no functionality, just the minimal magic and version.
	static constexpr uint8_t kTrivialModuleBytes[] = {0x00, 0x61, 0x73, 0x6d,
	0x01, 0x00, 0x00, 0x00};
	ScriptState::Scope scope(script_state);
	v8::Local<v8::WasmModuleObject> trivial_module =
	v8::WasmModuleObject::Compile(isolate, {std::data(kTrivialModuleBytes),
	std::size(kTrivialModuleBytes)})
	.ToLocalChecked();
	tester->channel()->postMessage(ScriptValue(isolate, trivial_module),
	ASSERT_NO_EXCEPTION);
	}
	run_loop.Run();

	ASSERT_EQ(tester->sent_messages().size(), 1u);
	EXPECT_EQ(tester->sent_messages()[0].sender_agent_cluster_id,
	execution_context->GetAgentClusterID());
	EXPECT_TRUE(tester->sent_messages()[0].locked_to_sender_agent_cluster);
	}

	} // namespace
	} // namespace blink