Make Port (and subclasses) fully "Network"-based, instead of IP-based.

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.
  */
 
+#include <list>
 #include <memory>
 
 #include "webrtc/p2p/base/basicpacketsocketfactory.h"
 #include "webrtc/p2p/base/jseptransport.h"
 #include "webrtc/p2p/base/relayport.h"
 #include "webrtc/p2p/base/stunport.h"
 #include "webrtc/p2p/base/tcpport.h"
 #include "webrtc/p2p/base/testrelayserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/p2p/base/testturnserver.h"
@@ skipping 81 matching lines @@
   return msg->Write(buf);
 }
 
 // Stub port class for testing STUN generation and processing.
 class TestPort : public Port {
  public:
   TestPort(rtc::Thread* thread,
            const std::string& type,
            rtc::PacketSocketFactory* factory,
            rtc::Network* network,
-           const rtc::IPAddress& ip,
            uint16_t min_port,
            uint16_t max_port,
            const std::string& username_fragment,
            const std::string& password)
       : Port(thread,
              type,
              factory,
              network,
-             ip,
              min_port,
              max_port,
              username_fragment,
              password) {}
   ~TestPort() {}
 
   // Expose GetStunMessage so that we can test it.
   using cricket::Port::GetStunMessage;
 
   // The last StunMessage that was sent on this Port.
   // TODO: Make these const; requires changes to SendXXXXResponse.
   Buffer* last_stun_buf() { return last_stun_buf_.get(); }
   IceMessage* last_stun_msg() { return last_stun_msg_.get(); }
   int last_stun_error_code() {
     int code = 0;
     if (last_stun_msg_) {
       const StunErrorCodeAttribute* error_attr = last_stun_msg_->GetErrorCode();
       if (error_attr) {
         code = error_attr->code();
       }
     }
     return code;
   }
 
   virtual void PrepareAddress() {
-    rtc::SocketAddress addr(ip(), min_port());
+    // Act as if the socket was bound to the best IP on the network, to the
+    // first port in the allowed range.
+    rtc::SocketAddress addr(Network()->GetBestIP(), min_port());
     AddAddress(addr, addr, rtc::SocketAddress(), "udp", "", "", Type(),
                ICE_TYPE_PREFERENCE_HOST, 0, "", true);
   }
 
   virtual bool SupportsProtocol(const std::string& protocol) const {
     return true;
   }
 
   virtual ProtocolType GetProtocol() const { return PROTO_UDP; }
 
@@ skipping 217 matching lines @@
   std::string remote_frag_;
   bool nominated_;
   bool connection_ready_to_send_ = false;
 };
 
 class PortTest : public testing::Test, public sigslot::has_slots<> {
  public:
   PortTest()
       : ss_(new rtc::VirtualSocketServer()),
         main_(ss_.get()),
-        network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
         socket_factory_(rtc::Thread::Current()),
         nat_factory1_(ss_.get(), kNatAddr1, SocketAddress()),
         nat_factory2_(ss_.get(), kNatAddr2, SocketAddress()),
         nat_socket_factory1_(&nat_factory1_),
         nat_socket_factory2_(&nat_factory2_),
         stun_server_(TestStunServer::Create(&main_, kStunAddr)),
         turn_server_(&main_, kTurnUdpIntAddr, kTurnUdpExtAddr),
         relay_server_(&main_,
                       kRelayUdpIntAddr,
                       kRelayUdpExtAddr,
                       kRelayTcpIntAddr,
                       kRelayTcpExtAddr,
                       kRelaySslTcpIntAddr,
                       kRelaySslTcpExtAddr),
         username_(rtc::CreateRandomString(ICE_UFRAG_LENGTH)),
         password_(rtc::CreateRandomString(ICE_PWD_LENGTH)),
         role_conflict_(false),
         ports_destroyed_(0) {
-    network_.AddIP(rtc::IPAddress(INADDR_ANY));
   }
 
  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);
   }
