Fix leaks in mojo::edk::NodeController

mojo/edk/system/node_controller.cc

 // 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.
 
 #include "mojo/edk/system/node_controller.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
@@ skipping 694 matching lines @@
     base::AutoLock lock(peers_lock_);
     auto& queue = pending_peer_messages_[name];
     needs_introduction = queue.empty();
     queue.emplace(std::move(channel_message));
   }
 
   if (needs_introduction) {
     scoped_refptr<NodeChannel> broker = GetBrokerChannel();
     if (!broker) {
       DVLOG(1) << "Dropping message for unknown peer: " << name;
+
+      base::AutoLock lock(peers_lock_);
+      pending_peer_messages_.erase(name);
       return;
     }
     broker->RequestIntroduction(name);
   }
 }
 
 void NodeController::AcceptIncomingMessages() {
   // This is an impactically large value which should never be reached in
   // practice. See the CHECK below for usage.
   constexpr size_t kMaxAcceptedMessages = 1000000;
@@ skipping 205 matching lines @@
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   auto it = pending_children_.find(from_node);
   if (it == pending_children_.end() || token != from_node) {
     DLOG(ERROR) << "Received unexpected AcceptParent message from "
                 << from_node;
     DropPeer(from_node, nullptr);
     return;
   }
 
+  {
+    base::AutoLock lock(reserved_ports_lock_);
+    auto it = pending_child_tokens_.find(from_node);
+    if (it != pending_child_tokens_.end()) {
+      std::string token = std::move(it->second);
+      pending_child_tokens_.erase(it);
+      pending_child_tokens_[child_name] = std::move(token);
+    }
+  }
+
   scoped_refptr<NodeChannel> channel = it->second;
   pending_children_.erase(it);
 
   DCHECK(channel);
 
   DVLOG(1) << "Parent " << name_ << " accepted child " << child_name;
 
   AddPeer(child_name, channel, false /* start_channel */);
 
   // TODO(rockot/amistry): We could simplify child initialization if we could
@@ skipping 198 matching lines @@
   ports::PortRef local_port;
   {
     base::AutoLock lock(reserved_ports_lock_);
     auto it = reserved_ports_.find(token);
     if (it == reserved_ports_.end()) {
       DVLOG(1) << "Ignoring request to connect to port for unknown token "
                << token;
       return;
     }
     local_port = it->second.port;
+    reserved_ports_.erase(it);
   }
 
   int rv = node_->MergePorts(local_port, from_node, connector_port_name);
   if (rv != ports::OK)
     DLOG(ERROR) << "MergePorts failed: " << rv;
 
   AcceptIncomingMessages();
 }
 
 void NodeController::OnRequestIntroduction(const ports::NodeName& from_node,
@@ skipping 280 matching lines @@
 NodeController::PeerConnection::~PeerConnection() = default;
 
 NodeController::PeerConnection& NodeController::PeerConnection::
 operator=(const PeerConnection& other) = default;
 
 NodeController::PeerConnection& NodeController::PeerConnection::
 operator=(PeerConnection&& other) = default;
 
 }  // namespace edk
 }  // namespace mojo