Move const PortName data out of header file

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 432 matching lines @@
 
   channel->AcceptChild(name_, token);
 }
 
 void NodeController::ConnectToParentOnIOThread(
     ScopedPlatformHandle platform_handle) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   {
     base::AutoLock lock(parent_lock_);
-    DCHECK(parent_name_ == ports::kInvalidNodeName);
+    DCHECK(parent_name_ == ports::constants::kInvalidNodeName);
 
     // At this point we don't know the parent's name, so we can't yet insert it
     // into our |peers_| map. That will happen as soon as we receive an
     // AcceptChild message from them.
     bootstrap_parent_channel_ =
         NodeChannel::Create(this, std::move(platform_handle), io_task_runner_,
                             ProcessErrorCallback());
     // Prevent the parent pipe handle from being closed on shutdown. Pipe
     // closure is used by the parent to detect the child process has exited.
     // Relying on message pipes to be closed is not enough because the parent
@@ skipping 60 matching lines @@
     broker_name = broker_name_;
   }
   return GetPeerChannel(broker_name);
 }
 
 void NodeController::AddPeer(const ports::NodeName& name,
                              scoped_refptr<NodeChannel> channel,
                              bool start_channel) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
-  DCHECK(name != ports::kInvalidNodeName);
+  DCHECK(name != ports::constants::kInvalidNodeName);
   DCHECK(channel);
 
   channel->SetRemoteNodeName(name);
 
   OutgoingMessageQueue pending_messages;
   {
     base::AutoLock lock(peers_lock_);
     if (peers_.find(name) != peers_.end()) {
       // This can happen normally if two nodes race to be introduced to each
       // other. The losing pipe will be silently closed and introduction should
@@ skipping 124 matching lines @@
     }
   }
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
   if (channel_message->has_mach_ports()) {
     // Messages containing Mach ports are always routed through the broker, even
     // if the broker process is the intended recipient.
     bool use_broker = false;
     {
       base::AutoLock lock(parent_lock_);
       use_broker = (bootstrap_parent_channel_ ||
-                    parent_name_ != ports::kInvalidNodeName);
+                    parent_name_ != ports::constants::kInvalidNodeName);
     }
     if (use_broker) {
       scoped_refptr<NodeChannel> broker = GetBrokerChannel();
       if (broker) {
         broker->RelayPortsMessage(name, std::move(channel_message));
       } else {
         base::AutoLock lock(broker_lock_);
         pending_relay_messages_[name].emplace(std::move(channel_message));
       }
       return;
@@ skipping 184 matching lines @@
 }
 
 void NodeController::OnAcceptChild(const ports::NodeName& from_node,
                                    const ports::NodeName& parent_name,
                                    const ports::NodeName& token) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   scoped_refptr<NodeChannel> parent;
   {
     base::AutoLock lock(parent_lock_);
-    if (bootstrap_parent_channel_ && parent_name_ == ports::kInvalidNodeName) {
+    if (bootstrap_parent_channel_ &&
+        parent_name_ == ports::constants::kInvalidNodeName) {
       parent_name_ = parent_name;
       parent = bootstrap_parent_channel_;
     }
   }
 
   if (!parent) {
     DLOG(ERROR) << "Unexpected AcceptChild message from " << from_node;
     DropPeer(from_node, nullptr);
     return;
   }
@@ skipping 140 matching lines @@
 
   std::queue<ports::NodeName> pending_broker_clients;
   std::unordered_map<ports::NodeName, OutgoingMessageQueue>
       pending_relay_messages;
   {
     base::AutoLock lock(broker_lock_);
     broker_name_ = broker_name;
     std::swap(pending_broker_clients, pending_broker_clients_);
     std::swap(pending_relay_messages, pending_relay_messages_);
   }
-  DCHECK(broker_name != ports::kInvalidNodeName);
+  DCHECK(broker_name != ports::constants::kInvalidNodeName);
 
   // It's now possible to add both the broker and the parent as peers.
   // Note that the broker and parent may be the same node.
   scoped_refptr<NodeChannel> broker;
   if (broker_name == parent_name) {
     DCHECK(!broker_channel.is_valid());
     broker = parent;
   } else {
     DCHECK(broker_channel.is_valid());
     broker = NodeChannel::Create(this, std::move(broker_channel),
@@ skipping 85 matching lines @@
     DLOG(ERROR) << "MergePorts failed: " << rv;
 
   AcceptIncomingMessages();
 }
 
 void NodeController::OnRequestIntroduction(const ports::NodeName& from_node,
                                            const ports::NodeName& name) {
   DCHECK(io_task_runner_->RunsTasksOnCurrentThread());
 
   scoped_refptr<NodeChannel> requestor = GetPeerChannel(from_node);
-  if (from_node == name || name == ports::kInvalidNodeName || !requestor) {
+  if (from_node == name || name == ports::constants::kInvalidNodeName ||
+      !requestor) {
     DLOG(ERROR) << "Rejecting invalid OnRequestIntroduction message from "
                 << from_node;
     DropPeer(from_node, nullptr);
     return;
   }
 
   scoped_refptr<NodeChannel> new_friend = GetPeerChannel(name);
   if (!new_friend) {
     // We don't know who they're talking about!
     requestor->Introduce(name, ScopedPlatformHandle());
@@ skipping 188 matching lines @@
         base::Bind(&NodeController::OnChannelError, base::Unretained(this),
                    from_node, channel));
   }
 }
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
 MachPortRelay* NodeController::GetMachPortRelay() {
   {
     base::AutoLock lock(parent_lock_);
     // Return null if we're not the root.
-    if (bootstrap_parent_channel_ || parent_name_ != ports::kInvalidNodeName)
+    if (bootstrap_parent_channel_ ||
+        parent_name_ != ports::constants::kInvalidNodeName)
       return nullptr;
   }
 
   base::AutoLock lock(mach_port_relay_lock_);
   return mach_port_relay_.get();
 }
 #endif
 
 void NodeController::CancelPendingPortMerges() {
   std::vector<ports::PortRef> ports_to_close;
@@ skipping 56 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