@@ skipping 61 matching lines @@
                      rtype == RELAY_GTURN, false, true, true);
   }
   void TestSslTcpToRelay(RelayType rtype, ProtocolType proto) {
     Port* port1 = CreateTcpPort(kLocalAddr1);
     port1->SetIceRole(cricket::ICEROLE_CONTROLLING);
     Port* port2 = CreateRelayPort(kLocalAddr2, rtype, proto, PROTO_SSLTCP);
     port2->SetIceRole(cricket::ICEROLE_CONTROLLED);
     TestConnectivity("ssltcp", port1, RelayName(rtype, proto), port2,
                      rtype == RELAY_GTURN, false, true, true);
   }
+
+  rtc::Network* MakeNetwork(const SocketAddress& addr) {
+    networks_.emplace_back("unittest", "unittest", addr.ipaddr(), 32);
+    networks_.back().AddIP(addr.ipaddr());
+    return &networks_.back();
+  }
+
   // helpers for above functions
   UDPPort* CreateUdpPort(const SocketAddress& addr) {
     return CreateUdpPort(addr, &socket_factory_);
   }
   UDPPort* CreateUdpPort(const SocketAddress& addr,
                          PacketSocketFactory* socket_factory) {
-    return UDPPort::Create(&main_, socket_factory, &network_, addr.ipaddr(), 0,
-                           0, username_, password_, std::string(), true);
+    return UDPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
+                           username_, password_, std::string(), true);
   }
   TCPPort* CreateTcpPort(const SocketAddress& addr) {
     return CreateTcpPort(addr, &socket_factory_);
   }
   TCPPort* CreateTcpPort(const SocketAddress& addr,
                         PacketSocketFactory* socket_factory) {
-    return TCPPort::Create(&main_, socket_factory, &network_,
-                           addr.ipaddr(), 0, 0, username_, password_,
-                           true);
+    return TCPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
+                           username_, password_, true);
   }
   StunPort* CreateStunPort(const SocketAddress& addr,
                            rtc::PacketSocketFactory* factory) {
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
-    return StunPort::Create(&main_, factory, &network_,
-                            addr.ipaddr(), 0, 0,
-                            username_, password_, stun_servers,
-                            std::string());
+    return StunPort::Create(&main_, factory, MakeNetwork(addr), 0, 0, username_,
+                            password_, stun_servers, std::string());
   }
   Port* CreateRelayPort(const SocketAddress& addr, RelayType rtype,
                         ProtocolType int_proto, ProtocolType ext_proto) {
     if (rtype == RELAY_TURN) {
       return CreateTurnPort(addr, &socket_factory_, int_proto, ext_proto);
     } else {
       return CreateGturnPort(addr, int_proto, ext_proto);
     }
   }
   TurnPort* CreateTurnPort(const SocketAddress& addr,
                            PacketSocketFactory* socket_factory,
                            ProtocolType int_proto, ProtocolType ext_proto) {
     SocketAddress server_addr =
         int_proto == PROTO_TCP ? kTurnTcpIntAddr : kTurnUdpIntAddr;
     return CreateTurnPort(addr, socket_factory, int_proto, ext_proto,
                           server_addr);
   }
   TurnPort* CreateTurnPort(const SocketAddress& addr,
                            PacketSocketFactory* socket_factory,
                            ProtocolType int_proto, ProtocolType ext_proto,
                            const rtc::SocketAddress& server_addr) {
-    return TurnPort::Create(&main_, socket_factory, &network_, addr.ipaddr(), 0,
-                            0, username_, password_,
+    return TurnPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
+                            username_, password_,
                             ProtocolAddress(server_addr, int_proto),
                             kRelayCredentials, 0, std::string());
   }
   RelayPort* CreateGturnPort(const SocketAddress& addr,
                              ProtocolType int_proto, ProtocolType ext_proto) {
     RelayPort* port = CreateGturnPort(addr);
     SocketAddress addrs[] =
         { kRelayUdpIntAddr, kRelayTcpIntAddr, kRelaySslTcpIntAddr };
     port->AddServerAddress(ProtocolAddress(addrs[int_proto], int_proto));
     return port;
   }
   RelayPort* CreateGturnPort(const SocketAddress& addr) {
     // TODO(pthatcher):  Remove GTURN.
     // Generate a username with length of 16 for Gturn only.
     std::string username = rtc::CreateRandomString(kGturnUserNameLength);
-    return RelayPort::Create(&main_, &socket_factory_, &network_, addr.ipaddr(),
-                             0, 0, username, password_);
+    return RelayPort::Create(&main_, &socket_factory_, MakeNetwork(addr), 0, 0,
+                             username, password_);
     // TODO: Add an external address for ext_proto, so that the
     // other side can connect to this port using a non-UDP protocol.
   }
   rtc::NATServer* CreateNatServer(const SocketAddress& addr,
                                         rtc::NATType type) {
     return new rtc::NATServer(type, ss_.get(), addr, addr, ss_.get(), addr);
   }
   static const char* StunName(NATType type) {
     switch (type) {
       case NAT_OPEN_CONE:
@@ skipping 31 matching lines @@
         case PROTO_SSLTCP:
           return "gturn(ssltcp)";
         case PROTO_TLS:
           return "gturn(tls)";
         default:
           return "gturn(?)";
       }
     }
   }
 
