Move const PortName data out of header file

mojo/edk/system/ports/node.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/ports/node.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 390 matching lines @@
   return rv;
 }
 
 int Node::LostConnectionToNode(const NodeName& node_name) {
   // We can no longer send events to the given node. We also can't expect any
   // PortAccepted events.
 
   DVLOG(1) << "Observing lost connection from node " << name_
            << " to node " << node_name;
 
-  DestroyAllPortsWithPeer(node_name, kInvalidPortName);
+  DestroyAllPortsWithPeer(node_name, constants::kInvalidPortName);
   return OK;
 }
 
 int Node::OnUserMessage(ScopedMessage message) {
   PortName port_name = GetEventHeader(*message)->port_name;
   const auto* event = GetEventData<UserEventData>(*message);
 
 #if DCHECK_IS_ON()
   std::ostringstream ports_buf;
   for (size_t i = 0; i < message->num_ports(); ++i) {
@@ skipping 80 matching lines @@
 
   DVLOG(2) << "PortAccepted at " << port_name << "@" << name_
            << " pointing to "
            << port->peer_port_name << "@" << port->peer_node_name;
 
   return BeginProxying(PortRef(port_name, port));
 }
 
 int Node::OnObserveProxy(const PortName& port_name,
                          const ObserveProxyEventData& event) {
-  if (port_name == kInvalidPortName) {
+  if (port_name == constants::kInvalidPortName) {
     // An ObserveProxy with an invalid target port name is a broadcast used to
     // inform ports when their peer (which was itself a proxy) has become
     // defunct due to unexpected node disconnection.
     //
     // Receiving ports affected by this treat it as equivalent to peer closure.
     // Proxies affected by this can be removed and will in turn broadcast their
     // own death with a similar message.
-    CHECK_EQ(event.proxy_to_node_name, kInvalidNodeName);
-    CHECK_EQ(event.proxy_to_port_name, kInvalidPortName);
+    CHECK_EQ(event.proxy_to_node_name, constants::kInvalidNodeName);
+    CHECK_EQ(event.proxy_to_port_name, constants::kInvalidPortName);
     DestroyAllPortsWithPeer(event.proxy_node_name, event.proxy_port_name);
     return OK;
   }
 
   // The port may have already been closed locally, in which case the
   // ObserveClosure message will contain the last_sequence_num field.
   // We can then silently ignore this message.
   scoped_refptr<Port> port = GetPort(port_name);
   if (!port) {
     DVLOG(1) << "ObserveProxy: " << port_name << "@" << name_ << " not found";
@@ skipping 754 matching lines @@
 
   {
     base::AutoLock ports_lock(ports_lock_);
 
     for (auto iter = ports_.begin(); iter != ports_.end(); ++iter) {
       Port* port = iter->second.get();
       {
         base::AutoLock port_lock(port->lock);
 
         if (port->peer_node_name == node_name &&
-              (port_name == kInvalidPortName ||
-                    port->peer_port_name == port_name)) {
+            (port_name == constants::kInvalidPortName ||
+             port->peer_port_name == port_name)) {
           if (!port->peer_closed) {
             // Treat this as immediate peer closure. It's an exceptional
             // condition akin to a broken pipe, so we don't care about losing
             // messages.
 
             port->peer_closed = true;
             port->last_sequence_num_to_receive =
                 port->message_queue.next_sequence_num() - 1;
 
             if (port->state == Port::kReceiving)
@@ skipping 23 matching lines @@
 
   // Wake up any receiving ports who have just observed simulated peer closure.
   for (const auto& port : ports_to_notify)
     delegate_->PortStatusChanged(port);
 
   for (const auto& proxy_name : dead_proxies_to_broadcast) {
     // Broadcast an event signifying that this proxy is no longer functioning.
     ObserveProxyEventData event;
     event.proxy_node_name = name_;
     event.proxy_port_name = proxy_name;
-    event.proxy_to_node_name = kInvalidNodeName;
-    event.proxy_to_port_name = kInvalidPortName;
+    event.proxy_to_node_name = constants::kInvalidNodeName;
+    event.proxy_to_port_name = constants::kInvalidPortName;
     delegate_->BroadcastMessage(NewInternalMessage(
-        kInvalidPortName, EventType::kObserveProxy, event));
+        constants::kInvalidPortName, EventType::kObserveProxy, event));
 
     // Also process death locally since the port that points this closed one
     // could be on the current node.
     // Note: Although this is recursive, only a single port is involved which
     // limits the expected branching to 1.
     DestroyAllPortsWithPeer(name_, proxy_name);
   }
 
   // Close any ports referenced by the closed proxies.
   for (const auto& name : referenced_port_names) {
@@ skipping 17 matching lines @@
 
   if (num_data_bytes)
     memcpy(header + 1, data, num_data_bytes);
 
   return message;
 }
 
 }  // namespace ports
 }  // namespace edk
 }  // namespace mojo