[mojo-edk] Bind a child token to child launches and port reservations.

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 <memory>
 #include <queue>
 #include <unordered_map>
 #include <unordered_set>
+#include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.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"
@@ skipping 43 matching lines @@
   // Create the relay used to transfer mach ports between processes.
   void CreateMachPortRelay(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);
+                      ScopedPlatformHandle platform_handle,
+                      const std::string& child_token);
+
+  // Closes all reserved ports which associated with the child process
+  // |child_token|.
+  void CloseChildPorts(const std::string& child_token);
 
   // Connects this node to a parent node. The parent node will initiate a
   // handshake.
   void ConnectToParent(ScopedPlatformHandle platform_handle);
 
   // 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);
 
   // Sends a message on a port to its peer.
   int SendMessage(const ports::PortRef& port_ref,
                   std::unique_ptr<PortsMessage> message);
 
   // Reserves a local port |port| associated with |token|. A peer holding a copy
   // of |token| can merge one of its own ports into this one.
-  void ReservePort(const std::string& token, const ports::PortRef& port);
+  void ReservePort(const std::string& token, const ports::PortRef& port,
+                   const std::string& child_token);
 
   // Merges a local port |port| into a port reserved by |token| in the parent.
   void MergePortIntoParent(const std::string& token,
                            const ports::PortRef& port);
 
   // Merges two local ports together.
   int MergeLocalPorts(const ports::PortRef& port0, const ports::PortRef& port1);
 
   // Creates a new shared buffer for use in the current process.
   scoped_refptr<PlatformSharedBuffer> CreateSharedBuffer(size_t num_bytes);
 
   // Request that the Node be shut down cleanly. This may take an arbitrarily
   // long time to complete, at which point |callback| will be called.
   //
   // Note that while it is safe to continue using the NodeController's public
   // interface after requesting shutdown, you do so at your own risk and there
   // is NO guarantee that new messages will be sent or ports will complete
   // transfer.
   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);
+                                ScopedPlatformHandle platform_handle,
+                                ports::NodeName token);
   void ConnectToParentOnIOThread(ScopedPlatformHandle platform_handle);
 
   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);
@@ skipping 66 matching lines @@
   // Guards |peers_| and |pending_peer_messages_|.
   base::Lock peers_lock_;
 
   // Channels to known peers, including parent and children, if any.
   NodeMap peers_;
 
   // Outgoing message queues for peers we've heard of but can't yet talk to.
   std::unordered_map<ports::NodeName, OutgoingMessageQueue>
       pending_peer_messages_;
 
-  // Guards |reserved_ports_|.
+  // Guards |reserved_ports_| and |pending_child_tokens_|.
   base::Lock reserved_ports_lock_;
 
   // Ports reserved by token.

[ncarter (slow), 2016/06/02 17:43:28]

Seems like there are two flavors of token in this map (one in the keys and one
in the values). Could this comment clarify which is which?

[Anand Mistry (off Chromium), 2016/06/03 04:39:41]

Done.

-  base::hash_map<std::string, ports::PortRef> reserved_ports_;
+  base::hash_map<std::string, std::pair<ports::PortRef, std::string>>

[ncarter (slow), 2016/06/02 17:43:28]

With c++11 uniform inititalization syntax, it's really easy to just use a struct
instead of std::pair, like this:

struct ReservedPort {
  ports::PortRef port;
  std::string child_token;
};

Doing that, IMO, results in more readable code when the map is used
(it->second.port vs. it->second.second).

[Anand Mistry (off Chromium), 2016/06/03 04:39:40]

Done.

+      reserved_ports_;
+  // TODO(amistry): This _really_ needs to be a bimap. Unfortunately, we don't
+  // have one yet :(
+  std::unordered_map<ports::NodeName, std::string> pending_child_tokens_;
 
   // Guards |pending_port_merges_|.
   base::Lock pending_port_merges_lock_;
 
   // A set of port merge requests awaiting parent connection.
   std::vector<std::pair<std::string, ports::PortRef>> pending_port_merges_;
 
   // Guards |parent_name_| and |bootstrap_parent_channel_|.
   base::Lock parent_lock_;
 
@@ skipping 54 matching lines @@
   std::unique_ptr<MachPortRelay> mach_port_relay_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(NodeController);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_NODE_CONTROLLER_H_