Add 16-bit network id to the candidate signaling.

webrtc/p2p/base/p2ptransportchannel.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 596 matching lines @@
     if (!priority_attr) {
       LOG(LS_WARNING) << "P2PTransportChannel::OnUnknownAddress - "
                       << "No STUN_ATTR_PRIORITY found in the "
                       << "stun request message";
       port->SendBindingErrorResponse(stun_msg, address, STUN_ERROR_BAD_REQUEST,
                                      STUN_ERROR_REASON_BAD_REQUEST);
       return;
     }
     int remote_candidate_priority = priority_attr->value();
 
-    const StunUInt32Attribute* cost_attr =
-        stun_msg->GetUInt32(STUN_ATTR_NETWORK_COST);
-    uint32_t network_cost = (cost_attr) ? cost_attr->value() : 0;
+    uint16_t network_id = 0;
+    uint16_t network_cost = 0;
+    const StunUInt32Attribute* network_attr =
+        stun_msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
+    if (network_attr) {
+      uint32_t network_info = network_attr->value();
+      network_id = static_cast<uint16_t>(network_info >> 16);
+      network_cost = static_cast<uint16_t>(network_info);
+    } else {
+      // TODO(honghaiz): Delete this once no client sends this attribute.
+      const StunUInt32Attribute* cost_attr =
+          stun_msg->GetUInt32(STUN_ATTR_NETWORK_COST);
+      network_cost =
+          (cost_attr) ? static_cast<uint16_t>(cost_attr->value()) : 0;

[pthatcher1, 2016/03/21 17:49:24]

Why can't we just have it be the same attribute, but fill in more bytes with the
network ID?  

[honghaiz3, 2016/03/22 16:30:03]

If a new client talks to an old client, the old  client will treat the new
client' ID+cost as cost. 
Perhaps it may not be a big issue as not so many clients have implemented the
network cost yet.

[pthatcher1, 2016/03/22 21:12:09]

I think since the network cost is signalled, and this is really just for
peer-reflexive candidates, and since hardly any clients using this have been
deployed, we can safely switch over.

[honghaiz3, 2016/03/23 18:59:33]

Done.

+    }
 
     // RFC 5245
     // If the source transport address of the request does not match any
     // existing remote candidates, it represents a new peer reflexive remote
     // candidate.
-    remote_candidate = Candidate(component(), ProtoToString(proto), address, 0,
-                                 remote_username, remote_password,
-                                 PRFLX_PORT_TYPE, remote_generation, "");
+    remote_candidate = Candidate(
+        component(), ProtoToString(proto), address, remote_candidate_priority,
+        remote_username, remote_password, PRFLX_PORT_TYPE, remote_generation,
+        "", network_id, network_cost);
 
     // From RFC 5245, section-7.2.1.3:
     // The foundation of the candidate is set to an arbitrary value, different
     // from the foundation for all other remote candidates.
     remote_candidate.set_foundation(
         rtc::ToString<uint32_t>(rtc::ComputeCrc32(remote_candidate.id())));
-    remote_candidate.set_priority(remote_candidate_priority);
-    remote_candidate.set_network_cost(network_cost);
   }
 
   // RFC5245, the agent constructs a pair whose local candidate is equal to
   // the transport address on which the STUN request was received, and a
   // remote candidate equal to the source transport address where the
   // request came from.
 
   // There shouldn't be an existing connection with this remote address.
   // When ports are muxed, this channel might get multiple unknown address
   // signals. In that case if the connection is already exists, we should
@@ skipping 968 matching lines @@
 
   // During the initial state when nothing has been pinged yet, return the first
   // one in the ordered |connections_|.
   return *(std::find_if(connections_.begin(), connections_.end(),
                         [conn1, conn2](Connection* conn) {
                           return conn == conn1 || conn == conn2;
                         }));
 }
 
 }  // namespace cricket