blink_message_port_adapter.cc 8.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187
  1. // Copyright 2021 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 "components/cast/message_port/blink_message_port_adapter.h"
  5. #include "base/callback.h"
  6. #include "base/memory/raw_ptr.h"
  7. #include "components/cast/message_port/cast/message_port_cast.h"
  8. #include "components/cast/message_port/platform_message_port.h"
  9. namespace cast_api_bindings {
  10. namespace {
  11. // MessagePortAdapters are used to adapt between two different implementations
  12. // of cast_api_bindings::MessagePort.
  13. //
  14. // PostMessageWithTransferables flow including adaptation:
  15. //+---+ +-------+ +---------+ +---------+ +-------+ +---+
  16. //| A | | PortA | | AdptrA | | AdptrB | | PortB | | B |
  17. //+---+ +-------+ +---------+ +---------+ +-------+ +---+
  18. // | Post | | | | |
  19. // |---------->| | | | |
  20. // | | OnMsg | | | |
  21. // | |------------>| | | |
  22. // | | | Adapt Ports | | |
  23. // | | |-----------| | | |
  24. // | | |<----------| | | |
  25. // | | | Post | | |
  26. // | | |----------------->| | |
  27. // | | | | OnMsg | |
  28. // | | | |----------->| |
  29. // | | | | | OnMsg |
  30. // | | | | |-------->|
  31. //
  32. // Error flow including deletion, for example when OnMessage fails
  33. // | | | | | false |
  34. // | | | | |<--------|
  35. // | | | | OnErr | |
  36. // | | | |<-----------| |
  37. // | | | delete | | |
  38. // | | |<-----------------| | |
  39. // | | delete | | | |
  40. // | |<------------| | | |
  41. // | OnErr | | | | |
  42. // |<----------| | | | |
  43. // | | | | delete | |
  44. // | | | |------| | |
  45. // | | | |<-----| | |
  46. class MessagePortAdapter : public MessagePort::Receiver {
  47. public:
  48. using CreatePairRepeatingCallback =
  49. base::RepeatingCallback<void(std::unique_ptr<MessagePort>*,
  50. std::unique_ptr<MessagePort>*)>;
  51. // PortType is used to track whether the held port represents a client or a
  52. // server port. Clients must respect client and server semantics because some
  53. // platforms have asymmetric port implementations.
  54. enum class PortType {
  55. CLIENT = 1,
  56. SERVER = 2,
  57. };
  58. // Two MessagePortAdapters are used to adapt between their respective
  59. // |port|s. Some implementations are directional, so |port_type| is used
  60. // determine how the |create_pair| function should be invoked when
  61. // adapting transferred ports. The adapter pair manages its own lifetime
  62. // and is destroyed on error.
  63. MessagePortAdapter(std::unique_ptr<MessagePort> port,
  64. PortType port_type,
  65. CreatePairRepeatingCallback create_pair_cb)
  66. : port_(std::move(port)),
  67. port_type_(port_type),
  68. create_pair_cb_(create_pair_cb) {
  69. DCHECK(port_);
  70. port_->SetReceiver(this);
  71. }
  72. ~MessagePortAdapter() override = default;
  73. MessagePortAdapter(const MessagePortAdapter&) = delete;
  74. MessagePortAdapter(MessagePortAdapter&&) = delete;
  75. // Pairs the port with a |peer|. Their lifetimes will be the same.
  76. void SetPeer(MessagePortAdapter* peer) {
  77. DCHECK(peer);
  78. peer_ = peer;
  79. }
  80. // Invokes |create_pair_|, which should create a new pair of ports with the
  81. // same type as |port_|.
  82. void CreatePair(std::unique_ptr<MessagePort>* client,
  83. std::unique_ptr<MessagePort>* server) {
  84. create_pair_cb_.Run(client, server);
  85. }
  86. private:
  87. // MessagePort::Receiver implementation:
  88. void OnPipeError() override {
  89. DCHECK(peer_);
  90. // Ports are closed on error; when an error occurs, destroy the adapters.
  91. delete peer_;
  92. delete this;
  93. }
  94. bool OnMessage(base::StringPiece message,
  95. std::vector<std::unique_ptr<MessagePort>> ports) override {
  96. DCHECK(peer_);
  97. std::vector<std::unique_ptr<MessagePort>> transferables;
  98. // Because we are adapting port types, an adapter to the peer's type is
  99. // needed for each transferred port.
  100. for (auto& port : ports) {
  101. // The incoming |port| is the same kind of port as |this|.
  102. MessagePortAdapter* incoming =
  103. new MessagePortAdapter(std::move(port), port_type_, create_pair_cb_);
  104. // The outgoing port is the same kind of port as |peer_|.
  105. std::unique_ptr<MessagePort> client;
  106. std::unique_ptr<MessagePort> server;
  107. peer_->CreatePair(&client, &server);
  108. // If |incoming| is a client port adapter, it will be talking to a
  109. // |server| of the port type of the |peer_|, and vice versa.
  110. MessagePortAdapter* outgoing = new MessagePortAdapter(
  111. incoming->port_type_ == PortType::CLIENT ? std::move(server)
  112. : std::move(client),
  113. peer_->port_type_, peer_->create_pair_cb_);
  114. // Connect the adapters together.
  115. incoming->SetPeer(outgoing);
  116. outgoing->SetPeer(incoming);
  117. // If |incoming| is a client port adapter, the |client| port of the
  118. // |peer_| type will be transferred, and vice versa.
  119. // |server| of the port type of the |peer_|, and vice versa.
  120. transferables.push_back(port_type_ == PortType::CLIENT
  121. ? std::move(client)
  122. : std::move(server));
  123. }
  124. return peer_->port_->PostMessageWithTransferables(message,
  125. std::move(transferables));
  126. }
  127. std::unique_ptr<MessagePort> port_;
  128. raw_ptr<MessagePortAdapter> peer_ = nullptr;
  129. const PortType port_type_;
  130. const CreatePairRepeatingCallback create_pair_cb_;
  131. };
  132. } // namespace
  133. // static
  134. std::unique_ptr<MessagePort>
  135. BlinkMessagePortAdapter::ToClientPlatformMessagePort(
  136. blink::WebMessagePort&& client) {
  137. MessagePortAdapter* blink =
  138. new MessagePortAdapter(MessagePortCast::Create(std::move(client)),
  139. MessagePortAdapter::PortType::CLIENT,
  140. base::BindRepeating(&MessagePortCast::CreatePair));
  141. std::unique_ptr<MessagePort> adapted_client;
  142. std::unique_ptr<MessagePort> server;
  143. CreatePlatformMessagePortPair(&adapted_client, &server);
  144. MessagePortAdapter* platform = new MessagePortAdapter(
  145. std::move(server), MessagePortAdapter::PortType::SERVER,
  146. base::BindRepeating(&CreatePlatformMessagePortPair));
  147. blink->SetPeer(platform);
  148. platform->SetPeer(blink);
  149. return adapted_client;
  150. }
  151. // static
  152. blink::WebMessagePort BlinkMessagePortAdapter::FromServerPlatformMessagePort(
  153. std::unique_ptr<MessagePort> server) {
  154. MessagePortAdapter* platform = new MessagePortAdapter(
  155. std::move(server), MessagePortAdapter::PortType::SERVER,
  156. base::BindRepeating(&CreatePlatformMessagePortPair));
  157. std::unique_ptr<MessagePort> client;
  158. std::unique_ptr<MessagePort> adapted_server;
  159. MessagePortCast::CreatePair(&client, &adapted_server);
  160. MessagePortAdapter* blink = new MessagePortAdapter(
  161. std::move(client), MessagePortAdapter::PortType::CLIENT,
  162. base::BindRepeating(&MessagePortCast::CreatePair));
  163. blink->SetPeer(platform);
  164. platform->SetPeer(blink);
  165. return MessagePortCast::FromMessagePort(adapted_server.get())->TakePort();
  166. }
  167. } // namespace cast_api_bindings