| // Copyright 2017 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "extensions/renderer/api/messaging/native_renderer_messaging_service.h" |
| |
| #include <memory> |
| |
| #include "base/memory/raw_ptr.h" |
| #include "base/run_loop.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/bind.h" |
| #include "base/test/gmock_callback_support.h" |
| #include "base/values.h" |
| #include "components/crx_file/id_util.h" |
| #include "content/public/common/content_constants.h" |
| #include "extensions/common/api/messaging/messaging_endpoint.h" |
| #include "extensions/common/extension.h" |
| #include "extensions/common/extension_builder.h" |
| #include "extensions/common/mojom/context_type.mojom.h" |
| #include "extensions/common/mojom/message_port.mojom-shared.h" |
| #include "extensions/renderer/api/messaging/message_target.h" |
| #include "extensions/renderer/api/messaging/messaging_util.h" |
| #include "extensions/renderer/api/messaging/mock_message_port_host.h" |
| #include "extensions/renderer/bindings/api_binding_test_util.h" |
| #include "extensions/renderer/bindings/api_binding_types.h" |
| #include "extensions/renderer/bindings/api_response_validator.h" |
| #include "extensions/renderer/native_extension_bindings_system.h" |
| #include "extensions/renderer/native_extension_bindings_system_test_base.h" |
| #include "extensions/renderer/script_context.h" |
| #include "extensions/renderer/script_context_set.h" |
| |
| namespace extensions { |
| |
| namespace { |
| |
| // Unfortunately, we have a layering violation in the runtime API. The runtime |
| // API is defined at the //extensions layer, but the `MessageSender` type has an |
| // optional `tabs.Tab` property. This causes issues in type validation because |
| // when we try to look up the `tabs.Tab` property, it fails (since it's only |
| // defined in //chrome). This is a "real bug" in that it's a layering violation, |
| // but it doesn't have real-world implications since right now the only consumer |
| // of //extensions is //chrome (and thus, the tabs API will always be defined). |
| // Ignore validation for the affected runtime message-related events. |
| class RuntimeMessageValidationIgnorer { |
| public: |
| RuntimeMessageValidationIgnorer() |
| : test_handler_(base::BindRepeating( |
| &RuntimeMessageValidationIgnorer::HardValidationFailure)) { |
| test_handler_.IgnoreSignature("runtime.onMessage"); |
| test_handler_.IgnoreSignature("runtime.onMessageExternal"); |
| test_handler_.IgnoreSignature("runtime.onConnect"); |
| } |
| ~RuntimeMessageValidationIgnorer() = default; |
| |
| private: |
| // Hard-fail on any unexpected validation errors. |
| static void HardValidationFailure(const std::string& name, |
| const std::string& failure) { |
| NOTREACHED() << "Unexpected validation failure: " << name << ", " |
| << failure; |
| } |
| |
| APIResponseValidator::TestHandler test_handler_; |
| }; |
| |
| } // namespace |
| |
| class NativeRendererMessagingServiceTest |
| : public NativeExtensionBindingsSystemUnittest { |
| public: |
| NativeRendererMessagingServiceTest() {} |
| |
| NativeRendererMessagingServiceTest( |
| const NativeRendererMessagingServiceTest&) = delete; |
| NativeRendererMessagingServiceTest& operator=( |
| const NativeRendererMessagingServiceTest&) = delete; |
| |
| ~NativeRendererMessagingServiceTest() override {} |
| |
| // NativeExtensionBindingsSystemUnittest: |
| void SetUp() override { |
| NativeExtensionBindingsSystemUnittest::SetUp(); |
| |
| extension_ = ExtensionBuilder("foo").Build(); |
| RegisterExtension(extension_); |
| |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| script_context_ = CreateScriptContext( |
| context, extension_.get(), mojom::ContextType::kPrivilegedExtension); |
| script_context_->set_url(extension_->url()); |
| bindings_system()->UpdateBindingsForContext(script_context_); |
| } |
| void TearDown() override { |
| script_context_ = nullptr; |
| extension_ = nullptr; |
| NativeExtensionBindingsSystemUnittest::TearDown(); |
| } |
| bool UseStrictIPCMessageSender() override { return true; } |
| |
| NativeRendererMessagingService* messaging_service() { |
| return bindings_system()->messaging_service(); |
| } |
| ScriptContext* script_context() { return script_context_; } |
| const Extension* extension() { return extension_.get(); } |
| |
| private: |
| raw_ptr<ScriptContext> script_context_ = nullptr; |
| scoped_refptr<const Extension> extension_; |
| }; |
| |
| TEST_F(NativeRendererMessagingServiceTest, OpenMessagePort) { |
| RuntimeMessageValidationIgnorer message_validation_ignorer; |
| |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| base::UnguessableToken other_context_id = base::UnguessableToken::Create(); |
| const PortId port_id(other_context_id, 0, false, |
| mojom::SerializationFormat::kJson); |
| EXPECT_FALSE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| |
| const std::string channel_name = "some channel"; |
| NativeRendererMessagingService::TabConnectionInfo tab_connection_info; |
| NativeRendererMessagingService::ExternalConnectionInfo |
| external_connection_info; |
| tab_connection_info.frame_id = 0; |
| const int tab_id = 10; |
| GURL source_url("http://example.com"); |
| tab_connection_info.tab = base::Value::Dict().Set("tabId", tab_id); |
| external_connection_info.target_id = extension()->id(); |
| external_connection_info.source_endpoint = |
| MessagingEndpoint::ForExtension(extension()->id()); |
| external_connection_info.source_url = source_url; |
| external_connection_info.guest_process_id = |
| content::kInvalidChildProcessUniqueId; |
| external_connection_info.guest_render_frame_routing_id = 0; |
| |
| const char kAddListener[] = |
| "(function() {\n" |
| " chrome.runtime.onConnect.addListener(function(port) {\n" |
| " this.eventFired = true;\n" |
| " this.sender = port.sender\n" |
| " });\n" |
| "})"; |
| v8::Local<v8::Function> add_listener = |
| FunctionFromString(context, kAddListener); |
| RunFunctionOnGlobal(add_listener, context, 0, nullptr); |
| |
| mojo::PendingAssociatedRemote<mojom::MessagePortHost> port_host_remote; |
| auto port_host_receiver = |
| port_host_remote.InitWithNewEndpointAndPassReceiver(); |
| |
| mojo::PendingAssociatedReceiver<mojom::MessagePort> port_receiver; |
| auto port_remote = port_receiver.InitWithNewEndpointAndPassRemote(); |
| |
| bool port_opened = false; |
| messaging_service()->DispatchOnConnect( |
| script_context_set(), port_id, mojom::ChannelType::kConnect, channel_name, |
| tab_connection_info, external_connection_info, std::move(port_receiver), |
| std::move(port_host_remote), nullptr, |
| base::BindLambdaForTesting( |
| [&port_opened](bool success) { port_opened = success; })); |
| port_host_receiver.EnableUnassociatedUsage(); |
| port_remote.EnableUnassociatedUsage(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| EXPECT_TRUE(port_opened); |
| |
| ASSERT_TRUE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| |
| EXPECT_EQ("true", GetStringPropertyFromObject(context->Global(), context, |
| "eventFired")); |
| base::Value::Dict expected_sender = |
| base::Value::Dict() |
| .Set("frameId", 0) |
| .Set("tab", base::Value::Dict().Set("tabId", tab_id)) |
| .Set("url", source_url.spec()) |
| .Set("id", extension()->id()); |
| EXPECT_EQ(ValueToString(base::Value(std::move(expected_sender))), |
| GetStringPropertyFromObject(context->Global(), context, "sender")); |
| } |
| |
| TEST_F(NativeRendererMessagingServiceTest, DeliverMessageToPort) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| base::UnguessableToken other_context_id = base::UnguessableToken::Create(); |
| const PortId port_id1(other_context_id, 0, false, |
| mojom::SerializationFormat::kJson); |
| const PortId port_id2(other_context_id, 1, false, |
| mojom::SerializationFormat::kJson); |
| |
| mojo::PendingAssociatedRemote<mojom::MessagePort> message_port_remote1; |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| message_port_host_receiver1; |
| mojo::PendingAssociatedRemote<mojom::MessagePort> message_port_remote2; |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| message_port_host_receiver2; |
| |
| GinPort* port1 = messaging_service()->CreatePortForTesting( |
| script_context(), "channel1", mojom::ChannelType::kSendMessage, port_id1, |
| message_port_remote1, message_port_host_receiver1); |
| GinPort* port2 = messaging_service()->CreatePortForTesting( |
| script_context(), "channel2", mojom::ChannelType::kSendMessage, port_id2, |
| message_port_remote2, message_port_host_receiver2); |
| message_port_remote1.EnableUnassociatedUsage(); |
| message_port_host_receiver1.EnableUnassociatedUsage(); |
| message_port_remote2.EnableUnassociatedUsage(); |
| message_port_host_receiver2.EnableUnassociatedUsage(); |
| |
| const char kOnMessageListenerTemplate[] = |
| "(function(port) {\n" |
| " port.onMessage.addListener((message) => {\n" |
| " this.%s = message;\n" |
| " });\n" |
| "})"; |
| const char kPort1Message[] = "port1Message"; |
| const char kPort2Message[] = "port2Message"; |
| { |
| v8::Local<v8::Function> add_on_message_listener = FunctionFromString( |
| context, base::StringPrintf(kOnMessageListenerTemplate, kPort1Message)); |
| v8::Local<v8::Value> args[] = { |
| port1->GetWrapper(isolate()).ToLocalChecked()}; |
| RunFunctionOnGlobal(add_on_message_listener, context, std::size(args), |
| args); |
| } |
| { |
| v8::Local<v8::Function> add_on_message_listener = FunctionFromString( |
| context, base::StringPrintf(kOnMessageListenerTemplate, kPort2Message)); |
| v8::Local<v8::Value> args[] = { |
| port2->GetWrapper(isolate()).ToLocalChecked()}; |
| RunFunctionOnGlobal(add_on_message_listener, context, std::size(args), |
| args); |
| } |
| |
| // We've only added listeners (not dispatched any messages), so neither |
| // listener should have been triggered. |
| v8::Local<v8::Object> global = context->Global(); |
| EXPECT_EQ("undefined", |
| GetStringPropertyFromObject(global, context, kPort1Message)); |
| EXPECT_EQ("undefined", |
| GetStringPropertyFromObject(global, context, kPort2Message)); |
| |
| const char kMessageString[] = R"({"data":"hello"})"; |
| messaging_service()->DeliverMessage( |
| script_context_set(), port_id1, |
| Message(kMessageString, mojom::SerializationFormat::kJson, false), |
| nullptr); |
| |
| // Only port1 should have been notified of the message (ports only receive |
| // messages directed to themselves). |
| EXPECT_EQ(kMessageString, |
| GetStringPropertyFromObject(global, context, kPort1Message)); |
| EXPECT_EQ("undefined", |
| GetStringPropertyFromObject(global, context, kPort2Message)); |
| } |
| |
| TEST_F(NativeRendererMessagingServiceTest, DisconnectMessagePort) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| base::UnguessableToken other_context_id = base::UnguessableToken::Create(); |
| const PortId port_id1(other_context_id, 0, false, |
| mojom::SerializationFormat::kJson); |
| const PortId port_id2(other_context_id, 1, false, |
| mojom::SerializationFormat::kJson); |
| |
| mojo::PendingAssociatedRemote<mojom::MessagePort> message_port_remote1; |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| message_port_host_receiver1; |
| mojo::PendingAssociatedRemote<mojom::MessagePort> message_port_remote2; |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| message_port_host_receiver2; |
| GinPort* port1 = messaging_service()->CreatePortForTesting( |
| script_context(), "channel1", mojom::ChannelType::kSendMessage, port_id1, |
| message_port_remote1, message_port_host_receiver1); |
| GinPort* port2 = messaging_service()->CreatePortForTesting( |
| script_context(), "channel2", mojom::ChannelType::kSendMessage, port_id2, |
| message_port_remote2, message_port_host_receiver2); |
| message_port_remote1.EnableUnassociatedUsage(); |
| message_port_host_receiver1.EnableUnassociatedUsage(); |
| message_port_remote2.EnableUnassociatedUsage(); |
| message_port_host_receiver2.EnableUnassociatedUsage(); |
| |
| const char kOnDisconnectListenerTemplate[] = |
| "(function(port) {\n" |
| " port.onDisconnect.addListener(() => {\n" |
| " this.%s = true;\n" |
| " });\n" |
| "})"; |
| const char kPort1Disconnect[] = "port1Disconnect"; |
| const char kPort2Disconnect[] = "port2Disconnect"; |
| { |
| v8::Local<v8::Function> add_on_disconnect_listener = FunctionFromString( |
| context, |
| base::StringPrintf(kOnDisconnectListenerTemplate, kPort1Disconnect)); |
| v8::Local<v8::Value> args[] = {port1->GetWrapper(isolate()).ToLocalChecked()}; |
| RunFunctionOnGlobal(add_on_disconnect_listener, context, std::size(args), |
| args); |
| } |
| { |
| v8::Local<v8::Function> add_on_disconnect_listener = FunctionFromString( |
| context, |
| base::StringPrintf(kOnDisconnectListenerTemplate, kPort2Disconnect)); |
| v8::Local<v8::Value> args[] = {port2->GetWrapper(isolate()).ToLocalChecked()}; |
| RunFunctionOnGlobal(add_on_disconnect_listener, context, std::size(args), |
| args); |
| } |
| |
| v8::Local<v8::Object> global = context->Global(); |
| EXPECT_EQ("undefined", |
| GetStringPropertyFromObject(global, context, kPort1Disconnect)); |
| EXPECT_EQ("undefined", |
| GetStringPropertyFromObject(global, context, kPort2Disconnect)); |
| |
| messaging_service()->DispatchOnDisconnect(script_context_set(), port_id1, |
| std::string(), nullptr); |
| |
| EXPECT_EQ("true", |
| GetStringPropertyFromObject(global, context, kPort1Disconnect)); |
| EXPECT_EQ("undefined", |
| GetStringPropertyFromObject(global, context, kPort2Disconnect)); |
| } |
| |
| TEST_F(NativeRendererMessagingServiceTest, PostMessageFromJS) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| base::UnguessableToken other_context_id = base::UnguessableToken::Create(); |
| const PortId port_id(other_context_id, 0, false, |
| mojom::SerializationFormat::kJson); |
| |
| MockMessagePortHost mock_message_port_host; |
| mojo::PendingAssociatedRemote<mojom::MessagePort> message_port_remote; |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| message_port_host_receiver; |
| GinPort* port = messaging_service()->CreatePortForTesting( |
| script_context(), "channel", mojom::ChannelType::kSendMessage, port_id, |
| message_port_remote, message_port_host_receiver); |
| message_port_remote.EnableUnassociatedUsage(); |
| message_port_host_receiver.EnableUnassociatedUsage(); |
| mock_message_port_host.BindReceiver(std::move(message_port_host_receiver)); |
| v8::Local<v8::Object> port_object = port->GetWrapper(isolate()).ToLocalChecked(); |
| |
| const char kDispatchMessage[] = |
| "(function(port) {\n" |
| " port.postMessage({data: 'hello'});\n" |
| "})"; |
| v8::Local<v8::Function> post_message = |
| FunctionFromString(context, kDispatchMessage); |
| v8::Local<v8::Value> args[] = {port_object}; |
| |
| base::RunLoop run_loop; |
| EXPECT_CALL(mock_message_port_host, |
| PostMessage(Message(R"({"data":"hello"})", |
| mojom::SerializationFormat::kJson, false))) |
| .WillOnce(base::test::RunClosure(run_loop.QuitClosure())); |
| RunFunctionOnGlobal(post_message, context, std::size(args), args); |
| run_loop.Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| } |
| |
| TEST_F(NativeRendererMessagingServiceTest, DisconnectFromJS) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| base::UnguessableToken other_context_id = base::UnguessableToken::Create(); |
| const PortId port_id(other_context_id, 0, false, |
| mojom::SerializationFormat::kJson); |
| |
| MockMessagePortHost mock_message_port_host; |
| mojo::PendingAssociatedRemote<mojom::MessagePort> message_port_remote; |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| message_port_host_receiver; |
| GinPort* port = messaging_service()->CreatePortForTesting( |
| script_context(), "channel", mojom::ChannelType::kSendMessage, port_id, |
| message_port_remote, message_port_host_receiver); |
| message_port_remote.EnableUnassociatedUsage(); |
| message_port_host_receiver.EnableUnassociatedUsage(); |
| mock_message_port_host.BindReceiver(std::move(message_port_host_receiver)); |
| v8::Local<v8::Object> port_object = port->GetWrapper(isolate()).ToLocalChecked(); |
| |
| const char kDispatchMessage[] = |
| "(function(port) {\n" |
| " port.disconnect();\n" |
| "})"; |
| v8::Local<v8::Function> post_message = |
| FunctionFromString(context, kDispatchMessage); |
| v8::Local<v8::Value> args[] = {port_object}; |
| |
| base::RunLoop run_loop; |
| EXPECT_CALL(mock_message_port_host, |
| ClosePort( |
| /*close_channel=*/true, |
| /*error_message=*/testing::Eq(std::nullopt))) |
| .WillOnce(base::test::RunClosure(run_loop.QuitClosure())); |
| RunFunctionOnGlobal(post_message, context, std::size(args), args); |
| run_loop.Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| } |
| |
| TEST_F(NativeRendererMessagingServiceTest, Connect) { |
| v8::HandleScope handle_scope(isolate()); |
| |
| const std::string kChannel = "channel"; |
| PortId expected_port_id(script_context()->context_id(), 0, true, |
| mojom::SerializationFormat::kJson); |
| MessageTarget target(MessageTarget::ForExtension(extension()->id())); |
| EXPECT_CALL(*ipc_message_sender(), |
| SendOpenMessageChannel(script_context(), expected_port_id, target, |
| mojom::ChannelType::kConnect, kChannel, |
| testing::_, testing::_)); |
| GinPort* new_port = messaging_service()->Connect( |
| script_context(), target, "channel", mojom::SerializationFormat::kJson); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ASSERT_TRUE(new_port); |
| |
| EXPECT_EQ(expected_port_id, new_port->port_id()); |
| EXPECT_EQ(kChannel, new_port->name()); |
| EXPECT_FALSE(new_port->is_closed_for_testing()); |
| } |
| |
| // Tests sending a one-time message through the messaging service and getting a |
| // response to a callback. Note that this is more thoroughly tested in the |
| // OneTimeMessageHandler tests; this is just to ensure |
| // NativeRendererMessagingService correctly forwards the calls. |
| TEST_F(NativeRendererMessagingServiceTest, SendOneTimeMessageWithCallback) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| const mojom::ChannelType kChannel = mojom::ChannelType::kSendMessage; |
| PortId port_id(script_context()->context_id(), 0, true, |
| mojom::SerializationFormat::kJson); |
| const char kEchoArgs[] = |
| "(function() { this.replyArgs = Array.from(arguments); })"; |
| v8::Local<v8::Function> response_callback = |
| FunctionFromString(context, kEchoArgs); |
| |
| // Send a message and expect a reply to a passed in callback. A new port |
| // should be created, and should remain open until the response is sent. |
| const Message message("\"hi\"", mojom::SerializationFormat::kJson, false); |
| MessageTarget target(MessageTarget::ForExtension(extension()->id())); |
| MockMessagePortHost mock_message_port_host; |
| auto run_loop = std::make_unique<base::RunLoop>(); |
| EXPECT_CALL(*ipc_message_sender(), |
| SendOpenMessageChannel(script_context(), port_id, target, |
| kChannel, "chrome.runtime.sendMessage", |
| testing::_, testing::_)) |
| .WillOnce([&mock_message_port_host]( |
| ScriptContext* script_context, const PortId& port_id, |
| const MessageTarget& target, |
| mojom::ChannelType channel_type, |
| const std::string& channel_name, |
| mojo::PendingAssociatedRemote<mojom::MessagePort> port, |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| port_host) { |
| port.EnableUnassociatedUsage(); |
| port_host.EnableUnassociatedUsage(); |
| mock_message_port_host.BindReceiver(std::move(port_host)); |
| }); |
| EXPECT_CALL(mock_message_port_host, PostMessage(message)) |
| .WillOnce(base::test::RunClosure(run_loop->QuitClosure())); |
| |
| v8::Local<v8::Promise> promise = messaging_service()->SendOneTimeMessage( |
| script_context(), target, kChannel, message, |
| binding::AsyncResponseType::kCallback, response_callback); |
| // Since this is a callback based request, the returned promise should be |
| // empty. |
| EXPECT_TRUE(promise.IsEmpty()); |
| run_loop->Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| EXPECT_TRUE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| |
| run_loop = std::make_unique<base::RunLoop>(); |
| // Respond to the message. The response callback should be triggered, and the |
| // port should be closed. |
| EXPECT_CALL(mock_message_port_host, |
| ClosePort( |
| /*close_channel=*/true, |
| /*error_message=*/testing::Eq(std::nullopt))) |
| .WillOnce(base::test::RunClosure(run_loop->QuitClosure())); |
| messaging_service()->DeliverMessage( |
| script_context_set(), port_id, |
| Message("\"reply\"", mojom::SerializationFormat::kJson, false), nullptr); |
| run_loop->Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| EXPECT_EQ("[\"reply\"]", GetStringPropertyFromObject(context->Global(), |
| context, "replyArgs")); |
| EXPECT_FALSE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| } |
| |
| // Similar to the above test, tests sending a one-time message through the |
| // messaging service, but this time using a Promise for the response. |
| TEST_F(NativeRendererMessagingServiceTest, SendOneTimeMessageWithPromise) { |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| const mojom::ChannelType kChannel = mojom::ChannelType::kSendMessage; |
| PortId port_id(script_context()->context_id(), 0, true, |
| mojom::SerializationFormat::kJson); |
| |
| // Send a message and expect a reply fulfilling a promise. A new port should |
| // be created, and should remain open until the response is sent. |
| const Message message("\"hi\"", mojom::SerializationFormat::kJson, false); |
| MessageTarget target(MessageTarget::ForExtension(extension()->id())); |
| MockMessagePortHost mock_message_port_host; |
| auto run_loop = std::make_unique<base::RunLoop>(); |
| EXPECT_CALL(*ipc_message_sender(), |
| SendOpenMessageChannel(script_context(), port_id, target, |
| kChannel, "chrome.runtime.sendMessage", |
| testing::_, testing::_)) |
| .WillRepeatedly( |
| [&mock_message_port_host]( |
| ScriptContext* script_context, const PortId& port_id, |
| const MessageTarget& target, mojom::ChannelType channel_type, |
| const std::string& channel_name, |
| mojo::PendingAssociatedRemote<mojom::MessagePort> port, |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| port_host) { |
| port.EnableUnassociatedUsage(); |
| port_host.EnableUnassociatedUsage(); |
| mock_message_port_host.BindReceiver(std::move(port_host)); |
| }); |
| EXPECT_CALL(mock_message_port_host, PostMessage(message)) |
| .WillOnce(base::test::RunClosure(run_loop->QuitClosure())); |
| v8::Local<v8::Promise> promise = messaging_service()->SendOneTimeMessage( |
| script_context(), target, kChannel, message, |
| binding::AsyncResponseType::kPromise, v8::Local<v8::Function>()); |
| ASSERT_FALSE(promise.IsEmpty()); |
| EXPECT_EQ(v8::Promise::kPending, promise->State()); |
| run_loop->Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| EXPECT_TRUE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| |
| run_loop = std::make_unique<base::RunLoop>(); |
| // Respond to the message. The response callback should be triggered, and the |
| // port should be closed. |
| EXPECT_CALL(mock_message_port_host, |
| ClosePort( |
| /*close_channel=*/true, |
| /*error_message=*/testing::Eq(std::nullopt))) |
| .WillOnce(base::test::RunClosure(run_loop->QuitClosure())); |
| messaging_service()->DeliverMessage( |
| script_context_set(), port_id, |
| Message("\"reply\"", mojom::SerializationFormat::kJson, false), nullptr); |
| run_loop->Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| EXPECT_EQ(v8::Promise::kFulfilled, promise->State()); |
| EXPECT_EQ("\"reply\"", V8ToString(promise->Result(), context)); |
| EXPECT_FALSE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| } |
| |
| // Tests receiving a one-time message through the messaging service. Note that |
| // this is more thoroughly tested in the OneTimeMessageHandler tests; this is |
| // just to ensure NativeRendererMessagingService correctly forwards the calls. |
| TEST_F(NativeRendererMessagingServiceTest, ReceiveOneTimeMessage) { |
| RuntimeMessageValidationIgnorer message_validation_ignorer; |
| |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| constexpr char kRegisterListener[] = |
| "(function() {\n" |
| " chrome.runtime.onMessage.addListener(\n" |
| " function(message, sender, reply) {\n" |
| " this.eventMessage = message;\n" |
| " reply({data: 'hi'});\n" |
| " });\n" |
| "})"; |
| v8::Local<v8::Function> add_listener = |
| FunctionFromString(context, kRegisterListener); |
| RunFunctionOnGlobal(add_listener, context, 0, nullptr); |
| |
| const std::string kChannel = "chrome.runtime.sendMessage"; |
| base::UnguessableToken other_context_id = base::UnguessableToken::Create(); |
| const PortId port_id(other_context_id, 0, false, |
| mojom::SerializationFormat::kJson); |
| |
| NativeRendererMessagingService::TabConnectionInfo tab_connection_info; |
| NativeRendererMessagingService::ExternalConnectionInfo |
| external_connection_info; |
| tab_connection_info.frame_id = 0; |
| const int tab_id = 10; |
| GURL source_url("http://example.com"); |
| tab_connection_info.tab = base::Value::Dict().Set("tabId", tab_id); |
| external_connection_info.target_id = extension()->id(); |
| external_connection_info.source_endpoint = |
| MessagingEndpoint::ForExtension(extension()->id()); |
| external_connection_info.source_url = source_url; |
| external_connection_info.guest_process_id = |
| content::kInvalidChildProcessUniqueId; |
| external_connection_info.guest_render_frame_routing_id = 0; |
| |
| mojo::PendingAssociatedRemote<mojom::MessagePortHost> port_host_remote; |
| auto port_host_receiver = |
| port_host_remote.InitWithNewEndpointAndPassReceiver(); |
| |
| mojo::PendingAssociatedReceiver<mojom::MessagePort> port_receiver; |
| auto port_remote = port_receiver.InitWithNewEndpointAndPassRemote(); |
| |
| // Open a receiver for the message. |
| bool port_opened = false; |
| MockMessagePortHost mock_message_port_host; |
| messaging_service()->DispatchOnConnect( |
| script_context_set(), port_id, mojom::ChannelType::kSendMessage, kChannel, |
| tab_connection_info, external_connection_info, std::move(port_receiver), |
| std::move(port_host_remote), nullptr, |
| base::BindLambdaForTesting( |
| [&port_opened](bool success) { port_opened = success; })); |
| port_remote.EnableUnassociatedUsage(); |
| port_host_receiver.EnableUnassociatedUsage(); |
| mock_message_port_host.BindReceiver(std::move(port_host_receiver)); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| EXPECT_TRUE(port_opened); |
| EXPECT_TRUE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| |
| base::RunLoop run_loop; |
| // Post the message to the receiver. The receiver should respond, and the |
| // port should close. |
| EXPECT_CALL(mock_message_port_host, |
| PostMessage(Message(R"({"data":"hi"})", |
| mojom::SerializationFormat::kJson, false))); |
| EXPECT_CALL(mock_message_port_host, |
| ClosePort( |
| /*close_channel=*/true, |
| /*error_message=*/testing::Eq(std::nullopt))) |
| .WillOnce(base::test::RunClosure(run_loop.QuitClosure())); |
| messaging_service()->DeliverMessage( |
| script_context_set(), port_id, |
| Message("\"message\"", mojom::SerializationFormat::kJson, false), |
| nullptr); |
| run_loop.Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| EXPECT_FALSE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| } |
| |
| // Test sending a one-time message from an external source (e.g., a different |
| // extension). This shouldn't conflict with messages sent from the same source. |
| TEST_F(NativeRendererMessagingServiceTest, TestExternalOneTimeMessages) { |
| RuntimeMessageValidationIgnorer message_validation_ignorer; |
| |
| v8::HandleScope handle_scope(isolate()); |
| v8::Local<v8::Context> context = MainContext(); |
| |
| constexpr char kListeners[] = |
| R"((function() { |
| chrome.runtime.onMessage.addListener((message) => { |
| this.onMessageReceived = message; |
| return true; // Keep the channel open. |
| }); |
| chrome.runtime.onMessageExternal.addListener((message) => { |
| this.onMessageExternalReceived = message; |
| return true; // Keep the channel open. |
| }); |
| }))"; |
| |
| v8::Local<v8::Function> add_listener = |
| FunctionFromString(context, kListeners); |
| RunFunctionOnGlobal(add_listener, context, 0, nullptr); |
| |
| base::UnguessableToken other_context_id = base::UnguessableToken::Create(); |
| int next_port_id = 0; |
| const PortId on_message_port_id(other_context_id, ++next_port_id, false, |
| mojom::SerializationFormat::kJson); |
| const PortId on_message_external_port_id(other_context_id, ++next_port_id, |
| false, |
| mojom::SerializationFormat::kJson); |
| |
| auto open_port = |
| [this](const PortId& port_id, const ExtensionId& source_id, |
| mojo::PendingAssociatedRemote<mojom::MessagePort>& port_remote, |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost>& |
| port_host_receiver) { |
| NativeRendererMessagingService::TabConnectionInfo tab_connection_info; |
| NativeRendererMessagingService::ExternalConnectionInfo |
| external_connection_info; |
| tab_connection_info.frame_id = 0; |
| const int tab_id = 10; |
| GURL source_url("http://example.com"); |
| tab_connection_info.tab = base::Value::Dict().Set("tabId", tab_id); |
| |
| external_connection_info.target_id = extension()->id(); |
| external_connection_info.source_endpoint = |
| MessagingEndpoint::ForExtension(source_id); |
| external_connection_info.source_url = source_url; |
| external_connection_info.guest_process_id = |
| content::kInvalidChildProcessUniqueId; |
| external_connection_info.guest_render_frame_routing_id = 0; |
| |
| auto port_host_remote = |
| port_host_receiver.InitWithNewEndpointAndPassRemote(); |
| auto port_receiver = port_remote.InitWithNewEndpointAndPassReceiver(); |
| bool port_opened = false; |
| |
| // Open a receiver for the message. |
| messaging_service()->DispatchOnConnect( |
| script_context_set(), port_id, mojom::ChannelType::kSendMessage, |
| messaging_util::kSendMessageChannel, tab_connection_info, |
| external_connection_info, std::move(port_receiver), |
| std::move(port_host_remote), nullptr, |
| base::BindLambdaForTesting( |
| [&port_opened](bool success) { port_opened = success; })); |
| port_remote.EnableUnassociatedUsage(); |
| port_host_receiver.EnableUnassociatedUsage(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| EXPECT_TRUE(port_opened); |
| EXPECT_TRUE( |
| messaging_service()->HasPortForTesting(script_context(), port_id)); |
| }; |
| |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> port_host_receiver; |
| mojo::PendingAssociatedRemote<mojom::MessagePort> port_remote; |
| |
| open_port(on_message_port_id, extension()->id(), port_remote, |
| port_host_receiver); |
| |
| mojo::PendingAssociatedReceiver<mojom::MessagePortHost> |
| other_port_host_receiver; |
| mojo::PendingAssociatedRemote<mojom::MessagePort> other_port_remote; |
| const ExtensionId other_extension = |
| crx_file::id_util::GenerateId("different"); |
| open_port(on_message_external_port_id, other_extension, other_port_remote, |
| other_port_host_receiver); |
| |
| base::RunLoop run_loop; |
| MockMessagePortHost mock_message_port_host; |
| mock_message_port_host.BindReceiver(std::move(port_host_receiver)); |
| EXPECT_CALL(mock_message_port_host, ResponsePending()) |
| .WillOnce(base::test::RunClosure(run_loop.QuitClosure())); |
| messaging_service()->DeliverMessage( |
| script_context_set(), on_message_port_id, |
| Message("\"onMessage\"", mojom::SerializationFormat::kJson, false), |
| nullptr); |
| EXPECT_EQ("\"onMessage\"", |
| GetStringPropertyFromObject(context->Global(), context, |
| "onMessageReceived")); |
| EXPECT_EQ("undefined", |
| GetStringPropertyFromObject(context->Global(), context, |
| "onMessageExternalReceived")); |
| run_loop.Run(); |
| ::testing::Mock::VerifyAndClearExpectations(ipc_message_sender()); |
| ::testing::Mock::VerifyAndClearExpectations(&mock_message_port_host); |
| messaging_service()->DeliverMessage( |
| script_context_set(), on_message_external_port_id, |
| Message("\"onMessageExternal\"", mojom::SerializationFormat::kJson, |
| false), |
| nullptr); |
| EXPECT_EQ("\"onMessage\"", |
| GetStringPropertyFromObject(context->Global(), context, |
| "onMessageReceived")); |
| EXPECT_EQ("\"onMessageExternal\"", |
| GetStringPropertyFromObject(context->Global(), context, |
| "onMessageExternalReceived")); |
| } |
| |
| } // namespace extensions |
