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

webrtc/p2p/base/port_unittest.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 28 matching lines @@
 using rtc::ByteBufferReader;
 using rtc::ByteBufferWriter;
 using rtc::NATType;
 using rtc::NAT_OPEN_CONE;
 using rtc::NAT_ADDR_RESTRICTED;
 using rtc::NAT_PORT_RESTRICTED;
 using rtc::NAT_SYMMETRIC;
 using rtc::PacketSocketFactory;
 using rtc::Socket;
 using rtc::SocketAddress;
+using rtc::kMaxNetworkCost;
 using namespace cricket;
 
 static const int kTimeout = 1000;
 static const SocketAddress kLocalAddr1("192.168.1.2", 0);
 static const SocketAddress kLocalAddr2("192.168.1.3", 0);
 static const SocketAddress kNatAddr1("77.77.77.77", rtc::NAT_SERVER_UDP_PORT);
 static const SocketAddress kNatAddr2("88.88.88.88", rtc::NAT_SERVER_UDP_PORT);
 static const SocketAddress kStunAddr("99.99.99.1", STUN_SERVER_PORT);
 static const SocketAddress kRelayUdpIntAddr("99.99.99.2", 5000);
 static const SocketAddress kRelayUdpExtAddr("99.99.99.3", 5001);
 static const SocketAddress kRelayTcpIntAddr("99.99.99.2", 5002);
 static const SocketAddress kRelayTcpExtAddr("99.99.99.3", 5003);
 static const SocketAddress kRelaySslTcpIntAddr("99.99.99.2", 5004);
 static const SocketAddress kRelaySslTcpExtAddr("99.99.99.3", 5005);
 static const SocketAddress kTurnUdpIntAddr("99.99.99.4", STUN_SERVER_PORT);
 static const SocketAddress kTurnTcpIntAddr("99.99.99.4", 5010);
 static const SocketAddress kTurnUdpExtAddr("99.99.99.5", 0);
 static const RelayCredentials kRelayCredentials("test", "test");
+static const uint16_t kCostForUnknownNetworkType = 10;
 
 // TODO: Update these when RFC5245 is completely supported.
 // Magic value of 30 is from RFC3484, for IPv4 addresses.
 static const uint32_t kDefaultPrflxPriority =
     ICE_TYPE_PREFERENCE_PRFLX << 24 | 30 << 8 |
     (256 - ICE_CANDIDATE_COMPONENT_DEFAULT);
 
 static const int kTiebreaker1 = 11111;
 static const int kTiebreaker2 = 22222;
 
@@ skipping 300 matching lines @@
                       kRelayTcpExtAddr,
                       kRelaySslTcpIntAddr,
                       kRelaySslTcpExtAddr),
         username_(rtc::CreateRandomString(ICE_UFRAG_LENGTH)),
         password_(rtc::CreateRandomString(ICE_PWD_LENGTH)),
         role_conflict_(false),
         destroyed_(false) {
     network_.AddIP(rtc::IPAddress(INADDR_ANY));
   }
 
