Revert of TransportController refactoring.

talk/session/media/channelmanager_unittest.cc

 /*
  * libjingle
  * Copyright 2008 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 14 matching lines @@
  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "talk/app/webrtc/mediacontroller.h"
 #include "talk/media/base/fakecapturemanager.h"
 #include "talk/media/base/fakemediaengine.h"
 #include "talk/media/base/fakemediaprocessor.h"
 #include "talk/media/base/testutils.h"
 #include "talk/media/devices/fakedevicemanager.h"
 #include "talk/media/webrtc/fakewebrtccall.h"
+#include "webrtc/p2p/base/fakesession.h"
 #include "talk/session/media/channelmanager.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/thread.h"
-#include "webrtc/p2p/base/faketransportcontroller.h"
 
 namespace cricket {
 
 static const AudioCodec kAudioCodecs[] = {
   AudioCodec(97, "voice", 1, 2, 3, 0),
   AudioCodec(111, "OPUS", 48000, 32000, 2, 0),
 };
 
 static const VideoCodec kVideoCodecs[] = {
   VideoCodec(99, "H264", 100, 200, 300, 0),
   VideoCodec(100, "VP8", 100, 200, 300, 0),
   VideoCodec(96, "rtx", 100, 200, 300, 0),
 };
 
 class FakeMediaController : public webrtc::MediaControllerInterface {
  public:
   explicit FakeMediaController(webrtc::Call* call) : call_(call) {
     RTC_DCHECK(nullptr != call);
   }
   ~FakeMediaController() override {}
   webrtc::Call* call_w() override { return call_; }
-
  private:
   webrtc::Call* call_;
 };
 
 class ChannelManagerTest : public testing::Test {
  protected:
-  ChannelManagerTest()
-      : fake_call_(webrtc::Call::Config()),
-        fake_mc_(&fake_call_),
-        fme_(NULL),
-        fdm_(NULL),
-        fcm_(NULL),
-        cm_(NULL) {}
+  ChannelManagerTest() : fake_call_(webrtc::Call::Config()),
+      fake_mc_(&fake_call_), fme_(NULL), fdm_(NULL), fcm_(NULL), cm_(NULL) {}
 
   virtual void SetUp() {
     fme_ = new cricket::FakeMediaEngine();
     fme_->SetAudioCodecs(MAKE_VECTOR(kAudioCodecs));
     fme_->SetVideoCodecs(MAKE_VECTOR(kVideoCodecs));
     fdme_ = new cricket::FakeDataEngine();
     fdm_ = new cricket::FakeDeviceManager();
     fcm_ = new cricket::FakeCaptureManager();
     cm_ = new cricket::ChannelManager(
         fme_, fdme_, fdm_, fcm_, rtc::Thread::Current());
-    transport_controller_ =
-        new cricket::FakeTransportController(ICEROLE_CONTROLLING);
+    session_ = new cricket::FakeSession(true);
 
     std::vector<std::string> in_device_list, out_device_list, vid_device_list;
     in_device_list.push_back("audio-in1");
     in_device_list.push_back("audio-in2");
     out_device_list.push_back("audio-out1");
     out_device_list.push_back("audio-out2");
     vid_device_list.push_back("video-in1");
     vid_device_list.push_back("video-in2");
     fdm_->SetAudioInputDevices(in_device_list);
     fdm_->SetAudioOutputDevices(out_device_list);
     fdm_->SetVideoCaptureDevices(vid_device_list);
   }
 
   virtual void TearDown() {
-    delete transport_controller_;
+    delete session_;
     delete cm_;
     cm_ = NULL;
     fdm_ = NULL;
     fcm_ = NULL;
     fdme_ = NULL;
     fme_ = NULL;
   }
 
   rtc::Thread worker_;
   cricket::FakeCall fake_call_;
   cricket::FakeMediaController fake_mc_;
   cricket::FakeMediaEngine* fme_;
   cricket::FakeDataEngine* fdme_;
   cricket::FakeDeviceManager* fdm_;
   cricket::FakeCaptureManager* fcm_;
   cricket::ChannelManager* cm_;
-  cricket::FakeTransportController* transport_controller_;
+  cricket::FakeSession* session_;
 };
 
 // Test that we startup/shutdown properly.
 TEST_F(ChannelManagerTest, StartupShutdown) {
   EXPECT_FALSE(cm_->initialized());
   EXPECT_EQ(rtc::Thread::Current(), cm_->worker_thread());
   EXPECT_TRUE(cm_->Init());
   EXPECT_TRUE(cm_->initialized());
   cm_->Terminate();
   EXPECT_FALSE(cm_->initialized());
@@ skipping 10 matching lines @@
   EXPECT_TRUE(cm_->initialized());
   // Setting the worker thread while initialized should fail.
   EXPECT_FALSE(cm_->set_worker_thread(rtc::Thread::Current()));
   cm_->Terminate();
   EXPECT_FALSE(cm_->initialized());
 }
 
 // Test that we can create and destroy a voice and video channel.
 TEST_F(ChannelManagerTest, CreateDestroyChannels) {
   EXPECT_TRUE(cm_->Init());
-  cricket::VoiceChannel* voice_channel =
-      cm_->CreateVoiceChannel(&fake_mc_, transport_controller_,
-                              cricket::CN_AUDIO, false, AudioOptions());
+  cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
+      &fake_mc_, session_, cricket::CN_AUDIO, false, AudioOptions());
   EXPECT_TRUE(voice_channel != nullptr);
-  cricket::VideoChannel* video_channel =
-      cm_->CreateVideoChannel(&fake_mc_, transport_controller_,
-                              cricket::CN_VIDEO, false, VideoOptions());
+  cricket::VideoChannel* video_channel = cm_->CreateVideoChannel(
+      &fake_mc_, session_, cricket::CN_VIDEO, false, VideoOptions());
   EXPECT_TRUE(video_channel != nullptr);
-  cricket::DataChannel* data_channel = cm_->CreateDataChannel(
-      transport_controller_, cricket::CN_DATA, false, cricket::DCT_RTP);
+  cricket::DataChannel* data_channel =
+      cm_->CreateDataChannel(session_, cricket::CN_DATA,
+                             false, cricket::DCT_RTP);
   EXPECT_TRUE(data_channel != nullptr);
   cm_->DestroyVideoChannel(video_channel);
   cm_->DestroyVoiceChannel(voice_channel);
   cm_->DestroyDataChannel(data_channel);
   cm_->Terminate();
 }
 
 // Test that we can create and destroy a voice and video channel with a worker.
 TEST_F(ChannelManagerTest, CreateDestroyChannelsOnThread) {
   worker_.Start();
   EXPECT_TRUE(cm_->set_worker_thread(&worker_));
   EXPECT_TRUE(cm_->Init());
-  delete transport_controller_;
-  transport_controller_ =
-      new cricket::FakeTransportController(&worker_, ICEROLE_CONTROLLING);
-  cricket::VoiceChannel* voice_channel =
-      cm_->CreateVoiceChannel(&fake_mc_, transport_controller_,
-                              cricket::CN_AUDIO, false, AudioOptions());
+  delete session_;
+  session_ = new cricket::FakeSession(&worker_, true);
+  cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
+      &fake_mc_, session_, cricket::CN_AUDIO, false, AudioOptions());
   EXPECT_TRUE(voice_channel != nullptr);
-  cricket::VideoChannel* video_channel =
-      cm_->CreateVideoChannel(&fake_mc_, transport_controller_,
-                              cricket::CN_VIDEO, false, VideoOptions());
+  cricket::VideoChannel* video_channel = cm_->CreateVideoChannel(
+      &fake_mc_, session_, cricket::CN_VIDEO, false, VideoOptions());
   EXPECT_TRUE(video_channel != nullptr);
-  cricket::DataChannel* data_channel = cm_->CreateDataChannel(
-      transport_controller_, cricket::CN_DATA, false, cricket::DCT_RTP);
+  cricket::DataChannel* data_channel =
+      cm_->CreateDataChannel(session_, cricket::CN_DATA,
+                             false, cricket::DCT_RTP);
   EXPECT_TRUE(data_channel != nullptr);
   cm_->DestroyVideoChannel(video_channel);
   cm_->DestroyVoiceChannel(voice_channel);
   cm_->DestroyDataChannel(data_channel);
   cm_->Terminate();
 }
 
 // Test that we fail to create a voice/video channel if the session is unable
 // to create a cricket::TransportChannel
 TEST_F(ChannelManagerTest, NoTransportChannelTest) {
   EXPECT_TRUE(cm_->Init());
-  transport_controller_->set_fail_channel_creation(true);
+  session_->set_fail_channel_creation(true);
   // The test is useless unless the session does not fail creating
   // cricket::TransportChannel.
-  ASSERT_TRUE(transport_controller_->CreateTransportChannel_w(
+  ASSERT_TRUE(session_->CreateChannel(
                   "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP) == nullptr);
 
-  cricket::VoiceChannel* voice_channel =
-      cm_->CreateVoiceChannel(&fake_mc_, transport_controller_,
-                              cricket::CN_AUDIO, false, AudioOptions());
+  cricket::VoiceChannel* voice_channel = cm_->CreateVoiceChannel(
+      &fake_mc_, session_, cricket::CN_AUDIO, false, AudioOptions());
   EXPECT_TRUE(voice_channel == nullptr);
-  cricket::VideoChannel* video_channel =
-      cm_->CreateVideoChannel(&fake_mc_, transport_controller_,
-                              cricket::CN_VIDEO, false, VideoOptions());
+  cricket::VideoChannel* video_channel = cm_->CreateVideoChannel(
+      &fake_mc_, session_, cricket::CN_VIDEO, false, VideoOptions());
   EXPECT_TRUE(video_channel == nullptr);
-  cricket::DataChannel* data_channel = cm_->CreateDataChannel(
-      transport_controller_, cricket::CN_DATA, false, cricket::DCT_RTP);
+  cricket::DataChannel* data_channel =
+      cm_->CreateDataChannel(session_, cricket::CN_DATA,
+                             false, cricket::DCT_RTP);
   EXPECT_TRUE(data_channel == nullptr);
   cm_->Terminate();
 }
 
 // Test that SetDefaultVideoCodec passes through the right values.
 TEST_F(ChannelManagerTest, SetDefaultVideoEncoderConfig) {
   cricket::VideoCodec codec(96, "G264", 1280, 720, 60, 0);
   cricket::VideoEncoderConfig config(codec, 1, 2);
   EXPECT_TRUE(cm_->Init());
   EXPECT_TRUE(cm_->SetDefaultVideoEncoderConfig(config));
@@ skipping 382 matching lines @@
   EXPECT_FALSE(cm_->SetVideoRtxEnabled(false));
 
   // Can set again after terminate.
   cm_->Terminate();
   EXPECT_TRUE(cm_->SetVideoRtxEnabled(true));
   cm_->GetSupportedVideoCodecs(&codecs);
   EXPECT_TRUE(ContainsMatchingCodec(codecs, rtx_codec));
 }
 
 }  // namespace cricket