[Cast] Migrate chromecast code to use blink::WebMessagePort.

This migrates all of the code in chromecast/ to use
blink::WebMessagePort instead of directly manipulating
Mojo pipes, and manually encoding messages. It preserves the
existing APIs so that downstream dependents can migrate. A
further CL will rip out the deprecated API.

BUG=803242

Change-Id: I6f3b03dd982e4093804a63f8ad6086f14c2b58b8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2028148
Commit-Queue: Chris Hamilton <chrisha@chromium.org>
Reviewed-by: Sean Topping <seantopping@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Wez <wez@chromium.org>
Cr-Commit-Position: refs/heads/master@{#737043}

chromecast/bindings/BUILD.gn

@@ -26,7 +26,11 @@ source_set("bindings_manager") {
     "bindings_manager.cc",
     "bindings_manager.h",
   ]
-  deps = [ "//base" ]
+  deps = [
+    "//base",
+    "//third_party/blink/public/common",
+    "//third_party/blink/public/common:headers",
+  ]
   public_deps = [ "//mojo/public/cpp/bindings" ]
 }
 

chromecast/bindings/bindings_manager.cc

@@ -15,8 +15,19 @@ BindingsManager::~BindingsManager() {
   DCHECK(port_handlers_.empty());
 }
 
+// TODO(crbug.com/803242): Deprecated and will be shortly removed.
 void BindingsManager::RegisterPortHandler(base::StringPiece port_name,
                                           PortConnectedHandler handler) {
+  MessagePortConnectedHandler wrapped_handler = base::BindRepeating(
+      [](PortConnectedHandler handler, blink::WebMessagePort port) {
+        handler.Run(port.PassHandle());
+      },
+      handler);
+  RegisterPortHandler(port_name, wrapped_handler);
+}
+
+void BindingsManager::RegisterPortHandler(base::StringPiece port_name,
+                                          MessagePortConnectedHandler handler) {
   auto result = port_handlers_.try_emplace(port_name, std::move(handler));
   DCHECK(result.second);
 }
@@ -26,8 +37,14 @@ void BindingsManager::UnregisterPortHandler(base::StringPiece port_name) {
   DCHECK_EQ(deleted, 1u);
 }
 