+  void ConnectSignalNeworkCostChangdForPort(PortInterface* port) {
+    port->SignalNetworkCostChanged.connect(this,
+                                           &PortTest::OnPortNetworkCostChanged);
+  }
+
+  void OnPortNetworkCostChanged(PortInterface* port) {
+    port_network_cost_changed_ = true;
+    ;
+  }
+
+  bool port_network_cost_changed() { return port_network_cost_changed_; }
+
  protected:
   void TestLocalToLocal() {
     Port* port1 = CreateUdpPort(kLocalAddr1);
     port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
     Port* port2 = CreateUdpPort(kLocalAddr2);
     port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
     TestConnectivity("udp", port1, "udp", port2, true, true, true, true);
   }
   void TestLocalToStun(NATType ntype) {
     Port* port1 = CreateUdpPort(kLocalAddr1);
@@ skipping 355 matching lines @@
 
   void OnDestroyed(PortInterface* port) {
     destroyed_ = true;
   }
   bool destroyed() const { return destroyed_; }
 
   rtc::BasicPacketSocketFactory* nat_socket_factory1() {
     return &nat_socket_factory1_;
   }
 
- protected:
   rtc::VirtualSocketServer* vss() { return ss_.get(); }
 
  private:
   rtc::Thread* main_;
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
   std::unique_ptr<rtc::NATServer> nat_server1_;
   std::unique_ptr<rtc::NATServer> nat_server2_;
   rtc::NATSocketFactory nat_factory1_;
   rtc::NATSocketFactory nat_factory2_;
   rtc::BasicPacketSocketFactory nat_socket_factory1_;
   rtc::BasicPacketSocketFactory nat_socket_factory2_;
   std::unique_ptr<TestStunServer> stun_server_;
   TestTurnServer turn_server_;
   TestRelayServer relay_server_;
   std::string username_;
   std::string password_;
   bool role_conflict_;
   bool destroyed_;
+  bool port_network_cost_changed_ = false;
 };
 
 void PortTest::TestConnectivity(const char* name1, Port* port1,
                                 const char* name2, Port* port2,
                                 bool accept, bool same_addr1,
                                 bool same_addr2, bool possible) {
   LOG(LS_INFO) << "Test: " << name1 << " to " << name2 << ": ";
   port1->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
   port2->set_component(cricket::ICE_CANDIDATE_COMPONENT_DEFAULT);
 
@@ skipping 960 matching lines @@
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt64Attribute* ice_controlling_attr =
       msg->GetUInt64(STUN_ATTR_ICE_CONTROLLING);
   ASSERT_TRUE(ice_controlling_attr != NULL);
   const StunByteStringAttribute* use_candidate_attr = msg->GetByteString(
       STUN_ATTR_USE_CANDIDATE);
   ASSERT_TRUE(use_candidate_attr != NULL);
 }
 
