message_port.cc 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383
  1. // Copyright 2019 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "fuchsia_web/webengine/browser/message_port.h"
  5. #include <fuchsia/mem/cpp/fidl.h>
  6. #include <lib/fidl/cpp/binding.h>
  7. #include <lib/fit/function.h>
  8. #include <lib/fpromise/result.h>
  9. #include <stdint.h>
  10. #include <memory>
  11. #include <string>
  12. #include <utility>
  13. #include <vector>
  14. #include "base/bind.h"
  15. #include "base/check.h"
  16. #include "base/containers/circular_deque.h"
  17. #include "base/fuchsia/fuchsia_logging.h"
  18. #include "base/fuchsia/mem_buffer_util.h"
  19. #include "base/stl_util.h"
  20. #include "base/strings/utf_string_conversions.h"
  21. namespace {
  22. using BlinkMessage = blink::WebMessagePort::Message;
  23. // Converts a fuchsia::web::WebMessage to a BlinkMessage.
  24. // An empty result indicates that conversion was successful.
  25. // Data validation errors are returned as a FrameError.
  26. absl::optional<fuchsia::web::FrameError> BlinkMessageFromFidl(
  27. fuchsia::web::WebMessage fidl_message,
  28. BlinkMessage* blink_message) {
  29. if (!fidl_message.has_data()) {
  30. return fuchsia::web::FrameError::NO_DATA_IN_MESSAGE;
  31. }
  32. absl::optional<std::u16string> data_utf16 =
  33. base::ReadUTF8FromVMOAsUTF16(fidl_message.data());
  34. if (!data_utf16) {
  35. return fuchsia::web::FrameError::BUFFER_NOT_UTF8;
  36. }
  37. blink_message->data = std::move(*data_utf16);
  38. if (fidl_message.has_outgoing_transfer() &&
  39. fidl_message.has_incoming_transfer()) {
  40. DLOG(WARNING) << "WebMessage may only have incoming or outgoing transfer.";
  41. return fuchsia::web::FrameError::INTERNAL_ERROR;
  42. }
  43. if (fidl_message.has_outgoing_transfer()) {
  44. for (fuchsia::web::OutgoingTransferable& transferrable :
  45. *fidl_message.mutable_outgoing_transfer()) {
  46. if (!transferrable.is_message_port())
  47. return fuchsia::web::FrameError::INTERNAL_ERROR;
  48. blink_message->ports.push_back(
  49. BlinkMessagePortFromFidl(std::move(transferrable.message_port())));
  50. }
  51. } else if (fidl_message.has_incoming_transfer()) {
  52. for (fuchsia::web::IncomingTransferable& transferrable :
  53. *fidl_message.mutable_incoming_transfer()) {
  54. if (!transferrable.is_message_port())
  55. return fuchsia::web::FrameError::INTERNAL_ERROR;
  56. blink_message->ports.push_back(
  57. BlinkMessagePortFromFidl(std::move(transferrable.message_port())));
  58. }
  59. }
  60. return absl::nullopt;
  61. }
  62. // Defines a MessagePortAdapter, which translates and routes messages between a
  63. // FIDL MessagePort and a blink::WebMessagePort. Every MessagePortAdapter has
  64. // exactly one FIDL MessagePort and one blink::WebMessagePort.
  65. //
  66. // MessagePortAdapter instances are self-managed; they destroy themselves when
  67. // the connection is terminated from either the Blink or FIDL side.
  68. class MessagePortAdapter : public blink::WebMessagePort::MessageReceiver {
  69. public:
  70. MessagePortAdapter(const MessagePortAdapter&) = delete;
  71. MessagePortAdapter& operator=(const MessagePortAdapter&) = delete;
  72. protected:
  73. explicit MessagePortAdapter(blink::WebMessagePort blink_port)
  74. : blink_port_(std::move(blink_port)) {
  75. blink_port_.SetReceiver(this, base::ThreadTaskRunnerHandle::Get());
  76. }
  77. ~MessagePortAdapter() override = default;
  78. // Deletes |this|, implicitly disconnecting the FIDL and Blink ports.
  79. void Destroy() { delete this; }
  80. // Sends a message to |blink_port_|.
  81. void SendBlinkMessage(BlinkMessage message) {
  82. CHECK(blink_port_.PostMessage(std::move(message)));
  83. }
  84. // Called when a Blink message was received through |blink_port_|.
  85. virtual void DeliverMessageToFidl() = 0;
  86. // Returns the next messagefrom Blink, or an empty value if there
  87. // are no more messages in the incoming queue.
  88. absl::optional<fuchsia::web::WebMessage> GetNextBlinkMessage() {
  89. if (message_queue_.empty())
  90. return absl::nullopt;
  91. return std::move(message_queue_.front());
  92. }
  93. void OnDeliverMessageToFidlComplete() {
  94. DCHECK(!message_queue_.empty());
  95. message_queue_.pop_front();
  96. }
  97. private:
  98. // blink::WebMessagePort::MessageReceiver implementation:
  99. bool OnMessage(BlinkMessage message) override {
  100. absl::optional<fuchsia::web::WebMessage> message_converted =
  101. FidlWebMessageFromBlink(std::move(message),
  102. TransferableHostType::kLocal);
  103. if (!message_converted) {
  104. DLOG(ERROR) << "Couldn't decode WebMessage from blink::WebMessagePort.";
  105. Destroy();
  106. return false;
  107. }
  108. message_queue_.emplace_back(std::move(*message_converted));
  109. // Start draining the queue if it was empty beforehand.
  110. if (message_queue_.size() == 1u)
  111. DeliverMessageToFidl();
  112. return true;
  113. }
  114. // blink::WebMessagePort::MessageReceiver implementation:
  115. void OnPipeError() override { Destroy(); }
  116. base::circular_deque<fuchsia::web::WebMessage> message_queue_;
  117. blink::WebMessagePort blink_port_;
  118. };
  119. // Binds a handle to a remote MessagePort to a blink::WebMessagePort.
  120. class FidlMessagePortClientAdapter : public MessagePortAdapter {
  121. public:
  122. FidlMessagePortClientAdapter(
  123. blink::WebMessagePort blink_port,
  124. fidl::InterfaceHandle<fuchsia::web::MessagePort> fidl_port)
  125. : MessagePortAdapter(std::move(blink_port)), port_(fidl_port.Bind()) {
  126. ReadMessageFromFidl();
  127. port_.set_error_handler([this](zx_status_t status) {
  128. ZX_LOG_IF(ERROR,
  129. status != ZX_ERR_PEER_CLOSED && status != ZX_ERR_CANCELED,
  130. status)
  131. << " MessagePort disconnected.";
  132. Destroy();
  133. });
  134. }
  135. FidlMessagePortClientAdapter(const FidlMessagePortClientAdapter&) = delete;
  136. FidlMessagePortClientAdapter& operator=(const FidlMessagePortClientAdapter&) =
  137. delete;
  138. fidl::InterfaceRequest<fuchsia::web::MessagePort> NewRequest() {
  139. return port_.NewRequest();
  140. }
  141. private:
  142. ~FidlMessagePortClientAdapter() override = default;
  143. void ReadMessageFromFidl() {
  144. port_->ReceiveMessage(fit::bind_member(
  145. this, &FidlMessagePortClientAdapter::OnMessageReceived));
  146. }
  147. void OnMessageReceived(fuchsia::web::WebMessage message) {
  148. BlinkMessage blink_message;
  149. absl::optional<fuchsia::web::FrameError> result =
  150. BlinkMessageFromFidl(std::move(message), &blink_message);
  151. if (result) {
  152. LOG(WARNING) << "Received bad message, error: "
  153. << static_cast<int32_t>(*result);
  154. Destroy();
  155. return;
  156. }
  157. SendBlinkMessage(std::move(blink_message));
  158. ReadMessageFromFidl();
  159. }
  160. void OnMessagePosted(fuchsia::web::MessagePort_PostMessage_Result result) {
  161. if (result.is_err()) {
  162. LOG(ERROR) << "PostMessage failed, reason: "
  163. << static_cast<int32_t>(result.err());
  164. Destroy();
  165. return;
  166. }
  167. DeliverMessageToFidl();
  168. }
  169. // MessagePortAdapter implementation.
  170. void DeliverMessageToFidl() override {
  171. absl::optional<fuchsia::web::WebMessage> message = GetNextBlinkMessage();
  172. if (!message)
  173. return;
  174. port_->PostMessage(
  175. std::move(*message),
  176. fit::bind_member(this, &FidlMessagePortClientAdapter::OnMessagePosted));
  177. OnDeliverMessageToFidlComplete();
  178. }
  179. fuchsia::web::MessagePortPtr port_;
  180. };
  181. // Binds a MessagePort FIDL service from a blink::WebMessagePort.
  182. class FidlMessagePortServerAdapter : public fuchsia::web::MessagePort,
  183. public MessagePortAdapter {
  184. public:
  185. explicit FidlMessagePortServerAdapter(blink::WebMessagePort blink_port)
  186. : MessagePortAdapter(std::move(blink_port)), binding_(this) {
  187. binding_.set_error_handler([this](zx_status_t status) {
  188. ZX_LOG_IF(ERROR,
  189. status != ZX_ERR_PEER_CLOSED && status != ZX_ERR_CANCELED,
  190. status)
  191. << " MessagePort disconnected.";
  192. Destroy();
  193. });
  194. }
  195. FidlMessagePortServerAdapter(
  196. blink::WebMessagePort blink_port,
  197. fidl::InterfaceRequest<fuchsia::web::MessagePort> request)
  198. : FidlMessagePortServerAdapter(std::move(blink_port)) {
  199. binding_.Bind(std::move(request));
  200. }
  201. FidlMessagePortServerAdapter(const FidlMessagePortServerAdapter&) = delete;
  202. FidlMessagePortServerAdapter& operator=(const FidlMessagePortServerAdapter&) =
  203. delete;
  204. fidl::InterfaceHandle<fuchsia::web::MessagePort> NewBinding() {
  205. return binding_.NewBinding();
  206. }
  207. private:
  208. ~FidlMessagePortServerAdapter() override = default;
  209. // MessagePortAdapter implementation.
  210. void DeliverMessageToFidl() override {
  211. // Do nothing if the client hasn't requested a read, or if there's nothing
  212. // to read.
  213. if (!pending_receive_message_callback_)
  214. return;
  215. absl::optional<fuchsia::web::WebMessage> message = GetNextBlinkMessage();
  216. if (!message)
  217. return;
  218. pending_receive_message_callback_(std::move(*message));
  219. pending_receive_message_callback_ = {};
  220. OnDeliverMessageToFidlComplete();
  221. }
  222. // fuchsia::web::MessagePort implementation.
  223. void PostMessage(fuchsia::web::WebMessage message,
  224. PostMessageCallback callback) override {
  225. BlinkMessage blink_message;
  226. absl::optional<fuchsia::web::FrameError> status =
  227. BlinkMessageFromFidl(std::move(message), &blink_message);
  228. if (status) {
  229. LOG(ERROR) << "Error when reading message from FIDL: "
  230. << static_cast<int32_t>(*status);
  231. Destroy();
  232. return;
  233. }
  234. SendBlinkMessage(std::move(blink_message));
  235. callback(fpromise::ok());
  236. }
  237. void ReceiveMessage(ReceiveMessageCallback callback) override {
  238. if (pending_receive_message_callback_) {
  239. LOG(WARNING)
  240. << "ReceiveMessage called multiple times without acknowledgement.";
  241. Destroy();
  242. return;
  243. }
  244. pending_receive_message_callback_ = std::move(callback);
  245. DeliverMessageToFidl();
  246. }
  247. PostMessageCallback post_message_ack_;
  248. ReceiveMessageCallback pending_receive_message_callback_;
  249. fidl::Binding<fuchsia::web::MessagePort> binding_;
  250. };
  251. fidl::InterfaceRequest<fuchsia::web::MessagePort>
  252. RemoteFidlMessagePortFromBlink(blink::WebMessagePort blink_port) {
  253. fidl::InterfaceHandle<fuchsia::web::MessagePort> fidl_handle;
  254. auto request = fidl_handle.NewRequest();
  255. new FidlMessagePortClientAdapter(std::move(blink_port),
  256. std::move(fidl_handle));
  257. return request;
  258. }
  259. } // namespace
  260. // Methods for constructing MessagePortAdapters for various port types and
  261. // origins. The adapters manage their own lifetimes and will self-delete when
  262. // either endpoint of their channels are disconnected.
  263. blink::WebMessagePort BlinkMessagePortFromFidl(
  264. fidl::InterfaceRequest<fuchsia::web::MessagePort> fidl_port) {
  265. auto port_pair = blink::WebMessagePort::CreatePair();
  266. new FidlMessagePortServerAdapter(std::move(port_pair.first),
  267. std::move(fidl_port));
  268. return std::move(port_pair.second);
  269. }
  270. blink::WebMessagePort BlinkMessagePortFromFidl(
  271. fidl::InterfaceHandle<fuchsia::web::MessagePort> fidl_port) {
  272. auto port_pair = blink::WebMessagePort::CreatePair();
  273. new FidlMessagePortClientAdapter(std::move(port_pair.first),
  274. std::move(fidl_port));
  275. return std::move(port_pair.second);
  276. }
  277. fidl::InterfaceHandle<fuchsia::web::MessagePort> FidlMessagePortFromBlink(
  278. blink::WebMessagePort blink_port) {
  279. auto* adapter = new FidlMessagePortServerAdapter(std::move(blink_port));
  280. return adapter->NewBinding();
  281. }
  282. absl::optional<fuchsia::web::WebMessage> FidlWebMessageFromBlink(
  283. BlinkMessage blink_message,
  284. TransferableHostType port_type) {
  285. fuchsia::web::WebMessage fidl_message;
  286. if (!blink_message.ports.empty()) {
  287. switch (port_type) {
  288. case TransferableHostType::kLocal:
  289. for (blink::WebMessagePort& port : blink_message.ports) {
  290. fuchsia::web::IncomingTransferable incoming;
  291. incoming.set_message_port(FidlMessagePortFromBlink(std::move(port)));
  292. fidl_message.mutable_incoming_transfer()->push_back(
  293. std::move(incoming));
  294. }
  295. break;
  296. case TransferableHostType::kRemote:
  297. for (blink::WebMessagePort& port : blink_message.ports) {
  298. fuchsia::web::OutgoingTransferable outgoing;
  299. outgoing.set_message_port(
  300. RemoteFidlMessagePortFromBlink(std::move(port)));
  301. fidl_message.mutable_outgoing_transfer()->push_back(
  302. std::move(outgoing));
  303. }
  304. break;
  305. }
  306. blink_message.ports.clear();
  307. }
  308. std::u16string data_utf16 = std::move(blink_message.data);
  309. std::string data_utf8;
  310. if (!base::UTF16ToUTF8(data_utf16.data(), data_utf16.size(), &data_utf8))
  311. return absl::nullopt;
  312. base::STLClearObject(&data_utf16);
  313. constexpr char kBufferVmoName[] = "cr-web-message-from-blink";
  314. fuchsia::mem::Buffer data_buffer =
  315. base::MemBufferFromString(data_utf8, kBufferVmoName);
  316. if (!data_buffer.vmo)
  317. return absl::nullopt;
  318. fidl_message.set_data(std::move(data_buffer));
  319. return fidl_message;
  320. }