Update the type and cost of existing networks if its type is found later by network monitor

webrtc/p2p/base/port.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 57 matching lines @@
 // Computes our estimate of the RTT given the current estimate.
 inline int ConservativeRTTEstimate(int rtt) {
   return std::max(MINIMUM_RTT, std::min(MAXIMUM_RTT, 2 * rtt));
 }
 
 // Weighting of the old rtt value to new data.
 const int RTT_RATIO = 3;  // 3 : 1
 
 // The delay before we begin checking if this port is useless.
 const int kPortTimeoutDelay = 30 * 1000;  // 30 seconds
-}
+}  // namespace
 
 namespace cricket {
 
 // TODO(ronghuawu): Use "host", "srflx", "prflx" and "relay". But this requires
 // the signaling part be updated correspondingly as well.
 const char LOCAL_PORT_TYPE[] = "local";
 const char STUN_PORT_TYPE[] = "stun";
 const char PRFLX_PORT_TYPE[] = "prflx";
 const char RELAY_PORT_TYPE[] = "relay";
 
@@ skipping 100 matching lines @@
 void Port::Construct() {
   // TODO(pthatcher): Remove this old behavior once we're sure no one
   // relies on it.  If the username_fragment and password are empty,
   // we should just create one.
   if (ice_username_fragment_.empty()) {
     ASSERT(password_.empty());
     ice_username_fragment_ = rtc::CreateRandomString(ICE_UFRAG_LENGTH);
     password_ = rtc::CreateRandomString(ICE_PWD_LENGTH);
   }
   network_->SignalInactive.connect(this, &Port::OnNetworkInactive);
-  // TODO(honghaiz): Make it configurable from user setting.
-  network_cost_ =
-      (network_->type() == rtc::ADAPTER_TYPE_CELLULAR) ? kMaxNetworkCost : 0;
+  network_->SignalNetworkTypeChanged.connect(this, &Port::OnNetworkTypeChanged);
+  network_cost_ = network_->GetCost();
 
-  LOG_J(LS_INFO, this) << "Port created";
+  LOG_J(LS_INFO, this) << "Port created with network cost " << network_cost_;
 }
 
 Port::~Port() {
   // Delete all of the remaining connections.  We copy the list up front
   // because each deletion will cause it to be modified.
 
   std::vector<Connection*> list;
 
   AddressMap::iterator iter = connections_.begin();
   while (iter != connections_.end()) {
@@ skipping 411 matching lines @@
   if (dead()) {
     Destroy();
   }
 }
 
 void Port::OnNetworkInactive(const rtc::Network* network) {
   ASSERT(network == network_);
   SignalNetworkInactive(this);
 }
 
+void Port::OnNetworkTypeChanged(const rtc::Network* network) {
+  ASSERT(network == network_);
+
+  UpdateNetworkCost();
+}
+
 std::string Port::ToString() const {
   std::stringstream ss;
   ss << "Port[" << std::hex << this << std::dec << ":" << content_name_ << ":"
      << component_ << ":" << generation_ << ":" << type_ << ":"
      << network_->ToString() << "]";
   return ss.str();
 }
 
+// TODO(honghaiz): Make the network cost configurable from user setting.
+void Port::UpdateNetworkCost() {
+  uint16_t new_cost = network_->GetCost();
+  if (network_cost_ == new_cost) {
+    return;
+  }
+  LOG(LS_INFO) << "Network cost changed from " << network_cost_
+               << " to " << new_cost
+               << ". Number of candidates created: " << candidates_.size()
+               << ". Number of connections created: " << connections_.size();
+  network_cost_ = new_cost;
+  for (cricket::Candidate& candidate : candidates_) {
+    candidate.set_network_cost(network_cost_);
+  }
+  // Network cost change will affect the connection selection criteria.
+  // Signal the network cost change if any connection has been created.
+  if (!connections_.empty()) {
+    SignalNetworkCostChanged(this);
+  }
+}
+
 void Port::EnablePortPackets() {
   enable_port_packets_ = true;
 }
 
 void Port::OnConnectionDestroyed(Connection* conn) {
   AddressMap::iterator iter =
       connections_.find(conn->remote_candidate().address());
   ASSERT(iter != connections_.end());
   connections_.erase(iter);
 
@@ skipping 335 matching lines @@
   }
 
   if (port_->GetIceRole() == ICEROLE_CONTROLLED) {
     const StunByteStringAttribute* use_candidate_attr =
         msg->GetByteString(STUN_ATTR_USE_CANDIDATE);
     if (use_candidate_attr) {
       set_nominated(true);
       SignalNominated(this);
     }
   }
+  // Set the remote cost if the network_info attribute is available.
+  const StunUInt32Attribute* network_attr =
+      msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
+  if (network_attr) {
+    uint32_t network_info = network_attr->value();
+    uint16_t network_cost = static_cast<uint16_t>(network_info);
+    if (network_cost != remote_candidate_.network_cost()) {
+      remote_candidate_.set_network_cost(network_cost);
+      // Network cost change will affect the connection ranking, so signal
+      // state change so that the transport channel will re-sort connections.
+      SignalStateChange(this);

[pthatcher1, 2016/05/17 21:23:11]

If we always send the cost, then this could cause issues when packets get
reordered.  It's not a very big deal, but we should note it.

[honghaiz3, 2016/05/18 07:41:47]

Added note at the beginning of the added code. 

+    }
+  }
 }
 
 void Connection::OnReadyToSend() {
   if (write_state_ == STATE_WRITABLE) {
     SignalReadyToSend(this);
   }
 }
 
 void Connection::Prune() {
   if (!pruned_ || active()) {
@@ skipping 150 matching lines @@
 }
 
 std::string Connection::ToDebugId() const {
   std::stringstream ss;
   ss << std::hex << this;
   return ss.str();
 }
 
 uint32_t Connection::ComputeNetworkCost() const {
   // TODO(honghaiz): Will add rtt as part of the network cost.
-  return local_candidate().network_cost() + remote_candidate_.network_cost();
+  return port()->network_cost() + remote_candidate_.network_cost();
 }
 
 std::string Connection::ToString() const {
   const char CONNECT_STATE_ABBREV[2] = {
     '-',  // not connected (false)
     'C',  // connected (true)
   };
   const char RECEIVE_STATE_ABBREV[2] = {
     '-',  // not receiving (false)
     'R',  // receiving (true)
@@ skipping 270 matching lines @@
     ASSERT(sent < 0);
     error_ = port_->GetError();
     sent_packets_discarded_++;
   } else {
     send_rate_tracker_.AddSamples(sent);
   }
   return sent;
 }
 
 }  // namespace cricket