Enable Blink to pass extra Mojo handles across MessagePorts

content/common/message_port.cc

 // Copyright 2017 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/common/message_port.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 
@@ skipping 29 matching lines @@
 // static
 std::vector<mojo::ScopedMessagePipeHandle> MessagePort::ReleaseHandles(
     const std::vector<MessagePort>& ports) {
   std::vector<mojo::ScopedMessagePipeHandle> handles(ports.size());
   for (size_t i = 0; i < ports.size(); ++i)
     handles[i] = ports[i].ReleaseHandle();
   return handles;
 }
 
 void MessagePort::PostMessage(const base::string16& encoded_message,
-                              std::vector<MessagePort> ports) {
+                              std::vector<MessagePort> ports,
+                              std::vector<mojo::ScopedHandle> extra_handles) {
   DCHECK(state_->handle_.is_valid());
 
-  uint32_t num_bytes = encoded_message.size() * sizeof(base::char16);
+  uint32_t num_message_bytes = encoded_message.size() * sizeof(base::char16);
 
   // NOTE: It is OK to ignore the return value of MojoWriteMessage here. HTML
   // MessagePorts have no way of reporting when the peer is gone.
 
-  if (ports.empty()) {
-    MojoWriteMessage(state_->handle_.get().value(),
-                     encoded_message.data(),
-                     num_bytes,
-                     nullptr,
-                     0,
+  // When we have handles to pass, we add a 4-byte prefix to the encoded
+  // message to indicate how many of the handles correspond to ports.
+
+  if (ports.empty() && extra_handles.empty()) {
+    MojoWriteMessage(state_->handle_.get().value(), encoded_message.data(),
+                     num_message_bytes, nullptr, 0,
                      MOJO_WRITE_MESSAGE_FLAG_NONE);
   } else {
-    uint32_t num_handles = static_cast<uint32_t>(ports.size());
+    uint32_t num_ports = static_cast<uint32_t>(ports.size());
+    uint32_t num_extra_handles = static_cast<uint32_t>(extra_handles.size());
+    uint32_t num_handles = num_ports + num_extra_handles;
+    uint32_t num_bytes = num_message_bytes + sizeof(num_ports);
+
+    std::unique_ptr<uint8_t> bytes(new uint8_t[num_bytes]);
+    memcpy(bytes.get(), &num_ports, sizeof(num_ports));
+    memcpy(bytes.get() + num_ports, encoded_message.data(), num_message_bytes);
+
     std::unique_ptr<MojoHandle[]> handles(new MojoHandle[num_handles]);
-    for (uint32_t i = 0; i < num_handles; ++i)
+    for (uint32_t i = 0; i < num_ports; ++i)
       handles[i] = ports[i].ReleaseHandle().release().value();
-    MojoWriteMessage(state_->handle_.get().value(),
-                     encoded_message.data(),
-                     num_bytes,
-                     handles.get(),
-                     num_handles,
-                     MOJO_WRITE_MESSAGE_FLAG_NONE);
+    for (uint32_t i = 0; i < num_extra_handles; ++i)
+      handles[num_ports + i] = extra_handles[i].release().value();
+
+    MojoWriteMessage(state_->handle_.get().value(), bytes.get(), num_bytes,
+                     handles.get(), num_handles, MOJO_WRITE_MESSAGE_FLAG_NONE);
   }
 }
 
 bool MessagePort::GetMessage(base::string16* encoded_message,
-                             std::vector<MessagePort>* ports) {
+                             std::vector<MessagePort>* ports,
+                             std::vector<mojo::ScopedHandle>* extra_handles) {
   DCHECK(state_->handle_.is_valid());
 
   uint32_t num_bytes = 0;
   uint32_t num_handles = 0;
 
   MojoResult rv = MojoReadMessage(state_->handle_.get().value(),
                                   nullptr,
                                   &num_bytes,
                                   nullptr,
                                   &num_handles,
                                   MOJO_READ_MESSAGE_FLAG_NONE);
   if (rv == MOJO_RESULT_OK) {
     encoded_message->clear();
     ports->clear();
+    extra_handles->clear();
     return true;
   }
   if (rv != MOJO_RESULT_RESOURCE_EXHAUSTED)
     return false;
 
   CHECK(num_bytes % 2 == 0);
 
   base::string16 buffer;
   buffer.resize(num_bytes / sizeof(base::char16));
 
   std::unique_ptr<MojoHandle[]> handles;
   if (num_handles)
     handles.reset(new MojoHandle[num_handles]);
 
   rv = MojoReadMessage(state_->handle_.get().value(),
                        num_bytes ? &buffer[0] : nullptr,
                        &num_bytes,
                        handles.get(),
                        &num_handles,
                        MOJO_READ_MESSAGE_FLAG_NONE);
   if (rv != MOJO_RESULT_OK)
     return false;
 
-  buffer.swap(*encoded_message);
+  // When we have received handles, the message contains a 4-byte prefix
+  // indicating how many of the handles correspond to ports.
 
   if (num_handles) {
-    ports->resize(static_cast<size_t>(num_handles));
-    for (uint32_t i = 0; i < num_handles; ++i) {
+    uint32_t num_ports;
+    memcpy(&num_ports, buffer.data(), sizeof(num_ports));
+    *encoded_message = buffer.substr(sizeof(num_ports) / sizeof(base::char16));
+
+    CHECK(num_ports <= num_handles);
+
+    uint32_t num_extra_handles = num_handles - num_ports;
+
+    ports->resize(static_cast<size_t>(num_ports));
+    extra_handles->resize(static_cast<size_t>(num_extra_handles));
+
+    for (uint32_t i = 0; i < num_ports; ++i) {
       ports->at(i) = MessagePort(
           mojo::ScopedMessagePipeHandle(mojo::MessagePipeHandle(handles[i])));
     }
+    for (uint32_t i = 0; i < num_extra_handles; ++i) {
+      extra_handles->at(i) =
+          mojo::ScopedHandle(mojo::Handle(handles[num_ports + i]));
+    }
+  } else {
+    buffer.swap(*encoded_message);
+    ports->clear();
+    extra_handles->clear();
   }
   return true;
 }
 
 void MessagePort::SetCallback(const base::Closure& callback) {
   state_->CancelWatch();
   state_->callback_ = callback;
   state_->AddWatch();
 }
 
@@ skipping 88 matching lines @@
   if (result == MOJO_RESULT_CANCELLED) {
     // Last notification. Release the watch context's owned State ref. This is
     // balanced in MessagePort::State::AddWatch.
     state->Release();
   } else {
     state->OnHandleReady(result);
   }
 }
 
 }  // namespace content