-  void SetNetworkType(rtc::AdapterType adapter_type) {
-    network_.set_type(adapter_type);
-  }
-
   void TestCrossFamilyPorts(int type);
 
   void ExpectPortsCanConnect(bool can_connect, Port* p1, Port* p2);
 
   // This does all the work and then deletes |port1| and |port2|.
   void TestConnectivity(const char* name1, Port* port1,
                         const char* name2, Port* port2,
                         bool accept, bool same_addr1,
                         bool same_addr2, bool possible);
 
@@ skipping 140 matching lines @@
   IceMessage* CreateStunMessageWithUsername(int type,
                                             const std::string& username) {
     IceMessage* msg = CreateStunMessage(type);
     msg->AddAttribute(
         rtc::MakeUnique<StunByteStringAttribute>(STUN_ATTR_USERNAME, username));
     return msg;
   }
   TestPort* CreateTestPort(const rtc::SocketAddress& addr,
                            const std::string& username,
                            const std::string& password) {
-    TestPort* port =  new TestPort(&main_, "test", &socket_factory_, &network_,
-                                   addr.ipaddr(), 0, 0, username, password);
+    TestPort* port = new TestPort(&main_, "test", &socket_factory_,
+                                  MakeNetwork(addr), 0, 0, username, password);
     port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
     return port;
   }
   TestPort* CreateTestPort(const rtc::SocketAddress& addr,
                            const std::string& username,
                            const std::string& password,
                            cricket::IceRole role,
                            int tiebreaker) {
     TestPort* port = CreateTestPort(addr, username, password);
     port->SetIceRole(role);
     port->SetIceTiebreaker(tiebreaker);
     return port;
   }
+  // Overload to create a test port given an rtc::Network directly.
+  TestPort* CreateTestPort(rtc::Network* network,
+                           const std::string& username,
+                           const std::string& password) {
+    TestPort* port = new TestPort(&main_, "test", &socket_factory_, network, 0,
+                                  0, username, password);
+    port->SignalRoleConflict.connect(this, &PortTest::OnRoleConflict);
+    return port;
+  }
 
   void OnRoleConflict(PortInterface* port) {
     role_conflict_ = true;
   }
   bool role_conflict() const { return role_conflict_; }
 
   void ConnectToSignalDestroyed(PortInterface* port) {
     port->SignalDestroyed.connect(this, &PortTest::OnDestroyed);
   }
 
   void OnDestroyed(PortInterface* port) { ++ports_destroyed_; }
   int ports_destroyed() const { return ports_destroyed_; }
 
   rtc::BasicPacketSocketFactory* nat_socket_factory1() {
     return &nat_socket_factory1_;
   }
 
   rtc::VirtualSocketServer* vss() { return ss_.get(); }
 
  private:
