Don't allow changing ICE pool size after SetLocalDescription.

webrtc/p2p/base/portallocator_unittest.cc

 /*
  *  Copyright 2016 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 14 matching lines @@
 
 class PortAllocatorTest : public testing::Test, public sigslot::has_slots<> {
  public:
   PortAllocatorTest() {
     allocator_.reset(
         new cricket::FakePortAllocator(rtc::Thread::Current(), nullptr));
   }
 
  protected:
   void SetConfigurationWithPoolSize(int candidate_pool_size) {
-    allocator_->SetConfiguration(cricket::ServerAddresses(),
-                                 std::vector<cricket::RelayServerConfig>(),
-                                 candidate_pool_size, false);
+    EXPECT_TRUE(allocator_->SetConfiguration(
+        cricket::ServerAddresses(), std::vector<cricket::RelayServerConfig>(),
+        candidate_pool_size, false));
+  }
+
+  void SetConfigurationWithPoolSizeExpectFailure(int candidate_pool_size) {
+    EXPECT_FALSE(allocator_->SetConfiguration(
+        cricket::ServerAddresses(), std::vector<cricket::RelayServerConfig>(),
+        candidate_pool_size, false));
   }
 
   std::unique_ptr<cricket::FakePortAllocatorSession> CreateSession(
       const std::string& content_name,
       int component,
       const std::string& ice_ufrag,
       const std::string& ice_pwd) {
     return std::unique_ptr<cricket::FakePortAllocatorSession>(
         static_cast<cricket::FakePortAllocatorSession*>(
             allocator_
@@ skipping 49 matching lines @@
   EXPECT_EQ(cricket::CF_RELAY, session->candidate_filter());
   EXPECT_EQ(kContentName, session->content_name());
   EXPECT_EQ(1, session->component());
   EXPECT_EQ(kIceUfrag, session->ice_ufrag());
   EXPECT_EQ(kIcePwd, session->ice_pwd());
 }
 
 TEST_F(PortAllocatorTest, SetConfigurationUpdatesIceServers) {
   cricket::ServerAddresses stun_servers_1 = {stun_server_1};
   std::vector<cricket::RelayServerConfig> turn_servers_1 = {turn_server_1};
-  allocator_->SetConfiguration(stun_servers_1, turn_servers_1, 0, false);
+  EXPECT_TRUE(
+      allocator_->SetConfiguration(stun_servers_1, turn_servers_1, 0, false));
   EXPECT_EQ(stun_servers_1, allocator_->stun_servers());
   EXPECT_EQ(turn_servers_1, allocator_->turn_servers());
 
   // Update with a different set of servers.
   cricket::ServerAddresses stun_servers_2 = {stun_server_2};
   std::vector<cricket::RelayServerConfig> turn_servers_2 = {turn_server_2};
-  allocator_->SetConfiguration(stun_servers_2, turn_servers_2, 0, false);
+  EXPECT_TRUE(
+      allocator_->SetConfiguration(stun_servers_2, turn_servers_2, 0, false));
   EXPECT_EQ(stun_servers_2, allocator_->stun_servers());
   EXPECT_EQ(turn_servers_2, allocator_->turn_servers());
 }
 
 TEST_F(PortAllocatorTest, SetConfigurationUpdatesCandidatePoolSize) {
   SetConfigurationWithPoolSize(2);
   EXPECT_EQ(2, allocator_->candidate_pool_size());
   SetConfigurationWithPoolSize(3);
   EXPECT_EQ(3, allocator_->candidate_pool_size());
   SetConfigurationWithPoolSize(1);
   EXPECT_EQ(1, allocator_->candidate_pool_size());
   SetConfigurationWithPoolSize(4);
   EXPECT_EQ(4, allocator_->candidate_pool_size());
 }
 
 // A negative pool size should just be treated as zero.
-TEST_F(PortAllocatorTest, SetConfigurationWithNegativePoolSizeDoesntCrash) {
-  SetConfigurationWithPoolSize(-1);
-  // No asserts; we're just testing that this doesn't crash.
+TEST_F(PortAllocatorTest, SetConfigurationWithNegativePoolSizeFails) {
+  SetConfigurationWithPoolSizeExpectFailure(-1);
 }
 
 // Test that if the candidate pool size is nonzero, pooled sessions are
 // created, and StartGettingPorts is called on them.
 TEST_F(PortAllocatorTest, SetConfigurationCreatesPooledSessions) {
   SetConfigurationWithPoolSize(2);
   auto session_1 = TakePooledSession();
   auto session_2 = TakePooledSession();
   ASSERT_NE(nullptr, session_1.get());
   ASSERT_NE(nullptr, session_2.get());
@@ skipping 11 matching lines @@
 }
 
 // Test that if the candidate pool size is reduced, extra sessions are
 // destroyed.
 TEST_F(PortAllocatorTest, SetConfigurationDestroysPooledSessions) {
   SetConfigurationWithPoolSize(2);
   SetConfigurationWithPoolSize(1);
   EXPECT_EQ(1, GetAllPooledSessionsReturnCount());
 }
 
-// Test that if the candidate pool size is reduced and increased, but reducing
-// didn't actually destroy any sessions (because they were already given away),
-// increasing the size to its initial value doesn't create a new session.
-TEST_F(PortAllocatorTest, SetConfigurationDoesntCreateExtraSessions) {
+// Test that after the pool starts to be drained, changing the pool size is not
+// allowed.
+TEST_F(PortAllocatorTest, CantChangePoolSizeAfterTakePooledSession) {
   SetConfigurationWithPoolSize(1);
   TakePooledSession();
-  SetConfigurationWithPoolSize(0);
-  SetConfigurationWithPoolSize(1);
-  EXPECT_EQ(0, GetAllPooledSessionsReturnCount());
+  SetConfigurationWithPoolSizeExpectFailure(2);
+  SetConfigurationWithPoolSizeExpectFailure(0);
 }
 
-// According to JSEP, exising pooled sessions should be destroyed and new
+// According to JSEP, existing pooled sessions should be destroyed and new
 // ones created when the ICE servers change.
 TEST_F(PortAllocatorTest,
        SetConfigurationRecreatesPooledSessionsWhenIceServersChange) {
   cricket::ServerAddresses stun_servers_1 = {stun_server_1};
   std::vector<cricket::RelayServerConfig> turn_servers_1 = {turn_server_1};
   allocator_->SetConfiguration(stun_servers_1, turn_servers_1, 1, false);
   EXPECT_EQ(stun_servers_1, allocator_->stun_servers());
   EXPECT_EQ(turn_servers_1, allocator_->turn_servers());
 
   // Update with a different set of servers (and also change pool size).
@@ skipping 48 matching lines @@
 // unfiltered until it's returned by TakePooledSession.
 TEST_F(PortAllocatorTest, TakePooledSessionUpdatesCandidateFilter) {
   allocator_->set_candidate_filter(cricket::CF_RELAY);
   SetConfigurationWithPoolSize(1);
   auto peeked_session = GetPooledSession();
   ASSERT_NE(nullptr, peeked_session);
   EXPECT_EQ(cricket::CF_ALL, peeked_session->candidate_filter());
   auto session = TakePooledSession();
   EXPECT_EQ(cricket::CF_RELAY, session->candidate_filter());
 }