Fixing the behavior of the candidate filter with pooled candidates.

webrtc/p2p/client/basicportallocator_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 947 matching lines @@
 TEST_F(BasicPortAllocatorTest, TestGetAllPortsRestarts) {
   AddInterface(kClientAddr);
   EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
   session_->StartGettingPorts();
   EXPECT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout);
   EXPECT_EQ(4U, ports_.size());
   EXPECT_TRUE(candidate_allocation_done_);
   // TODO(deadbeef): Extend this to verify ICE restart.
 }
 
+// Test that the allocator session uses the candidate filter it's created with,
+// rather than the filter of its parent allocator.
+// The filter of the allocator should only affect the next gathering phase,
+// according to JSEP, which means the *next* allocator session returned.
+TEST_F(BasicPortAllocatorTest, TestSessionUsesOwnCandidateFilter) {
+  AddInterface(kClientAddr);
+  EXPECT_TRUE(CreateSession(cricket::ICE_CANDIDATE_COMPONENT_RTP));
+  // Set candidate filter *after* creating the session. Should have no effect.
+  allocator().set_candidate_filter(cricket::CF_RELAY);
+  session_->StartGettingPorts();
+  EXPECT_EQ_WAIT(7U, candidates_.size(), kDefaultAllocationTimeout);
+  EXPECT_EQ(4U, ports_.size());
+  EXPECT_TRUE(candidate_allocation_done_);
+}
+
 // Test ICE candidate filter mechanism with options Relay/Host/Reflexive.
 // This test also verifies that when the allocator is only allowed to use
 // relay (i.e. IceTransportsType is relay), the raddr is an empty
 // address with the correct family. This is to prevent any local
 // reflective address leakage in the sdp line.
 TEST_F(BasicPortAllocatorTest, TestCandidateFilterWithRelayOnly) {
   AddInterface(kClientAddr);
   // GTURN is not configured here.
   ResetWithTurnServersNoNat(kTurnUdpIntAddr, rtc::SocketAddress());
   allocator().set_candidate_filter(cricket::CF_RELAY);
@@ skipping 513 matching lines @@
     EXPECT_EQ(1, port->component());
     EXPECT_EQ(kIceUfrag0, port->username_fragment());
     EXPECT_EQ(kIcePwd0, port->password());
   }
   for (const cricket::Candidate& candidate : candidates) {
     EXPECT_EQ(1, candidate.component());
     EXPECT_EQ(kIceUfrag0, candidate.username());
     EXPECT_EQ(kIcePwd0, candidate.password());
   }
 }
+
+// Test that a new candidate filter takes effect even on already-gathered
+// candidates.
+TEST_F(BasicPortAllocatorTest, TestSetCandidateFilterAfterCandidatesGathered) {
+  AddInterface(kClientAddr);
+  int pool_size = 1;
+  allocator_->SetConfiguration(allocator_->stun_servers(),
+                               allocator_->turn_servers(), pool_size);
+  const cricket::PortAllocatorSession* peeked_session =
+      allocator_->GetPooledSession();
+  ASSERT_NE(nullptr, peeked_session);
+  EXPECT_EQ_WAIT(true, peeked_session->CandidatesAllocationDone(),
+                 kDefaultAllocationTimeout);
+  size_t initial_candidates_size = peeked_session->ReadyCandidates().size();
+  size_t initial_ports_size = peeked_session->ReadyPorts().size();
+  allocator_->set_candidate_filter(cricket::CF_RELAY);
+  // Assume that when TakePooledSession is called, the candidate filter will be
+  // applied to the pooled session. This is tested by PortAllocatorTest.
+  session_ =
+      allocator_->TakePooledSession(kContentName, 1, kIceUfrag0, kIcePwd0);
+  ASSERT_NE(nullptr, session_.get());
+  auto candidates = session_->ReadyCandidates();
+  // Check that the number of candidates and ports decreased.
+  EXPECT_GT(initial_candidates_size, candidates.size());
+  EXPECT_GT(initial_ports_size, session_->ReadyPorts().size());
+  for (size_t i = 0; i < candidates.size(); ++i) {
+    // Expect only relay candidates now that the filter is applied.
+    EXPECT_EQ(std::string(cricket::RELAY_PORT_TYPE), candidates[i].type());
+    // Expect that the raddr is emptied due to the CF_RELAY filter.
+    EXPECT_EQ(
+        candidates[0].related_address(),
+        rtc::EmptySocketAddressWithFamily(candidates[0].address().family()));
+  }
+}