+  // When a "create port" helper method is called with an IP, we create a
+  // Network with that IP and add it to this list. Using a list instead of a
+  // vector so that when it grows, pointers aren't invalidated.
+  std::list<rtc::Network> networks_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::AutoSocketServerThread main_;
-  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_;
@@ skipping 1109 matching lines @@
   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. Also tests that
 // the remote network costs are updated with the stun binding requests.
 TEST_F(PortTest, TestNetworkCostChange) {
+  rtc::Network* test_network = MakeNetwork(kLocalAddr1);
   std::unique_ptr<TestPort> lport(
-      CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
+      CreateTestPort(test_network, "lfrag", "lpass"));
   std::unique_ptr<TestPort> rport(
-      CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
+      CreateTestPort(test_network, "rfrag", "rpass"));
   lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
   lport->SetIceTiebreaker(kTiebreaker1);
   rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
   rport->SetIceTiebreaker(kTiebreaker2);
   lport->PrepareAddress();
   rport->PrepareAddress();
 
   // Default local port cost is rtc::kNetworkCostUnknown.
   EXPECT_EQ(rtc::kNetworkCostUnknown, lport->network_cost());
   ASSERT_TRUE(!lport->Candidates().empty());
   for (const cricket::Candidate& candidate : lport->Candidates()) {
     EXPECT_EQ(rtc::kNetworkCostUnknown, candidate.network_cost());
   }
 
   // Change the network type to wifi.
-  SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
+  test_network->set_type(rtc::ADAPTER_TYPE_WIFI);
   EXPECT_EQ(rtc::kNetworkCostLow, lport->network_cost());
   for (const cricket::Candidate& candidate : lport->Candidates()) {
     EXPECT_EQ(rtc::kNetworkCostLow, candidate.network_cost());
   }
 
   // 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);
+  test_network->set_type(rtc::ADAPTER_TYPE_CELLULAR);
   EXPECT_EQ(rtc::kNetworkCostHigh, lport->network_cost());
   for (const cricket::Candidate& candidate : lport->Candidates()) {
     EXPECT_EQ(rtc::kNetworkCostHigh, candidate.network_cost());
   }
 
-  SetNetworkType(rtc::ADAPTER_TYPE_WIFI);
+  test_network->set_type(rtc::ADAPTER_TYPE_WIFI);
   Connection* rconn =
       rport->CreateConnection(lport->Candidates()[0], Port::ORIGIN_MESSAGE);
-  SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
+  test_network->set_type(rtc::ADAPTER_TYPE_CELLULAR);
   lconn->Ping(0);
   // The rconn's remote candidate cost is rtc::kNetworkCostLow, but the ping
   // contains an attribute of network cost of rtc::kNetworkCostHigh. Once the
   // message is handled in rconn, The rconn's remote candidate will have cost
   // rtc::kNetworkCostHigh;
   EXPECT_EQ(rtc::kNetworkCostLow, rconn->remote_candidate().network_cost());
   ASSERT_TRUE_WAIT(lport->last_stun_msg() != NULL, kDefaultTimeout);
   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, kDefaultTimeout);
   EXPECT_EQ(rtc::kNetworkCostHigh, rconn->remote_candidate().network_cost());
 }
 
 TEST_F(PortTest, TestNetworkInfoAttribute) {
+  rtc::Network* test_network = MakeNetwork(kLocalAddr1);
   std::unique_ptr<TestPort> lport(
-      CreateTestPort(kLocalAddr1, "lfrag", "lpass"));
+      CreateTestPort(test_network, "lfrag", "lpass"));
   std::unique_ptr<TestPort> rport(
-      CreateTestPort(kLocalAddr2, "rfrag", "rpass"));
+      CreateTestPort(test_network, "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, kDefaultTimeout);
   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 has unknown type and cost kNetworkCostUnknown.
   EXPECT_EQ(rtc::kNetworkCostUnknown, network_info & 0xFFFF);
 
   // Set the network type to be cellular so its cost will be kNetworkCostHigh.
   // Send a fake ping from rport to lport.
-  SetNetworkType(rtc::ADAPTER_TYPE_CELLULAR);
+  test_network->set_type(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, kDefaultTimeout);
   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();
@@ skipping 845 matching lines @@
       port->CreateConnection(candidate, Port::ORIGIN_MESSAGE);
   EXPECT_NE(conn1, conn2);
   conn_in_use = port->GetConnection(address);
   EXPECT_EQ(conn2, conn_in_use);
   EXPECT_EQ(2u, conn_in_use->remote_candidate().generation());
 
   // Make sure the new connection was not deleted.
   rtc::Thread::Current()->ProcessMessages(300);
   EXPECT_TRUE(port->GetConnection(address) != nullptr);
 }