Fixing P2PTransportChannelTest.TestIceConfigWillPassDownToPort.

webrtc/p2p/base/p2ptransportchannel_unittest.cc

 /*
  *  Copyright 2009 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 82 matching lines @@
 
 // Based on ICE_UFRAG_LENGTH
 static const char* kIceUfrag[4] = {"UF00", "UF01",
                                    "UF02", "UF03"};
 // Based on ICE_PWD_LENGTH
 static const char* kIcePwd[4] = {"TESTICEPWD00000000000000",
                                  "TESTICEPWD00000000000001",
                                  "TESTICEPWD00000000000002",
                                  "TESTICEPWD00000000000003"};
 
-static const uint64_t kTiebreaker1 = 11111;
-static const uint64_t kTiebreaker2 = 22222;
+static const uint64_t kLowTiebreaker = 11111;
+static const uint64_t kHighTiebreaker = 22222;
 
 enum { MSG_ADD_CANDIDATES, MSG_REMOVE_CANDIDATES };
 
 cricket::IceConfig CreateIceConfig(int receiving_timeout,
                                    bool gather_continually,
                                    int backup_ping_interval = -1) {
   cricket::IceConfig config;
   config.receiving_timeout = receiving_timeout;
   config.gather_continually = gather_continually;
   config.backup_connection_ping_interval = backup_ping_interval;
@@ skipping 521 matching lines @@
                             old_remote_candidate1->generation(),
                             1000, 1000);
     EXPECT_TRUE_WAIT_MARGIN(RemoteCandidate(ep2_ch1())->generation() !=
                             old_remote_candidate2->generation(),
                             1000, 1000);
     EXPECT_EQ(1u, RemoteCandidate(ep2_ch1())->generation());
     EXPECT_EQ(1u, RemoteCandidate(ep1_ch1())->generation());
   }
 
   void TestSignalRoleConflict() {
-    SetIceTiebreaker(0, kTiebreaker1);  // Default EP1 is in controlling state.
+    SetIceTiebreaker(0,
+                     kLowTiebreaker);  // Default EP1 is in controlling state.
 
     SetIceRole(1, ICEROLE_CONTROLLING);
-    SetIceTiebreaker(1, kTiebreaker2);
+    SetIceTiebreaker(1, kHighTiebreaker);
 
     // Creating channels with both channels role set to CONTROLLING.
     CreateChannels(1);
     // Since both the channels initiated with controlling state and channel2
     // has higher tiebreaker value, channel1 should receive SignalRoleConflict.
     EXPECT_TRUE_WAIT(GetRoleConflict(0), 1000);
     EXPECT_FALSE(GetRoleConflict(1));
 
     EXPECT_TRUE_WAIT(ep1_ch1()->receiving() &&
                      ep1_ch1()->writable() &&
@@ skipping 750 matching lines @@
 }
 
 TEST_F(P2PTransportChannelTest, TestIceRoleConflict) {
   AddAddress(0, kPublicAddrs[0]);
   AddAddress(1, kPublicAddrs[1]);
   TestSignalRoleConflict();
 }
 
 // Tests that the ice configs (protocol, tiebreaker and role) can be passed
 // down to ports.
-// Disable on Windows because it is flaky.
-// https://bugs.chromium.org/p/webrtc/issues/detail?id=6019
-#if defined(WEBRTC_WIN)
-#define MAYBE_TestIceConfigWillPassDownToPort \
-  DISABLED_TestIceConfigWillPassDownToPort
-#else
-#define MAYBE_TestIceConfigWillPassDownToPort TestIceConfigWillPassDownToPort
-#endif
-TEST_F(P2PTransportChannelTest, MAYBE_TestIceConfigWillPassDownToPort) {
+TEST_F(P2PTransportChannelTest, TestIceConfigWillPassDownToPort) {
   AddAddress(0, kPublicAddrs[0]);
   AddAddress(1, kPublicAddrs[1]);
 
+  // Give the first connection the higher tiebreaker so its role won't
+  // change unless we tell it to.
   SetIceRole(0, ICEROLE_CONTROLLING);
-  SetIceTiebreaker(0, kTiebreaker1);
+  SetIceTiebreaker(0, kHighTiebreaker);
   SetIceRole(1, ICEROLE_CONTROLLING);
-  SetIceTiebreaker(1, kTiebreaker2);
+  SetIceTiebreaker(1, kLowTiebreaker);
 
   CreateChannels(1);
 
   EXPECT_EQ_WAIT(2u, ep1_ch1()->ports().size(), 1000);
 
   const std::vector<PortInterface*> ports_before = ep1_ch1()->ports();
   for (size_t i = 0; i < ports_before.size(); ++i) {
     EXPECT_EQ(ICEROLE_CONTROLLING, ports_before[i]->GetIceRole());
-    EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker());
+    EXPECT_EQ(kHighTiebreaker, ports_before[i]->IceTiebreaker());
   }
 
   ep1_ch1()->SetIceRole(ICEROLE_CONTROLLED);
-  ep1_ch1()->SetIceTiebreaker(kTiebreaker2);
+  ep1_ch1()->SetIceTiebreaker(kLowTiebreaker);
 
   const std::vector<PortInterface*> ports_after = ep1_ch1()->ports();
   for (size_t i = 0; i < ports_after.size(); ++i) {
     EXPECT_EQ(ICEROLE_CONTROLLED, ports_before[i]->GetIceRole());
     // SetIceTiebreaker after Connect() has been called will fail. So expect the
     // original value.
-    EXPECT_EQ(kTiebreaker1, ports_before[i]->IceTiebreaker());
+    EXPECT_EQ(kHighTiebreaker, ports_before[i]->IceTiebreaker());
   }
 
   EXPECT_TRUE_WAIT(ep1_ch1()->receiving() &&
                    ep1_ch1()->writable() &&
                    ep2_ch1()->receiving() &&
                    ep2_ch1()->writable(),
                    1000);
 
   EXPECT_TRUE(ep1_ch1()->selected_connection() &&
               ep2_ch1()->selected_connection());
@@ skipping 2013 matching lines @@
 
   // TCP Relay/Relay is the next.
   VerifyNextPingableConnection(RELAY_PORT_TYPE, RELAY_PORT_TYPE,
                                TCP_PROTOCOL_NAME);
 
   // Finally, Local/Relay will be pinged.
   VerifyNextPingableConnection(LOCAL_PORT_TYPE, RELAY_PORT_TYPE);
 }
 
 }  // namespace cricket {