+// Tests that when the network type changes, the network cost of the port will
+// change, the network cost of the local candidates will change and a signal
+// will be fire to notify the network cost change if there are connections in
+// the port. Also tests that the remote network costs are updated with the stun
+// binding requests.
+TEST_F(PortTest, TestNetworkCostChange) {
+  std::unique_ptr<TestPort> lport(
+      CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
+  std::unique_ptr<TestPort> rport(
+      CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
+  lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
+  lport->SetIceTiebreaker(kTiebreaker1);
+  rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
+  rport->SetIceTiebreaker(kTiebreaker2);
+  lport->PrepareAddress();
+  rport->PrepareAddress();
+  ConnectSignalNeworkCostChangdForPort(lport.get());
+
+  // Default local port cost is kCostForUnknownNetworkType.
+  EXPECT_EQ(kCostForUnknownNetworkType, lport->network_cost());
+  ASSERT_TRUE(!lport->Candidates().empty());
+  for (const cricket::Candidate& candidate : lport->Candidates()) {
+    EXPECT_EQ(kCostForUnknownNetworkType, candidate.network_cost());
+  }
+
+  // Change the network type to wifi.
+  SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
+  EXPECT_EQ(0, lport->network_cost());
+  for (const cricket::Candidate& candidate : lport->Candidates()) {
+    EXPECT_EQ(0u, candidate.network_cost());
+  }
+  // There is no connection yet, should not fire the NetworkCostChanged event.
+  EXPECT_FALSE(port_network_cost_changed());
+
+  // Add a connection and then change the network type.
+  Connection* lconn =
+      lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
+  // Change the network type to cellular.
+  SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
+  EXPECT_EQ(kMaxNetworkCost, lport->network_cost());
+  for (const cricket::Candidate& candidate : lport->Candidates()) {
+    EXPECT_EQ(kMaxNetworkCost, candidate.network_cost());
+  }
+  // Should fire SignalNetworkCostChanged now.
+  EXPECT_TRUE(port_network_cost_changed());
+
+  SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
+  Connection* rconn =
+      rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
+  SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
+  lconn->Ping(0);
+  // The rconn's remote candidate cost is 0, but the ping contains an attribute
+  // of network cost of kMaxNetworkCost. Once the message is handled in rconn,
+  // The rconn's remote candidate will have cost kMaxNetworkCost;
+  EXPECT_EQ(0u, rconn->remote_candidate().network_cost());
+  ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
+  IceMessage* msg = lport->last_stun_msg();
+  EXPECT_EQ(STUN_BINDING_REQUEST, msg->type());
+  // Pass the binding request to rport.
+  rconn->OnReadPacket(lport->last_stun_buf()->data<char>(),
+                      lport->last_stun_buf()->size(), rtc::PacketTime());
+  // Wait until rport sends the response and then check the remote network cost.
+  ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000);
+  EXPECT_EQ(kMaxNetworkCost, rconn->remote_candidate().network_cost());
+}
+
 TEST_F(PortTest, TestNetworkInfoAttribute) {
   std::unique_ptr<TestPort> lport(
       CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
-  // Set the network type for rport to be cellular so its cost will be 999.
-  SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   std::unique_ptr<TestPort> rport(
       CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
 
   uint16_t lnetwork_id = 9;
   lport->Network()->set_id(lnetwork_id);
   // Send a fake ping from lport to rport.
   lport->PrepareAddress();
   rport->PrepareAddress();
   Connection* lconn =
       lport->CreateConnection(rport->Candidates()[0], Port::ORIGIN_MESSAGE);
   lconn->Ping(0);
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, 1000);
   IceMessage* msg = lport->last_stun_msg();
   const StunUInt32Attribute* network_info_attr =
       msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
   ASSERT_TRUE(network_info_attr != NULL);
   uint32_t network_info = network_info_attr->value();
   EXPECT_EQ(lnetwork_id, network_info >> 16);
-  // Default network cost is 0.
-  EXPECT_EQ(0U, network_info & 0xFFFF);
+  // Default network has unknown type and cost |kCostForUnknownNetworkType|.
+  EXPECT_EQ(kCostForUnknownNetworkType, network_info & 0xFFFF);
 
+  // Set the network type to be cellular so its cost will be 999.
   // Send a fake ping from rport to lport.
+  SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
   uint16_t rnetwork_id = 8;
   rport->Network()->set_id(rnetwork_id);
   Connection* rconn =
       rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
   rconn->Ping(0);
   ASSERT_TRUE_WAIT(rport->last_stun_msg() != NULL, 1000);
   msg = rport->last_stun_msg();
   network_info_attr = msg->GetUInt32(STUN_ATTR_NETWORK_INFO);
   ASSERT_TRUE(network_info_attr != NULL);
   network_info = network_info_attr->value();
   EXPECT_EQ(rnetwork_id, network_info >> 16);
-  EXPECT_EQ(cricket::kMaxNetworkCost, network_info & 0xFFFF);
+  EXPECT_EQ(kMaxNetworkCost, network_info & 0xFFFF);
 }
 
 // Test handling STUN messages.
 TEST_F(PortTest, TestHandleStunMessage) {
   // Our port will act as the "remote" port.
   std::unique_ptr<TestPort> port(CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
 
   std::unique_ptr<IceMessage> in_msg, out_msg;
   std::unique_ptr<ByteBufferWriter> buf(new ByteBufferWriter());
   rtc::SocketAddress addr(kLocalAddr1);
@@ skipping 761 matching lines @@
   std::unique_ptr<Port> tcp_port(CreateTcpPort(kLocalAddr1));
   EXPECT_TRUE(tcp_port->SupportsProtocol(TCP_PROTOCOL_NAME));
   EXPECT_TRUE(tcp_port->SupportsProtocol(SSLTCP_PROTOCOL_NAME));
   EXPECT_FALSE(tcp_port->SupportsProtocol(UDP_PROTOCOL_NAME));
 
   std::unique_ptr<Port> turn_port(
       CreateTurnPort(kLocalAddr1, nat_socket_factory1(), PROTO_UDP, PROTO_UDP));
   EXPECT_TRUE(turn_port->SupportsProtocol(UDP_PROTOCOL_NAME));
   EXPECT_FALSE(turn_port->SupportsProtocol(TCP_PROTOCOL_NAME));
 }