ice: include tiebreaker in computation of foundation attribute (tests)

split from the actual change for easier review and cherry-picking.

BUG=webrtc:14605

Change-Id: I7dbaf8e1f4a03f35a5d8c4da1a2784b00589bfc3
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/280680
Commit-Queue: Philipp Hancke <phancke@microsoft.com>
Reviewed-by: Jonas Oreland <jonaso@webrtc.org>
Reviewed-by: Harald Alvestrand <hta@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#38519}

p2p/base/fake_port_allocator.h

@@ -109,6 +109,7 @@ class FakePortAllocatorSession : public PortAllocatorSession {
         field_trials_(field_trials) {
     ipv4_network_.AddIP(rtc::IPAddress(INADDR_LOOPBACK));
     ipv6_network_.AddIP(rtc::IPAddress(in6addr_loopback));
+    set_ice_tiebreaker(/*kTiebreakerDefault = */ 44444);
   }
 
   void SetCandidateFilter(uint32_t filter) override {
@@ -125,6 +126,7 @@ class FakePortAllocatorSession : public PortAllocatorSession {
                                       username(), password(), false,
                                       &field_trials_));
       RTC_DCHECK(port_);
+      port_->SetIceTiebreaker(ice_tiebreaker());
       port_->SubscribePortDestroyed(
           [this](PortInterface* port) { OnPortDestroyed(port); });
       AddPort(port_.get());

p2p/base/p2p_transport_channel_unittest.cc

@@ -141,6 +141,7 @@ const cricket::IceParameters kIceParams[4] = {
 
 const uint64_t kLowTiebreaker = 11111;
 const uint64_t kHighTiebreaker = 22222;
+const uint64_t kTiebreakerDefault = 44444;
 
 cricket::IceConfig CreateIceConfig(
     int receiving_timeout,
@@ -300,6 +301,11 @@ class P2PTransportChannelTestBase : public ::testing::Test,
     ep2_.allocator_.reset(CreateBasicPortAllocator(
         &ep2_.network_manager_, ss_.get(), stun_servers, kTurnUdpIntAddr,
         rtc::SocketAddress()));
+
+    ep1_.SetIceTiebreaker(kTiebreakerDefault);
+    ep1_.allocator_->SetIceTiebreaker(kTiebreakerDefault);
+    ep2_.SetIceTiebreaker(kTiebreakerDefault);
+    ep2_.allocator_->SetIceTiebreaker(kTiebreakerDefault);
     webrtc::metrics::Reset();
   }
 
@@ -3476,6 +3482,7 @@ class P2PTransportChannelPingTest : public TestWithParam<std::string>,
  protected:
   void PrepareChannel(P2PTransportChannel* ch) {
     ch->SetIceRole(ICEROLE_CONTROLLING);
+    ch->SetIceTiebreaker(kTiebreakerDefault);
     ch->SetIceParameters(kIceParams[0]);
     ch->SetRemoteIceParameters(kIceParams[1]);
     ch->SignalNetworkRouteChanged.connect(
@@ -3840,6 +3847,7 @@ TEST_P(P2PTransportChannelPingTest, PingingStartedAsSoonAsPossible) {
   FakePortAllocator pa(rtc::Thread::Current(), packet_socket_factory());
   P2PTransportChannel ch("TestChannel", 1, &pa, &field_trials_);
   ch.SetIceRole(ICEROLE_CONTROLLING);
+  ch.SetIceTiebreaker(kTiebreakerDefault);
   ch.SetIceParameters(kIceParams[0]);
   ch.MaybeStartGathering();
   EXPECT_EQ_WAIT(IceGatheringState::kIceGatheringComplete, ch.gathering_state(),

p2p/base/port.cc

@@ -209,6 +209,7 @@ void Port::SetIceRole(IceRole role) {
 void Port::SetIceTiebreaker(uint64_t tiebreaker) {
   tiebreaker_ = tiebreaker;
 }
+
 uint64_t Port::IceTiebreaker() const {
   return tiebreaker_;
 }

p2p/base/port_allocator_unittest.cc

@@ -25,6 +25,7 @@ static const char kIceUfrag[] = "UF00";
 static const char kIcePwd[] = "TESTICEPWD00000000000000";
 static const char kTurnUsername[] = "test";
 static const char kTurnPassword[] = "test";
+constexpr uint64_t kTiebreakerDefault = 44444;
 
 class PortAllocatorTest : public ::testing::Test, public sigslot::has_slots<> {
  public:
@@ -35,7 +36,9 @@ class PortAllocatorTest : public ::testing::Test, public sigslot::has_slots<> {
             std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())),
         allocator_(std::make_unique<cricket::FakePortAllocator>(
             rtc::Thread::Current(),
-            packet_socket_factory_.get())) {}
+            packet_socket_factory_.get())) {
+    allocator_->SetIceTiebreaker(kTiebreakerDefault);
+  }
 
  protected:
   void SetConfigurationWithPoolSize(int candidate_pool_size) {

p2p/base/port_unittest.cc

@@ -105,6 +105,7 @@ const uint32_t kDefaultPrflxPriority = ICE_TYPE_PREFERENCE_PRFLX << 24 |
 
 constexpr int kTiebreaker1 = 11111;
 constexpr int kTiebreaker2 = 22222;
+constexpr int kTiebreakerDefault = 44444;
 
 const char* data = "ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
 
@@ -534,35 +535,44 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
   }
   std::unique_ptr<UDPPort> CreateUdpPort(const SocketAddress& addr,
                                          PacketSocketFactory* socket_factory) {
-    return UDPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
+    auto port = UDPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
                                 username_, password_, true, absl::nullopt,
                                 &field_trials_);
+    port->SetIceTiebreaker(kTiebreakerDefault);
+    return port;
   }
+
   std::unique_ptr<UDPPort> CreateUdpPortMultipleAddrs(
       const SocketAddress& global_addr,
       const SocketAddress& link_local_addr,
       PacketSocketFactory* socket_factory,
       const webrtc::test::ScopedKeyValueConfig& field_trials) {
-    return UDPPort::Create(
+    auto port = UDPPort::Create(
         &main_, socket_factory,
         MakeNetworkMultipleAddrs(global_addr, link_local_addr, &field_trials),
         0, 0, username_, password_, true, absl::nullopt, &field_trials);
+    port->SetIceTiebreaker(kTiebreakerDefault);
+    return port;
   }
   std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr) {
     return CreateTcpPort(addr, &socket_factory_);
   }
   std::unique_ptr<TCPPort> CreateTcpPort(const SocketAddress& addr,
                                          PacketSocketFactory* socket_factory) {
-    return TCPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
+    auto port = TCPPort::Create(&main_, socket_factory, MakeNetwork(addr), 0, 0,
                                 username_, password_, true, &field_trials_);
+    port->SetIceTiebreaker(kTiebreakerDefault);
+    return port;
   }
   std::unique_ptr<StunPort> CreateStunPort(const SocketAddress& addr,
                                            rtc::PacketSocketFactory* factory) {
     ServerAddresses stun_servers;
     stun_servers.insert(kStunAddr);
-    return StunPort::Create(&main_, factory, MakeNetwork(addr), 0, 0, username_,
+    auto port = StunPort::Create(&main_, factory, MakeNetwork(addr), 0, 0,
-                            password_, stun_servers, absl::nullopt,
+                                 username_, password_, stun_servers,
-                            &field_trials_);
+                                 absl::nullopt, &field_trials_);
+    port->SetIceTiebreaker(kTiebreakerDefault);
+    return port;
   }
   std::unique_ptr<Port> CreateRelayPort(const SocketAddress& addr,
                                         ProtocolType int_proto,
@@ -597,7 +607,9 @@ class PortTest : public ::testing::Test, public sigslot::has_slots<> {
     args.config = &config;
     args.field_trials = &field_trials_;
 
-    return TurnPort::Create(args, 0, 0);
+    auto port = TurnPort::Create(args, 0, 0);
+    port->SetIceTiebreaker(kTiebreakerDefault);
+    return port;
   }
 
   std::unique_ptr<rtc::NATServer> CreateNatServer(const SocketAddress& addr,
@@ -1772,6 +1784,7 @@ TEST_F(PortTest, TestUdpMultipleAddressesV6CrossTypePorts) {
     factory.set_next_udp_socket(socket);
     ports[i] = CreateUdpPortMultipleAddrs(addresses[i], kLinkLocalIPv6Addr,
                                           &factory, field_trials);
+    ports[i]->SetIceTiebreaker(kTiebreakerDefault);
     socket->set_state(AsyncPacketSocket::STATE_BINDING);
     socket->SignalAddressReady(socket, addresses[i]);
     ports[i]->PrepareAddress();
@@ -2468,10 +2481,10 @@ TEST_F(PortTest,
 TEST_F(PortTest,
        TestHandleStunResponseWithUnknownComprehensionRequiredAttribute) {
   // Generic setup.
-  auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
+  auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass",
-  lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
+                              cricket::ICEROLE_CONTROLLING, kTiebreakerDefault);
-  auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
+  auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
-  rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
+                              cricket::ICEROLE_CONTROLLED, kTiebreakerDefault);
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
@@ -2505,10 +2518,10 @@ TEST_F(PortTest,
 TEST_F(PortTest,
        TestHandleStunIndicationWithUnknownComprehensionRequiredAttribute) {
   // Generic set up.
-  auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass");
+  auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass",
-  lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
+                              cricket::ICEROLE_CONTROLLING, kTiebreakerDefault);
-  auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
+  auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass",
-  rport->SetIceRole(cricket::ICEROLE_CONTROLLED);
+                              cricket::ICEROLE_CONTROLLED, kTiebreakerDefault);
   lport->PrepareAddress();
   rport->PrepareAddress();
   ASSERT_FALSE(lport->Candidates().empty());
@@ -2530,9 +2543,8 @@ TEST_F(PortTest,
 // Test handling of STUN binding indication messages . STUN binding
 // indications are allowed only to the connection which is in read mode.
 TEST_F(PortTest, TestHandleStunBindingIndication) {
-  auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass");
+  auto lport = CreateTestPort(kLocalAddr2, "lfrag", "lpass",
-  lport->SetIceRole(cricket::ICEROLE_CONTROLLING);
+                              cricket::ICEROLE_CONTROLLING, kTiebreaker1);
-  lport->SetIceTiebreaker(kTiebreaker1);
 
   // Verifying encoding and decoding STUN indication message.
   std::unique_ptr<IceMessage> in_msg, out_msg;
@@ -2586,6 +2598,7 @@ TEST_F(PortTest, TestHandleStunBindingIndication) {
 
 TEST_F(PortTest, TestComputeCandidatePriority) {
   auto port = CreateTestPort(kLocalAddr1, "name", "pass");
+  port->SetIceTiebreaker(kTiebreakerDefault);
   port->set_type_preference(90);
   port->set_component(177);
   port->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
@@ -2623,6 +2636,7 @@ TEST_F(PortTest, TestComputeCandidatePriority) {
 // Test that candidates with different types will have different foundation.
 TEST_F(PortTest, TestFoundation) {
   auto testport = CreateTestPort(kLocalAddr1, "name", "pass");
+  testport->SetIceTiebreaker(kTiebreakerDefault);
   testport->AddCandidateAddress(kLocalAddr1, kLocalAddr1, LOCAL_PORT_TYPE,
                                 cricket::ICE_TYPE_PREFERENCE_HOST, false);
   testport->AddCandidateAddress(kLocalAddr2, kLocalAddr1, STUN_PORT_TYPE,
@@ -2743,8 +2757,11 @@ TEST_F(PortTest, TestCandidatePriority) {
 // Test the Connection priority is calculated correctly.
 TEST_F(PortTest, TestConnectionPriority) {
   auto lport = CreateTestPort(kLocalAddr1, "lfrag", "lpass");
+  lport->SetIceTiebreaker(kTiebreakerDefault);
   lport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_HOST);
+
   auto rport = CreateTestPort(kLocalAddr2, "rfrag", "rpass");
+  rport->SetIceTiebreaker(kTiebreakerDefault);
   rport->set_type_preference(cricket::ICE_TYPE_PREFERENCE_RELAY_UDP);
   lport->set_component(123);
   lport->AddCandidateAddress(SocketAddress("192.168.1.4", 1234));
@@ -3629,6 +3646,7 @@ TEST_F(PortTest, TestSupportsProtocol) {
 // on both the port itself and its candidates.
 TEST_F(PortTest, TestSetIceParameters) {
   auto port = CreateTestPort(kLocalAddr1, "ufrag1", "password1");
+  port->SetIceTiebreaker(kTiebreakerDefault);
   port->PrepareAddress();
   EXPECT_EQ(1UL, port->Candidates().size());
   port->SetIceParameters(1, "ufrag2", "password2");
@@ -3643,6 +3661,7 @@ TEST_F(PortTest, TestSetIceParameters) {
 
 TEST_F(PortTest, TestAddConnectionWithSameAddress) {
   auto port = CreateTestPort(kLocalAddr1, "ufrag1", "password1");
+  port->SetIceTiebreaker(kTiebreakerDefault);
   port->PrepareAddress();
   EXPECT_EQ(1u, port->Candidates().size());
   rtc::SocketAddress address("1.1.1.1", 5000);

p2p/base/regathering_controller_unittest.cc

@@ -39,6 +39,7 @@ const rtc::SocketAddress kTurnUdpIntAddr("99.99.99.3",
 const cricket::RelayCredentials kRelayCredentials("test", "test");
 const char kIceUfrag[] = "UF00";
 const char kIcePwd[] = "TESTICEPWD00000000000000";
+constexpr uint64_t kTiebreakerDefault = 44444;
 
 }  // namespace
 
@@ -56,6 +57,7 @@ class RegatheringControllerTest : public ::testing::Test,
         allocator_(std::make_unique<cricket::FakePortAllocator>(
             rtc::Thread::Current(),
             packet_socket_factory_.get())) {
+    allocator_->SetIceTiebreaker(kTiebreakerDefault);
     BasicRegatheringController::Config regathering_config;
     regathering_config.regather_on_failed_networks_interval = 0;
     regathering_controller_.reset(new BasicRegatheringController(

p2p/base/stun_port_unittest.cc

@@ -59,6 +59,8 @@ static const uint32_t kIPv6StunCandidatePriority =
 static const int kInfiniteLifetime = -1;
 static const int kHighCostPortKeepaliveLifetimeMs = 2 * 60 * 1000;
 
+constexpr uint64_t kTiebreakerDefault = 44444;
+
 // A PacketSocketFactory implementation that uses a mock DnsResolver and allows
 // setting expectations on the resolver and results.
 class MockDnsResolverPacketSocketFactory
@@ -141,6 +143,7 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
         rtc::Thread::Current(), socket_factory(), &network_, 0, 0,
         rtc::CreateRandomString(16), rtc::CreateRandomString(22), stun_servers,
         absl::nullopt, field_trials);
+    stun_port_->SetIceTiebreaker(kTiebreakerDefault);
     stun_port_->set_stun_keepalive_delay(stun_keepalive_delay_);
     // If `stun_keepalive_lifetime_` is negative, let the stun port
     // choose its lifetime from the network type.
@@ -171,6 +174,7 @@ class StunPortTestBase : public ::testing::Test, public sigslot::has_slots<> {
         rtc::CreateRandomString(16), rtc::CreateRandomString(22), false,
         absl::nullopt, field_trials);
     ASSERT_TRUE(stun_port_ != NULL);
+    stun_port_->SetIceTiebreaker(kTiebreakerDefault);
     ServerAddresses stun_servers;
     stun_servers.insert(server_addr);
     stun_port_->set_server_addresses(stun_servers);

p2p/base/tcp_port_unittest.cc

@@ -43,6 +43,8 @@ static const SocketAddress kRemoteAddr("22.22.22.22", 0);
 static const SocketAddress kRemoteIPv6Addr("2401:fa00:4:1000:be30:5bff:fee5:c4",
                                            0);
 
+constexpr uint64_t kTiebreakerDefault = 44444;
+
 class ConnectionObserver : public sigslot::has_slots<> {
  public:
   explicit ConnectionObserver(Connection* conn) : conn_(conn) {
@@ -81,15 +83,19 @@ class TCPPortTest : public ::testing::Test, public sigslot::has_slots<> {
   }
 
   std::unique_ptr<TCPPort> CreateTCPPort(const SocketAddress& addr) {
-    return std::unique_ptr<TCPPort>(
+    auto port = std::unique_ptr<TCPPort>(
         TCPPort::Create(&main_, &socket_factory_, MakeNetwork(addr), 0, 0,
                         username_, password_, true, &field_trials_));
+    port->SetIceTiebreaker(kTiebreakerDefault);
+    return port;
   }
 
   std::unique_ptr<TCPPort> CreateTCPPort(const rtc::Network* network) {
-    return std::unique_ptr<TCPPort>(
+    auto port = std::unique_ptr<TCPPort>(
         TCPPort::Create(&main_, &socket_factory_, network, 0, 0, username_,
                         password_, true, &field_trials_));
+    port->SetIceTiebreaker(kTiebreakerDefault);
+    return port;
   }
 
  protected:

p2p/base/turn_port_unittest.cc

@@ -95,6 +95,8 @@ static constexpr unsigned int kConnectionDestructionDelay = 1;
 // See: https://bugs.chromium.org/p/webrtc/issues/detail?id=5191
 static constexpr unsigned int kResolverTimeout = 10000;
 
+constexpr uint64_t kTiebreakerDefault = 44444;
+
 static const cricket::ProtocolAddress kTurnUdpProtoAddr(kTurnUdpIntAddr,
                                                         cricket::PROTO_UDP);
 static const cricket::ProtocolAddress kTurnTcpProtoAddr(kTurnTcpIntAddr,
@@ -293,6 +295,7 @@ class TurnPortTest : public ::testing::Test,
     }
     // This TURN port will be the controlling.
     turn_port_->SetIceRole(ICEROLE_CONTROLLING);
+    turn_port_->SetIceTiebreaker(kTiebreakerDefault);
     ConnectSignals();
 
     if (server_address.proto == cricket::PROTO_TLS) {
@@ -333,6 +336,7 @@ class TurnPortTest : public ::testing::Test,
     turn_port_ = TurnPort::Create(args, socket_.get());
     // This TURN port will be the controlling.
     turn_port_->SetIceRole(ICEROLE_CONTROLLING);
+    turn_port_->SetIceTiebreaker(kTiebreakerDefault);
     ConnectSignals();
   }
 
@@ -357,6 +361,7 @@ class TurnPortTest : public ::testing::Test,
                                 absl::nullopt, &field_trials_);
     // UDP port will be controlled.
     udp_port_->SetIceRole(ICEROLE_CONTROLLED);
+    udp_port_->SetIceTiebreaker(kTiebreakerDefault);
     udp_port_->SignalPortComplete.connect(this,
                                           &TurnPortTest::OnUdpPortComplete);
   }

p2p/client/basic_port_allocator_unittest.cc

@@ -111,6 +111,8 @@ static const char kTurnPassword[] = "test";
 // Add some margin of error for slow bots.
 static const int kStunTimeoutMs = cricket::STUN_TOTAL_TIMEOUT;
 
+constexpr uint64_t kTiebreakerDefault = 44444;
+
 namespace {
 
 void CheckStunKeepaliveIntervalOfAllReadyPorts(
@@ -174,6 +176,7 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
         stun_servers, &field_trials_);
     allocator_->Initialize();
     allocator_->set_step_delay(kMinimumStepDelay);
+    allocator_->SetIceTiebreaker(kTiebreakerDefault);
     webrtc::metrics::Reset();
   }
 
@@ -212,6 +215,7 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
         &network_manager_,
         std::make_unique<rtc::BasicPacketSocketFactory>(fss_.get())));
     allocator_->Initialize();
+    allocator_->SetIceTiebreaker(kTiebreakerDefault);
     allocator_->set_step_delay(kMinimumStepDelay);
   }
   // Endpoint is behind a NAT, with STUN specified.
@@ -296,6 +300,7 @@ class BasicPortAllocatorTestBase : public ::testing::Test,
         this, &BasicPortAllocatorTestBase::OnCandidatesRemoved);
     session->SignalCandidatesAllocationDone.connect(
         this, &BasicPortAllocatorTestBase::OnCandidatesAllocationDone);
+    session->set_ice_tiebreaker(kTiebreakerDefault);
     return session;
   }
 

pc/peer_connection_ice_unittest.cc

@@ -85,6 +85,7 @@ using ::testing::Values;
 
 constexpr int kIceCandidatesTimeout = 10000;
 constexpr int64_t kWaitTimeout = 10000;
+constexpr uint64_t kTiebreakerDefault = 44444;
 
 class PeerConnectionWrapperForIceTest : public PeerConnectionWrapper {
  public:
@@ -1426,6 +1427,7 @@ class PeerConnectionIceConfigTest : public ::testing::Test {
         new cricket::FakePortAllocator(rtc::Thread::Current(),
                                        packet_socket_factory_.get()));
     port_allocator_ = port_allocator.get();
+    port_allocator_->SetIceTiebreaker(kTiebreakerDefault);
     PeerConnectionDependencies pc_dependencies(&observer_);
     pc_dependencies.allocator = std::move(port_allocator);
     auto result = pc_factory_->CreatePeerConnectionOrError(

pc/peer_connection_interface_unittest.cc

@@ -106,6 +106,7 @@ static const char kVideoTracks[][32] = {"videotrack0", "videotrack1"};
 
 static const char kRecvonly[] = "recvonly";
 static const char kSendrecv[] = "sendrecv";
+constexpr uint64_t kTiebreakerDefault = 44444;
 
 // Reference SDP with a MediaStream with label "stream1" and audio track with
 // id "audio_1" and a video track with id "video_1;
@@ -734,6 +735,7 @@ class PeerConnectionInterfaceBaseTest : public ::testing::Test {
             rtc::Thread::Current(),
             std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get())));
     port_allocator_ = port_allocator.get();
+    port_allocator_->SetIceTiebreaker(kTiebreakerDefault);
 
     // Create certificate generator unless DTLS constraint is explicitly set to
     // false.