Remove obosolete SessionId setter/getter from PortAllocator.

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.
  */
 
 #include <memory>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/p2p/base/fakeportallocator.h"
 #include "webrtc/p2p/base/portallocator.h"
 
-static const char kSessionId[] = "session id";
 static const char kContentName[] = "test content";
 // Based on ICE_UFRAG_LENGTH
 static const char kIceUfrag[] = "UF00";
 // Based on ICE_PWD_LENGTH
 static const char kIcePwd[] = "TESTICEPWD00000000000000";
 static const char kTurnUsername[] = "test";
 static const char kTurnPassword[] = "test";
 
 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);
   }
 
   std::unique_ptr<cricket::FakePortAllocatorSession> CreateSession(
-      const std::string& sid,
       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_
-                ->CreateSession(sid, content_name, component, ice_ufrag,
-                                ice_pwd)
+                ->CreateSession(content_name, component, ice_ufrag, ice_pwd)
                 .release()));
   }
 
   const cricket::FakePortAllocatorSession* GetPooledSession() const {
     return static_cast<const cricket::FakePortAllocatorSession*>(
         allocator_->GetPooledSession());
   }
 
   std::unique_ptr<cricket::FakePortAllocatorSession> TakePooledSession() {
     return std::unique_ptr<cricket::FakePortAllocatorSession>(
@@ skipping 26 matching lines @@
   EXPECT_EQ(0UL, allocator_->stun_servers().size());
   EXPECT_EQ(0UL, allocator_->turn_servers().size());
   EXPECT_EQ(0, allocator_->candidate_pool_size());
   EXPECT_EQ(0, GetAllPooledSessionsReturnCount());
 }
 
 // Call CreateSession and verify that the parameters passed in and the
 // candidate filter are applied as expected.
 TEST_F(PortAllocatorTest, CreateSession) {
   allocator_->set_candidate_filter(cricket::CF_RELAY);
-  auto session = CreateSession(kSessionId, kContentName, 1, kIceUfrag, kIcePwd);
+  auto session = CreateSession(kContentName, 1, kIceUfrag, kIcePwd);
   ASSERT_NE(nullptr, session);
   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};
@@ skipping 129 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());
 }