Bootstrap Mojo IPC independent of Chrome IPC

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>
@@ skipping 44 matching lines @@
   scoped_refptr<base::TaskRunner> io_task_runner() const {
     return io_task_runner_;
   }
 
   // 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);
+                      ScopedPlatformHandle platform_handle,
+                      const std::string& secret);
 
   // Connects this node to a parent node. The parent node will initiate a
   // handshake.
-  void ConnectToParent(ScopedPlatformHandle platform_handle);
+  void ConnectToParent(ScopedPlatformHandle platform_handle,
+                       const std::string& secret);
 
   // Sets a port's observer. If |observer| is null the port's current observer
   // is removed.
   void SetPortObserver(const ports::PortRef& port,
                        const scoped_refptr<PortObserver>& observer);
 
   // Closes a port. Use this in lieu of calling Node::ClosePort() directly, as
   // it ensures the port's observer has also been removed.
   void ClosePort(const ports::PortRef& port);
 
@@ skipping 23 matching lines @@
   void RequestShutdown(const base::Closure& callback);
 
  private:
   friend Core;
 
   using NodeMap = std::unordered_map<ports::NodeName,
                                      scoped_refptr<NodeChannel>>;
   using OutgoingMessageQueue = std::queue<Channel::MessagePtr>;
 
   void ConnectToChildOnIOThread(base::ProcessHandle process_handle,
-                                ScopedPlatformHandle platform_handle);
-  void ConnectToParentOnIOThread(ScopedPlatformHandle platform_handle);
+                                ScopedPlatformHandle platform_handle,
+                                const std::string& secret);
+  void ConnectToParentOnIOThread(ScopedPlatformHandle platform_handle,
+                                 const std::string& secret);
 
   scoped_refptr<NodeChannel> GetPeerChannel(const ports::NodeName& name);
   scoped_refptr<NodeChannel> GetParentChannel();
   scoped_refptr<NodeChannel> GetBrokerChannel();
 
   void AddPeer(const ports::NodeName& name,
                scoped_refptr<NodeChannel> channel,
                bool start_channel);
   void DropPeer(const ports::NodeName& name);
   void SendPeerMessage(const ports::NodeName& name,
@@ skipping 130 matching lines @@
   scoped_ptr<Broker> broker_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(NodeController);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_