[mojo-edk] Add support for transferring mach ports.

mojo/edk/system/node_controller.h

 // Copyright 2016 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.
 
 #ifndef MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_
 #define MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_
 
 #include <queue>
 #include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/task_runner.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/system/node_channel.h"
 #include "mojo/edk/system/ports/hash_functions.h"
 #include "mojo/edk/system/ports/name.h"
 #include "mojo/edk/system/ports/node.h"
 #include "mojo/edk/system/ports/node_delegate.h"
 
+namespace base {
+class PortProvider;
+}
+
 namespace mojo {
 namespace edk {
 
 class Broker;
 class Core;
+class MachPortRelay;
 class PortsMessage;
 
 // The owner of ports::Node which facilitates core EDK implementation. All
 // public interface methods are safe to call from any thread.
 class NodeController : public ports::NodeDelegate,
                        public NodeChannel::Delegate {
  public:
   class PortObserver : public ports::UserData {
    public:
     virtual void OnPortStatusChanged() = 0;
 
    protected:
     ~PortObserver() override {}
   };
 
   // |core| owns and out-lives us.
   explicit NodeController(Core* core);
   ~NodeController() override;
 
   const ports::NodeName& name() const { return name_; }
   Core* core() const { return core_; }
   ports::Node* node() const { return node_.get(); }
   scoped_refptr<base::TaskRunner> io_task_runner() const {
     return io_task_runner_;
   }
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  // Create the relay used to transfer mach ports between processes.
+  void CreateMachPortRelayIfNeeded(base::PortProvider* port_provider);
+#endif
+
   // Called exactly once, shortly after construction, and before any other
   // methods are called on this object.
   void SetIOTaskRunner(scoped_refptr<base::TaskRunner> io_task_runner);
 
   // Connects this node to a child node. This node will initiate a handshake.
   void ConnectToChild(base::ProcessHandle process_handle,
                       ScopedPlatformHandle platform_handle);
 
   // Connects this node to a parent node. The parent node will initiate a
   // handshake.
@@ skipping 83 matching lines @@
                             ScopedPlatformHandle broker_channel) override;
   void OnPortsMessage(Channel::MessagePtr message) override;
   void OnRequestPortMerge(const ports::NodeName& from_node,
                           const ports::PortName& connector_port_name,
                           const std::string& token) override;
   void OnRequestIntroduction(const ports::NodeName& from_node,
                              const ports::NodeName& name) override;
   void OnIntroduce(const ports::NodeName& from_node,
                    const ports::NodeName& name,
                    ScopedPlatformHandle channel_handle) override;
-#if defined(OS_WIN)
+#if defined(OS_WIN) || (defined(OS_MACOSX) && !defined(OS_IOS))
   void OnRelayPortsMessage(const ports::NodeName& from_node,
                            base::ProcessHandle from_process,
                            const ports::NodeName& destination,
                            Channel::MessagePtr message) override;
 #endif
   void OnChannelError(const ports::NodeName& from_node) override;
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  MachPortRelay* GetMachPortRelay() override;
+#endif
 
   // Marks this NodeController for destruction when the IO thread shuts down.
   // This is used in case Core is torn down before the IO thread. Must only be
   // called on the IO thread.
   void DestroyOnIOThreadShutdown();
 
   // If there is a registered shutdown callback (meaning shutdown has been
   // requested, this checks the Node's status to see if clean shutdown is
   // possible. If so, shutdown is performed and the shutdown callback is run.
   void AttemptShutdownIfRequested();
@@ skipping 69 matching lines @@
 
   // Indicates whether this object should delete itself on IO thread shutdown.
   // Must only be accessed from the IO thread.
   bool destroy_on_io_thread_shutdown_ = false;
 
 #if defined(OS_POSIX)
   // Broker for sync shared buffer creation (posix-only) in children.
   scoped_ptr<Broker> broker_;
 #endif
 
+#if defined(OS_MACOSX) && !defined(OS_IOS)
+  base::Lock mach_port_relay_lock_;
+  // Relay for transferring mach ports to/from children.
+  scoped_ptr<MachPortRelay> mach_port_relay_;
+#endif
+
   DISALLOW_COPY_AND_ASSIGN(NodeController);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_