+// TODO(crbug.com/803242): Deprecated and will be shortly removed.
 void BindingsManager::OnPortConnected(base::StringPiece port_name,
                                       mojo::ScopedMessagePipeHandle port) {
+  OnPortConnected(port_name, blink::WebMessagePort::Create(std::move(port)));
+}
+
+void BindingsManager::OnPortConnected(base::StringPiece port_name,
+                                      blink::WebMessagePort port) {
   auto handler = port_handlers_.find(port_name);
   if (handler == port_handlers_.end()) {
     LOG(ERROR) << "No handler found for port " << port_name << ".";

chromecast/bindings/bindings_manager.h

@@ -12,6 +12,7 @@
 #include "base/containers/flat_map.h"
 #include "base/strings/string_piece.h"
 #include "mojo/public/cpp/system/message_pipe.h"
+#include "third_party/blink/public/common/messaging/web_message_port.h"
 
 namespace chromecast {
 namespace bindings {
@@ -19,10 +20,15 @@ namespace bindings {
 // Injects Cast Platform API scripts into pages' scripting context and
 // establishes bidirectional communication with them across the JS/native
 // boundary.
+// TODO(crbug.com/803242): Deprecated and will be shortly removed.
 class BindingsManager {
  public:
+  // NOTE: This is the deprecated legacy notification type. Please use a
+  // MessagePortConnectedHandler instead!
   using PortConnectedHandler =
       base::RepeatingCallback<void(mojo::ScopedMessagePipeHandle)>;
+  using MessagePortConnectedHandler =
+      base::RepeatingCallback<void(blink::WebMessagePort)>;
 
   BindingsManager();
 
@@ -32,8 +38,12 @@ class BindingsManager {
   // Registers a |handler| which will receive MessagePorts originating from
   // the frame's web content. |port_name| is an alphanumeric string that is
   // consistent across JS and native code.
+  // NOTE: The mojo::ScopedMessagePipeHandle of this function is deprecated and
+  // soon to be removed, please use the blink::WebMessagePort variant!
   void RegisterPortHandler(base::StringPiece port_name,
                            PortConnectedHandler handler);
+  void RegisterPortHandler(base::StringPiece port_name,
+                           MessagePortConnectedHandler handler);
 
   // Unregisters a previously registered handler.
   // The owner of BindingsManager is responsible for ensuring that all handlers
@@ -48,11 +58,14 @@ class BindingsManager {
  protected:
   // Called by platform-specific subclasses when the underlying transport has
   // delivered a port.
+  // NOTE: The mojo::ScopedMessagePipeHandle of this function is deprecated and
+  // soon to be removed, please use the blink::WebMessagePort variant!
   void OnPortConnected(base::StringPiece port_name,
                        mojo::ScopedMessagePipeHandle port);
+  void OnPortConnected(base::StringPiece port_name, blink::WebMessagePort port);
 
  private:
-  base::flat_map<std::string, PortConnectedHandler> port_handlers_;
+  base::flat_map<std::string, MessagePortConnectedHandler> port_handlers_;
 
   DISALLOW_COPY_AND_ASSIGN(BindingsManager);
 };

chromecast/bindings/bindings_manager_cast.cc

@@ -12,10 +12,6 @@
 #include "base/strings/utf_string_conversions.h"
 #include "chromecast/bindings/grit/resources.h"
 #include "mojo/public/cpp/bindings/connector.h"
-#include "third_party/blink/public/common/messaging/string_message_codec.h"
-#include "third_party/blink/public/common/messaging/transferable_message.h"
-#include "third_party/blink/public/common/messaging/transferable_message_mojom_traits.h"
-#include "third_party/blink/public/mojom/messaging/transferable_message.mojom.h"
 #include "ui/base/resource/resource_bundle.h"
 
 namespace chromecast {
@@ -69,7 +65,7 @@ void BindingsManagerCast::OnPageStateChanged(
       return;
     case CastWebContents::PageState::DESTROYED:
     case CastWebContents::PageState::ERROR:
-      connector_.reset();
+      blink_port_.Reset();
       CastWebContents::Observer::Observe(nullptr);
       cast_web_contents_ = nullptr;
       return;
@@ -84,58 +80,37 @@ void BindingsManagerCast::OnPageLoaded() {
       << "Received PageLoaded event while not observing a page";
 
   // Unbind platform-side MessagePort connector.
-  if (connector_) {
-    connector_->set_incoming_receiver(nullptr);
-    connector_.reset();
-  }
+  blink_port_.Reset();
+
+  // Create a blink::WebMessagePort, this is the way Chromium implements HTML5
+  // MessagePorts.
+  auto port_pair = blink::WebMessagePort::CreatePair();
 
-  // Create a pre-connected MessagePipe, this is the way chromium
-  // implements HTML5 MessagePort.
-  mojo::ScopedMessagePipeHandle platform_port;
-  mojo::ScopedMessagePipeHandle page_port;
-  mojo::CreateMessagePipe(nullptr, &platform_port, &page_port);
-
-  connector_ = std::make_unique<mojo::Connector>(
-      std::move(platform_port), mojo::Connector::SINGLE_THREADED_SEND,
-      base::ThreadTaskRunnerHandle::Get());
-  connector_->set_connection_error_handler(base::BindOnce(
-      &BindingsManagerCast::OnControlPortDisconnected, base::Unretained(this)));
-  connector_->set_incoming_receiver(this);
-
-  // Post page_port to the page so that we could receive messages
-  // through another end of the pipe, which is platform_port.
-  // |named_message_port_connector.js| will receive this through
-  // onmessage event.
-  std::vector<mojo::ScopedMessagePipeHandle> message_ports;
-  message_ports.push_back(std::move(page_port));
+  blink_port_ = std::move(port_pair.first);
+  blink_port_.SetReceiver(this, base::ThreadTaskRunnerHandle::Get());
+
+  // Post the other end of the pipe to the page so that we can receive messages
+  // over |content_port|. |named_message_port_connector.js| will receive this
+  // through an onmessage event.
+  std::vector<blink::WebMessagePort> message_ports;
+  message_ports.push_back(std::move(port_pair.second));
   cast_web_contents_->PostMessageToMainFrame("*", kControlPortConnectMessage,
                                              std::move(message_ports));
 }
 
-bool BindingsManagerCast::Accept(mojo::Message* message) {
+bool BindingsManagerCast::OnMessage(blink::WebMessagePort::Message message) {
   // Receive MessagePort and forward ports to their corresponding
   // binding handlers.
-  blink::TransferableMessage transferable_message;
-  if (!blink::mojom::TransferableMessage::DeserializeFromMessage(
-          std::move(*message), &transferable_message)) {
-    return false;
-  }
 
   // One and only one MessagePort should be sent to here.
-  if (transferable_message.ports.empty()) {
-    LOG(ERROR) << "TransferableMessage contains no ports.";
-  }
-  DCHECK(transferable_message.ports.size() == 1)
+  if (message.ports.empty())
+    LOG(ERROR) << "blink::WebMessagePort::Message contains no ports.";
+  DCHECK_EQ(1u, message.ports.size())
       << "Only one control port should be provided";
-  blink::MessagePortChannel message_port_channel =
-      std::move(transferable_message.ports[0]);
+  blink::WebMessagePort message_port = std::move(message.ports[0]);
+  message.ports.clear();
 
-  base::string16 data_utf16;
-  if (!blink::DecodeStringMessage(transferable_message.encoded_message,
-                                  &data_utf16)) {
-    LOG(ERROR) << "This Message does not contain bindingId";
-    return false;
-  }
+  base::string16 data_utf16 = std::move(message.data);
 
   std::string binding_id;
   if (!base::UTF16ToUTF8(data_utf16.data(), data_utf16.size(), &binding_id)) {
@@ -143,13 +118,13 @@ bool BindingsManagerCast::Accept(mojo::Message* message) {
   }
 
   // Route the port to corresponding binding backend.
-  OnPortConnected(binding_id, message_port_channel.ReleaseHandle());
+  OnPortConnected(binding_id, std::move(message_port));
   return true;
 }
 
-void BindingsManagerCast::OnControlPortDisconnected() {
+void BindingsManagerCast::OnPipeError() {
   LOG(INFO) << "NamedMessagePortConnector control port disconnected";
-  connector_.reset();
+  blink_port_.Reset();
 }
 
 }  // namespace bindings

chromecast/bindings/bindings_manager_cast.h

@@ -21,7 +21,7 @@ namespace bindings {
 // Implements the CastOS BindingsManager.
 class BindingsManagerCast : public BindingsManager,
                             public CastWebContents::Observer,
-                            public mojo::MessageReceiver {
+                            public blink::WebMessagePort::MessageReceiver {
  public:
   BindingsManagerCast();
   ~BindingsManagerCast() override;
@@ -45,17 +45,15 @@ class BindingsManagerCast : public BindingsManager,
   void OnPageStateChanged(CastWebContents* cast_web_contents) override;
 
  private:
-  // |connector_| has been disconnected.
-  void OnControlPortDisconnected();
-
-  // mojo::MessageReceiver implementation:
-  bool Accept(mojo::Message* message) override;
+  // blink::WebMessagePort::MessageReceiver implementation:
+  bool OnMessage(blink::WebMessagePort::Message message) override;
+  void OnPipeError() override;
 
   // Stores all bindings, keyed on the string-based IDs.
   std::map<std::string, std::string> bindings_by_id_;
   chromecast::CastWebContents* cast_web_contents_;
-  // Binded with the MessagePort used to receive messages from the page JS.
-  std::unique_ptr<mojo::Connector> connector_;
+  // Receives messages from JS.
+  blink::WebMessagePort blink_port_;
 
   DISALLOW_COPY_AND_ASSIGN(BindingsManagerCast);
 };

chromecast/bindings/bindings_manager_cast_browsertest.cc

@@ -33,10 +33,6 @@
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/public/common/messaging/string_message_codec.h"
-#include "third_party/blink/public/common/messaging/transferable_message.h"
-#include "third_party/blink/public/common/messaging/transferable_message_mojom_traits.h"
-#include "third_party/blink/public/mojom/messaging/transferable_message.mojom.h"
 #include "url/gurl.h"
 
 using ::testing::_;
@@ -66,35 +62,10 @@ base::FilePath GetTestDataFilePath(const std::string& name) {
   return file_path.Append(GetTestDataPath()).AppendASCII(name);
 }
 
-// Mojo MessagePort Utils:
-mojo::Message MojoMessageFromUtf8(base::StringPiece message_utf8) {
-  blink::TransferableMessage transfer_message;
-  transfer_message.owned_encoded_message =
-      blink::EncodeStringMessage(base::UTF8ToUTF16(message_utf8));
-  transfer_message.encoded_message = transfer_message.owned_encoded_message;
-  return blink::mojom::TransferableMessage::SerializeAsMessage(
-      &transfer_message);
-}
-
-base::Optional<std::string> ReadMessagePayloadAsUtf8(mojo::Message message) {
-  blink::TransferableMessage transferable_message;
-  if (!blink::mojom::TransferableMessage::DeserializeFromMessage(
-          std::move(message), &transferable_message)) {
-    return base::nullopt;
-  }
-
-  if (!transferable_message.ports.empty()) {
-    LOG(ERROR) << "TransferableMessage has unexpected ports.";
-  }
-
-  base::string16 data_utf16;
-  if (!blink::DecodeStringMessage(transferable_message.encoded_message,
-                                  &data_utf16)) {
-    return base::nullopt;
-  }
-
+base::Optional<std::string> ReadMessagePayloadAsUtf8(
+    blink::WebMessagePort::Message message) {
   std::string output;
-  if (!base::UTF16ToUTF8(data_utf16.data(), data_utf16.size(), &output))
+  if (!base::UTF16ToUTF8(message.data.data(), message.data.size(), &output))
     return base::nullopt;
 
   return base::make_optional<std::string>(output);
@@ -139,7 +110,7 @@ class TitleChangeObserver : public CastWebContents::Observer {
 };
 
 // Test class for communicating with connector.html.
-class TestBindingBackend : public mojo::MessageReceiver {
+class TestBindingBackend : public blink::WebMessagePort::MessageReceiver {
  public:
   TestBindingBackend(bindings::BindingsManager* bindings_manager)
       : bindings_manager_(bindings_manager) {
@@ -150,14 +121,14 @@ class TestBindingBackend : public mojo::MessageReceiver {
   }
 
   ~TestBindingBackend() override {
-    connector_.reset();
+    port_.Reset();
     constexpr char kPortName[] = "hello";
     bindings_manager_->UnregisterPortHandler(kPortName);
   }
 
   // Start the RunLoop until OnPortConnected.
   void RunUntilPortConnected() {
-    if (connector_)
+    if (port_.IsValid())
       return;
 
     base::RunLoop run_loop;
@@ -182,13 +153,13 @@ class TestBindingBackend : public mojo::MessageReceiver {
   }
 
   void SendMessageToPage(base::StringPiece message) {
-    if (!connector_)
+    if (!port_.IsValid())
       return;
 
     DCHECK(!message.empty());
 
-    mojo::Message mojo_message = MojoMessageFromUtf8(message);
-    connector_->Accept(&mojo_message);
+    blink::WebMessagePort::Message blink_message(base::UTF8ToUTF16(message));
+    port_.PostMessage(std::move(blink_message));
   }
 
   void SetPortDisconnectedCallback(
@@ -199,31 +170,18 @@ class TestBindingBackend : public mojo::MessageReceiver {
 
  private:
   // Called when a port was received from the page.
-  void OnPortConnected(mojo::ScopedMessagePipeHandle port) {
+  void OnPortConnected(blink::WebMessagePort port) {
     if (!quit_closure_.is_null()) {
       std::move(quit_closure_).Run();
     }
-    connector_ = std::make_unique<mojo::Connector>(
-        std::move(port), mojo::Connector::SINGLE_THREADED_SEND,
-        base::ThreadTaskRunnerHandle::Get());
-    connector_->set_connection_error_handler(base::BindOnce(
-        &TestBindingBackend::OnPortDisconnected, base::Unretained(this)));
-    connector_->set_incoming_receiver(this);
+    port_ = std::move(port);
+    port_.SetReceiver(this, base::ThreadTaskRunnerHandle::Get());
   }
 
-  // Called when the peer disconnected the port.
-  void OnPortDisconnected() {
-    LOG(INFO) << "TestBindingBackend port disconnected.";
-    connector_.reset();
-    if (port_disconnected_callback_) {
-      std::move(port_disconnected_callback_).Run();
-    }
-  }
-
-  // mojo::MessageReceiver implementation:
-  bool Accept(mojo::Message* message) override {
+  // blink::WebMessagePort::MessageReceiver implementation:
+  bool OnMessage(blink::WebMessagePort::Message message) override {
     base::Optional<std::string> message_json =
-        ReadMessagePayloadAsUtf8(std::move(*message));
+        ReadMessagePayloadAsUtf8(std::move(message));
     if (!message_json)
       return false;
 
@@ -233,18 +191,29 @@ class TestBindingBackend : public mojo::MessageReceiver {
       std::move(message_received_callback_).Run(message_json.value());
       return true;
     }
+
     // Cache received message until external caller access it
     // via TestBindingBackend::ReceiveMessage
     message_queue_.emplace_back(message_json.value());
     return true;
   }
 
+  // blink::WebMessagePort::MessageReceiver implementation:
+  // Called when the peer disconnected the port.
+  void OnPipeError() override {
+    LOG(INFO) << "TestBindingBackend port disconnected.";
+    port_.Reset();
+    if (port_disconnected_callback_) {
+      std::move(port_disconnected_callback_).Run();
+    }
+  }
+
   base::OnceClosure quit_closure_;
 
   bindings::BindingsManager* const bindings_manager_;
 
   // Used for sending and receiving messages over the MessagePort.
-  std::unique_ptr<mojo::Connector> connector_;
+  blink::WebMessagePort port_;
 
   base::circular_deque<std::string> message_queue_;
   base::OnceCallback<void(std::string)> message_received_callback_;

chromecast/browser/cast_web_contents.h

@@ -17,6 +17,7 @@
 #include "chromecast/common/mojom/feature_manager.mojom.h"
 #include "services/service_manager/public/cpp/binder_registry.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
+#include "third_party/blink/public/common/messaging/web_message_port.h"
 #include "ui/gfx/geometry/rect.h"
 #include "url/gurl.h"
 
@@ -337,10 +338,15 @@ class CastWebContents {
   // See html.spec.whatwg.org/multipage/web-messaging.html sect. 9.4.3
   // for more details on how the target origin policy is applied.
   // Should be called on UI thread.
+  // TODO(crbug.com/803242): Deprecated and will be shortly removed.
   virtual void PostMessageToMainFrame(
       const std::string& target_origin,
       const std::string& data,
       std::vector<mojo::ScopedMessagePipeHandle> channels) = 0;
+  virtual void PostMessageToMainFrame(
+      const std::string& target_origin,
+      const std::string& data,
+      std::vector<blink::WebMessagePort> ports) = 0;
 
   // ===========================================================================
   // Utility Methods

chromecast/browser/cast_web_contents_browsertest.cc

@@ -40,10 +40,6 @@
 #include "net/test/embedded_test_server/http_response.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "third_party/blink/public/common/messaging/string_message_codec.h"
-#include "third_party/blink/public/common/messaging/transferable_message.h"
-#include "third_party/blink/public/common/messaging/transferable_message_mojom_traits.h"
-#include "third_party/blink/public/mojom/messaging/transferable_message.mojom.h"
 #include "url/gurl.h"
 
 using ::testing::_;
@@ -87,17 +83,6 @@ std::unique_ptr<net::test_server::HttpResponse> DefaultHandler(
   return http_response;
 }
 
-// TODO(lijiawei): Move mojo_message_port_util upstream to remove duplicate
-// helper functions. (b/138150191)
-mojo::Message MojoMessageFromUtf8(base::StringPiece message_utf8) {
-  blink::TransferableMessage transfer_message;
-  transfer_message.owned_encoded_message =
-      blink::EncodeStringMessage(base::UTF8ToUTF16(message_utf8));
-  transfer_message.encoded_message = transfer_message.owned_encoded_message;
-  return blink::mojom::TransferableMessage::SerializeAsMessage(
-      &transfer_message);
-}
-
 // =============================================================================
 // Mocks
 // =============================================================================
@@ -184,50 +169,38 @@ class TitleChangeObserver : public CastWebContents::Observer {
   DISALLOW_COPY_AND_ASSIGN(TitleChangeObserver);
 };
 
-class TestMessageReceiver : public mojo::MessageReceiver {
+class TestMessageReceiver : public blink::WebMessagePort::MessageReceiver {
  public:
   TestMessageReceiver() = default;
   ~TestMessageReceiver() override = default;
 
   void WaitForNextIncomingMessage(
-      base::OnceCallback<void(std::string,
-                              base::Optional<mojo::ScopedMessagePipeHandle>)>
-          callback) {
+      base::OnceCallback<
+          void(std::string, base::Optional<blink::WebMessagePort>)> callback) {
     DCHECK(message_received_callback_.is_null())
         << "Only one waiting event is allowed.";
     message_received_callback_ = std::move(callback);
   }
 
- private:
-  bool Accept(mojo::Message* message) override {
-    blink::TransferableMessage transferable_message;
-    if (!blink::mojom::TransferableMessage::DeserializeFromMessage(
-            std::move(*message), &transferable_message)) {
-      return false;
-    }
-
-    base::string16 data_utf16;
-    if (!blink::DecodeStringMessage(transferable_message.encoded_message,
-                                    &data_utf16)) {
-      return false;
-    }
+  void SetOnPipeErrorCallback(base::OnceCallback<void()> callback) {
+    on_pipe_error_callback_ = std::move(callback);
+  }
 
+ private:
+  bool OnMessage(blink::WebMessagePort::Message message) override {
     std::string message_text;
-    if (!base::UTF16ToUTF8(data_utf16.data(), data_utf16.size(),
+    if (!base::UTF16ToUTF8(message.data.data(), message.data.size(),
                            &message_text)) {
       return false;
     }
 
-    base::Optional<mojo::ScopedMessagePipeHandle> incoming_port = base::nullopt;
+    base::Optional<blink::WebMessagePort> incoming_port = base::nullopt;
     // Only one MessagePort should be sent to here.
-    if (!transferable_message.ports.empty()) {
-      DCHECK(transferable_message.ports.size() == 1)
+    if (!message.ports.empty()) {
+      DCHECK(message.ports.size() == 1)
           << "Only one control port can be provided";
-
-      blink::MessagePortChannel message_port_channel =
-          std::move(transferable_message.ports[0]);
-      incoming_port = base::make_optional<mojo::ScopedMessagePipeHandle>(
-          message_port_channel.ReleaseHandle());
+      incoming_port = base::make_optional<blink::WebMessagePort>(
+          std::move(message.ports[0]));
     }
 
     if (message_received_callback_) {
@@ -237,11 +210,17 @@ class TestMessageReceiver : public mojo::MessageReceiver {
     return true;
   }
 
-  base::OnceCallback<void(
-      std::string,
-      base::Optional<mojo::ScopedMessagePipeHandle> incoming_port)>
+  void OnPipeError() override {
+    if (on_pipe_error_callback_)
+      std::move(on_pipe_error_callback_).Run();
+  }
+
+  base::OnceCallback<void(std::string,
+                          base::Optional<blink::WebMessagePort> incoming_port)>
       message_received_callback_;
 
+  base::OnceCallback<void()> on_pipe_error_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(TestMessageReceiver);
 };
 
@@ -993,7 +972,7 @@ IN_PROC_BROWSER_TEST_F(CastWebContentsBrowserTest, PostMessageToMainFrame) {
 
   cast_web_contents_->PostMessageToMainFrame(
       gurl.GetOrigin().spec(), std::string(kPage1Path),
-      std::vector<mojo::ScopedMessagePipeHandle>());
+      std::vector<blink::WebMessagePort>());
   title_change_observer_.RunUntilTitleEquals(kPage1Title);
 }
 
@@ -1015,15 +994,13 @@ IN_PROC_BROWSER_TEST_F(CastWebContentsBrowserTest, PostMessagePassMessagePort) {
   cast_web_contents_->LoadUrl(gurl);
   title_change_observer_.RunUntilTitleEquals(kOriginalTitle);
 
-  mojo::MessagePipe message_pipe;
-  auto platform_port = std::move(message_pipe.handle0);
-  auto page_port = std::move(message_pipe.handle1);
+  auto message_pipe = blink::WebMessagePort::CreatePair();
+  auto platform_port = std::move(message_pipe.first);
+  auto page_port = std::move(message_pipe.second);
 
   TestMessageReceiver message_receiver;
-  auto connector = std::make_unique<mojo::Connector>(
-      std::move(platform_port), mojo::Connector::SINGLE_THREADED_SEND,
-      base::ThreadTaskRunnerHandle::Get());
-  connector->set_incoming_receiver(&message_receiver);
+  platform_port.SetReceiver(&message_receiver,
+                            base::ThreadTaskRunnerHandle::Get());
 
   // Make sure we could send a MessagePort (ScopedMessagePipeHandle) to the
   // page.
@@ -1032,35 +1009,35 @@ IN_PROC_BROWSER_TEST_F(CastWebContentsBrowserTest, PostMessagePassMessagePort) {
     auto quit_closure = run_loop.QuitClosure();
     auto received_message_callback = base::BindOnce(
         [](base::OnceClosure loop_quit_closure, std::string port_msg,
-           base::Optional<mojo::ScopedMessagePipeHandle> incoming_port) {
+           base::Optional<blink::WebMessagePort> incoming_port) {
           EXPECT_EQ("got_port", port_msg);
           std::move(loop_quit_closure).Run();
         },
         std::move(quit_closure));
     message_receiver.WaitForNextIncomingMessage(
         std::move(received_message_callback));
-    std::vector<mojo::ScopedMessagePipeHandle> message_ports;
+    std::vector<blink::WebMessagePort> message_ports;
     message_ports.push_back(std::move(page_port));
     cast_web_contents_->PostMessageToMainFrame(
         gurl.GetOrigin().spec(), kHelloMsg, std::move(message_ports));
     run_loop.Run();
   }
   // Test whether we could receive the right response from the page after we
-  // send messages through mojo::Connector which has binded to |platform_port|.
+  // send messages through |platform_port|.
   {
     base::RunLoop run_loop;
     auto quit_closure = run_loop.QuitClosure();
     auto received_message_callback = base::BindOnce(
         [](base::OnceClosure loop_quit_closure, std::string port_msg,
-           base::Optional<mojo::ScopedMessagePipeHandle> incoming_port) {
+           base::Optional<blink::WebMessagePort> incoming_port) {
           EXPECT_EQ("ack ping", port_msg);
           std::move(loop_quit_closure).Run();
         },
         std::move(quit_closure));
     message_receiver.WaitForNextIncomingMessage(
         std::move(received_message_callback));
-    mojo::Message mojo_message = MojoMessageFromUtf8(kPingMsg);
-    connector->Accept(&mojo_message);
+    platform_port.PostMessage(
+        blink::WebMessagePort::Message(base::UTF8ToUTF16(kPingMsg)));
     run_loop.Run();
   }
 }
@@ -1083,15 +1060,14 @@ IN_PROC_BROWSER_TEST_F(CastWebContentsBrowserTest,
   cast_web_contents_->LoadUrl(gurl);
   title_change_observer_.RunUntilTitleEquals(kOriginalTitle);
 
-  mojo::MessagePipe message_pipe;
-  auto platform_port = std::move(message_pipe.handle0);
-  auto page_port = std::move(message_pipe.handle1);
+  auto message_pipe = blink::WebMessagePort::CreatePair();
+  auto platform_port = std::move(message_pipe.first);
+  auto page_port = std::move(message_pipe.second);
+
   // Bind platform side port
   TestMessageReceiver message_receiver;
-  auto connector = std::make_unique<mojo::Connector>(
-      std::move(platform_port), mojo::Connector::SINGLE_THREADED_SEND,
-      base::ThreadTaskRunnerHandle::Get());
-  connector->set_incoming_receiver(&message_receiver);
+  platform_port.SetReceiver(&message_receiver,
+                            base::ThreadTaskRunnerHandle::Get());
 
   // Make sure we could post a MessagePort (ScopedMessagePipeHandle) to
   // the page.
@@ -1100,14 +1076,14 @@ IN_PROC_BROWSER_TEST_F(CastWebContentsBrowserTest,
     auto quit_closure = run_loop.QuitClosure();
     auto received_message_callback = base::BindOnce(
         [](base::OnceClosure loop_quit_closure, std::string port_msg,
-           base::Optional<mojo::ScopedMessagePipeHandle> incoming_port) {
+           base::Optional<blink::WebMessagePort> incoming_port) {
           EXPECT_EQ("got_port", port_msg);
           std::move(loop_quit_closure).Run();
         },
         std::move(quit_closure));
     message_receiver.WaitForNextIncomingMessage(
         std::move(received_message_callback));
-    std::vector<mojo::ScopedMessagePipeHandle> message_ports;
+    std::vector<blink::WebMessagePort> message_ports;
     message_ports.push_back(std::move(page_port));
     cast_web_contents_->PostMessageToMainFrame(
         gurl.GetOrigin().spec(), kHelloMsg, std::move(message_ports));
@@ -1117,7 +1093,7 @@ IN_PROC_BROWSER_TEST_F(CastWebContentsBrowserTest,
   // should be able to receive disconnected event.
   {
     base::RunLoop run_loop;
-    connector->set_connection_error_handler(base::BindOnce(
+    message_receiver.SetOnPipeErrorCallback(base::BindOnce(
         [](base::OnceClosure quit_closure) { std::move(quit_closure).Run(); },
         run_loop.QuitClosure()));
     cast_web_contents_->LoadUrl(GURL(url::kAboutBlankURL));

chromecast/browser/cast_web_contents_impl.cc

@@ -339,6 +339,7 @@ void CastWebContentsImpl::RemoveBeforeLoadJavaScript(base::StringPiece id) {
   }
 }
 
+// TODO(crbug.com/803242): Deprecated and will be shortly removed.
 void CastWebContentsImpl::PostMessageToMainFrame(
     const std::string& target_origin,
     const std::string& data,
@@ -359,6 +360,26 @@ void CastWebContentsImpl::PostMessageToMainFrame(
       std::move(channels));
 }
 
+void CastWebContentsImpl::PostMessageToMainFrame(
+    const std::string& target_origin,
+    const std::string& data,
+    std::vector<blink::WebMessagePort> ports) {
+  DCHECK(!data.empty());
+
+  base::string16 data_utf16;
+  data_utf16 = base::UTF8ToUTF16(data);
+
+  // If origin is set as wildcard, no origin scoping would be applied.
+  constexpr char kWildcardOrigin[] = "*";
+  base::Optional<base::string16> target_origin_utf16;
+  if (target_origin != kWildcardOrigin)
+    target_origin_utf16 = base::UTF8ToUTF16(target_origin);
+
+  content::MessagePortProvider::PostMessageToFrame(
+      web_contents(), base::string16(), target_origin_utf16, data_utf16,
+      std::move(ports));
+}
+
 void CastWebContentsImpl::AddObserver(CastWebContents::Observer* observer) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(observer);

chromecast/browser/cast_web_contents_impl.h

@@ -67,10 +67,15 @@ class CastWebContentsImpl : public CastWebContents,
                                const std::vector<std::string>& origins,
                                base::StringPiece script) override;
   void RemoveBeforeLoadJavaScript(base::StringPiece id) override;
+  // TODO(crbug.com/803242): Deprecated and will be shortly removed.
   void PostMessageToMainFrame(
       const std::string& target_origin,
       const std::string& data,
       std::vector<mojo::ScopedMessagePipeHandle> channels) override;
+  void PostMessageToMainFrame(
+      const std::string& target_origin,
+      const std::string& data,
+      std::vector<blink::WebMessagePort> ports) override;
   void AddObserver(Observer* observer) override;
   void RemoveObserver(Observer* observer) override;
   bool is_websql_enabled() override;

content/browser/message_port_provider.cc

@@ -81,6 +81,7 @@ void MessagePortProvider::PostMessageToFrame(
 #endif
 
 #if defined(OS_FUCHSIA) || BUILDFLAG(IS_CHROMECAST)
+// TODO(crbug.com/803242): Deprecated and will be shortly removed.
 // static
 void MessagePortProvider::PostMessageToFrame(
     WebContents* web_contents,
@@ -96,6 +97,22 @@ void MessagePortProvider::PostMessageToFrame(
                              target_origin.value_or(base::EmptyString16()),
                              data, channels_wrapped);
 }
+
+// static
+void MessagePortProvider::PostMessageToFrame(
+    WebContents* web_contents,
+    const base::string16& source_origin,
+    const base::Optional<base::string16>& target_origin,
+    const base::string16& data,
+    std::vector<blink::WebMessagePort> channels) {
+  std::vector<MessagePortChannel> channels_wrapped;
+  for (blink::WebMessagePort& port : channels) {
+    channels_wrapped.emplace_back(port.PassHandle());
+  }
+  PostMessageToFrameInternal(web_contents, source_origin,
+                             target_origin.value_or(base::EmptyString16()),
+                             data, channels_wrapped);
+}
 #endif
 
 }  // namespace content

content/public/browser/message_port_provider.h

@@ -14,6 +14,7 @@
 #include "build/build_config.h"
 #include "build/chromecast_buildflags.h"
 #include "content/common/content_export.h"
+#include "third_party/blink/public/common/messaging/web_message_port.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/scoped_java_ref.h"
@@ -51,6 +52,7 @@ class CONTENT_EXPORT MessagePortProvider {
 #endif  // OS_ANDROID
 
 #if defined(OS_FUCHSIA) || BUILDFLAG(IS_CHROMECAST)
+  // TODO(crbug.com/803242): Deprecated and will be shortly removed.
   // If |target_origin| is unset, then no origin scoping is applied.
   static void PostMessageToFrame(
       WebContents* web_contents,
@@ -58,6 +60,13 @@ class CONTENT_EXPORT MessagePortProvider {
       const base::Optional<base::string16>& target_origin,
       const base::string16& data,
       std::vector<mojo::ScopedMessagePipeHandle> channels);
+  // If |target_origin| is unset, then no origin scoping is applied.
+  static void PostMessageToFrame(
+      WebContents* web_contents,
+      const base::string16& source_origin,
+      const base::Optional<base::string16>& target_origin,
+      const base::string16& data,
+      std::vector<blink::WebMessagePort> ports);
 #endif  // OS_FUCHSIA || BUILDFLAG(IS_CHROMECAST)
 
  private:

third_party/blink/public/common/BUILD.gn

@@ -34,6 +34,7 @@ buildflag_header("buildflags") {
 source_set("headers") {
   visibility = [
     "//chrome/*",
+    "//chromecast/*",
     "//content/*",
     "//third_party/blink/*",
     "//components/*",