[mojo-edk] Simplify multiprocess pipe bootstrap

mojo/edk/system/core.cc

 // Copyright 2013 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 "mojo/edk/system/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 26 matching lines @@
 #include "mojo/edk/system/waiter.h"
 
 namespace mojo {
 namespace edk {
 
 namespace {
 
 // This is an unnecessarily large limit that is relatively easy to enforce.
 const uint32_t kMaxHandlesPerMessage = 1024 * 1024;
 
-void OnPortConnected(
-    Core* core,
-    int endpoint,
-    const base::Callback<void(ScopedMessagePipeHandle)>& callback,
-    const ports::PortRef& port) {
-  // TODO: Maybe we could negotiate a pipe ID for cross-process pipes too;
-  // for now we just use 0x7F7F7F7F7F7F7F7F. In practice these are used for
-  // bootstrap and aren't passed around, so tracking them is less important.
-  MojoHandle handle = core->AddDispatcher(
-      new MessagePipeDispatcher(core->GetNodeController(), port,
-                                0x7f7f7f7f7f7f7f7fUL, endpoint));
-  callback.Run(ScopedMessagePipeHandle(MessagePipeHandle(handle)));
-}
+// TODO: Maybe we could negotiate a debugging pipe ID for cross-process pipes
+// too; for now we just use a constant. This only affects bootstrap pipes.
+const uint64_t kUnknownPipeIdForDebug = 0x7f7f7f7f7f7f7f7fUL;
 
 }  // namespace
 
 Core::Core() {}
 
 Core::~Core() {
   if (node_controller_ && node_controller_->io_task_runner()) {
     // If this races with IO thread shutdown the callback will be dropped and
     // the NodeController will be shutdown on this thread anyway, which is also
     // just fine.
@@ skipping 83 matching lines @@
   if (base::ThreadTaskRunnerHandle::IsSet()) {
     on_shutdown = base::Bind(base::IgnoreResult(&base::TaskRunner::PostTask),
                              base::ThreadTaskRunnerHandle::Get(),
                              FROM_HERE, callback);
   } else {
     on_shutdown = callback;
   }
   GetNodeController()->RequestShutdown(on_shutdown);
 }
 
-void Core::CreateMessagePipe(
-    ScopedPlatformHandle platform_handle,
-    const base::Callback<void(ScopedMessagePipeHandle)>& callback) {
-  ports::PortRef port;
-  GetNodeController()->node()->CreateUninitializedPort(&port);
+ScopedMessagePipeHandle Core::CreateMessagePipe(
+    ScopedPlatformHandle platform_handle) {
+  ports::PortRef port0, port1;
+  GetNodeController()->node()->CreatePortPair(&port0, &port1);
+  MojoHandle handle = AddDispatcher(
+    new MessagePipeDispatcher(GetNodeController(), port0,
+                              kUnknownPipeIdForDebug, 0));
   RemoteMessagePipeBootstrap::Create(
-      GetNodeController(), std::move(platform_handle), port,
-      base::Bind(&OnPortConnected, base::Unretained(this), 0, callback, port));
+      GetNodeController(), std::move(platform_handle), port1);
+  return ScopedMessagePipeHandle(MessagePipeHandle(handle));
 }
 
-void Core::CreateParentMessagePipe(
-    const std::string& token,
-    const base::Callback<void(ScopedMessagePipeHandle)>& callback) {
-  GetNodeController()->ReservePort(
-      token,
-      base::Bind(&OnPortConnected, base::Unretained(this), 0, callback));
+ScopedMessagePipeHandle Core::CreateParentMessagePipe(
+    const std::string& token) {
+  ports::PortRef port0, port1;
+  GetNodeController()->node()->CreatePortPair(&port0, &port1);
+  MojoHandle handle = AddDispatcher(
+      new MessagePipeDispatcher(GetNodeController(), port0,
+                                kUnknownPipeIdForDebug, 0));
+  GetNodeController()->ReservePort(token, port1);
+  return ScopedMessagePipeHandle(MessagePipeHandle(handle));
 }
 
-void Core::CreateChildMessagePipe(
-    const std::string& token,
-    const base::Callback<void(ScopedMessagePipeHandle)>& callback) {
-  ports::PortRef port;
-  GetNodeController()->node()->CreateUninitializedPort(&port);
-  GetNodeController()->ConnectToParentPort(
-      port, token,
-      base::Bind(&OnPortConnected, base::Unretained(this), 1, callback, port));
+ScopedMessagePipeHandle Core::CreateChildMessagePipe(const std::string& token) {
+  ports::PortRef port0, port1;
+  GetNodeController()->node()->CreatePortPair(&port0, &port1);
+  MojoHandle handle = AddDispatcher(
+      new MessagePipeDispatcher(GetNodeController(), port0,
+                                kUnknownPipeIdForDebug, 1));
+  GetNodeController()->MergePortIntoParent(token, port1);
+  return ScopedMessagePipeHandle(MessagePipeHandle(handle));
 }
 
 MojoResult Core::AsyncWait(MojoHandle handle,
                            MojoHandleSignals signals,
                            const base::Callback<void(MojoResult)>& callback) {
   scoped_refptr<Dispatcher> dispatcher = GetDispatcher(handle);
   DCHECK(dispatcher);
 
   scoped_ptr<AsyncWaiter> waiter = make_scoped_ptr(new AsyncWaiter(callback));
   MojoResult rv = dispatcher->AddAwakable(waiter.get(), signals, 0, nullptr);
@@ skipping 505 matching lines @@
     scoped_ptr<NodeController> node_controller) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo