Delete MediaController class, move Call ownership to PeerConnection.

webrtc/pc/rtpsenderreceiver_unittest.cc

 /*
  *  Copyright 2012 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 <string>
 #include <utility>
 
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/sigslot.h"
 #include "webrtc/logging/rtc_event_log/rtc_event_log.h"
 #include "webrtc/media/base/fakemediaengine.h"
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/engine/fakewebrtccall.h"
 #include "webrtc/p2p/base/faketransportcontroller.h"
 #include "webrtc/pc/audiotrack.h"
 #include "webrtc/pc/channelmanager.h"
-#include "webrtc/pc/fakemediacontroller.h"
 #include "webrtc/pc/localaudiosource.h"
 #include "webrtc/pc/mediastream.h"
 #include "webrtc/pc/remoteaudiosource.h"
 #include "webrtc/pc/rtpreceiver.h"
 #include "webrtc/pc/rtpsender.h"
 #include "webrtc/pc/streamcollection.h"
 #include "webrtc/pc/test/fakevideotracksource.h"
 #include "webrtc/pc/videotrack.h"
 #include "webrtc/pc/videotracksource.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
 
 using ::testing::_;
 using ::testing::Exactly;
 using ::testing::InvokeWithoutArgs;
 using ::testing::Return;
 
 namespace {
 
 static const char kStreamLabel1[] = "local_stream_1";
 static const char kVideoTrackId[] = "video_1";
 static const char kAudioTrackId[] = "audio_1";
 static const uint32_t kVideoSsrc = 98;
 static const uint32_t kVideoSsrc2 = 100;
 static const uint32_t kAudioSsrc = 99;
 static const uint32_t kAudioSsrc2 = 101;
 static const int kDefaultTimeout = 10000;  // 10 seconds.
-
 }  // namespace
 
 namespace webrtc {
 
 class RtpSenderReceiverTest : public testing::Test,
                               public sigslot::has_slots<> {
  public:
   RtpSenderReceiverTest()
       :  // Create fake media engine/etc. so we can create channels to use to
          // test RtpSenders/RtpReceivers.
         media_engine_(new cricket::FakeMediaEngine()),
         channel_manager_(
             std::unique_ptr<cricket::MediaEngineInterface>(media_engine_),
             rtc::Thread::Current(),
             rtc::Thread::Current()),
         fake_call_(Call::Config(&event_log_)),
-        fake_media_controller_(&channel_manager_, &fake_call_),
         local_stream_(MediaStream::Create(kStreamLabel1)) {
     // Create channels to be used by the RtpSenders and RtpReceivers.
     channel_manager_.Init();
     bool srtp_required = true;
     cricket::DtlsTransportInternal* rtp_transport =
         fake_transport_controller_.CreateDtlsTransport(
             cricket::CN_AUDIO, cricket::ICE_CANDIDATE_COMPONENT_RTP);
     voice_channel_ = channel_manager_.CreateVoiceChannel(
-        &fake_media_controller_, rtp_transport, nullptr, rtc::Thread::Current(),
+        &fake_call_, cricket::MediaConfig(),
+        rtp_transport, nullptr, rtc::Thread::Current(),
         cricket::CN_AUDIO, srtp_required, cricket::AudioOptions());
     video_channel_ = channel_manager_.CreateVideoChannel(
-        &fake_media_controller_, rtp_transport, nullptr, rtc::Thread::Current(),
+        &fake_call_, cricket::MediaConfig(),
+        rtp_transport, nullptr, rtc::Thread::Current(),
         cricket::CN_VIDEO, srtp_required, cricket::VideoOptions());
     voice_channel_->Enable(true);
     video_channel_->Enable(true);
     voice_media_channel_ = media_engine_->GetVoiceChannel(0);
     video_media_channel_ = media_engine_->GetVideoChannel(0);
     RTC_CHECK(voice_channel_);
     RTC_CHECK(video_channel_);
     RTC_CHECK(voice_media_channel_);
     RTC_CHECK(video_media_channel_);
 
@@ skipping 152 matching lines @@
     EXPECT_FALSE(video_media_channel_->HasSink(kVideoSsrc));
   }
 
  protected:
   webrtc::RtcEventLogNullImpl event_log_;
   // |media_engine_| is actually owned by |channel_manager_|.
   cricket::FakeMediaEngine* media_engine_;
   cricket::FakeTransportController fake_transport_controller_;
   cricket::ChannelManager channel_manager_;
   cricket::FakeCall fake_call_;
-  cricket::FakeMediaController fake_media_controller_;
   cricket::VoiceChannel* voice_channel_;
   cricket::VideoChannel* video_channel_;
   cricket::FakeVoiceMediaChannel* voice_media_channel_;
   cricket::FakeVideoMediaChannel* video_media_channel_;
   rtc::scoped_refptr<AudioRtpSender> audio_rtp_sender_;
   rtc::scoped_refptr<VideoRtpSender> video_rtp_sender_;
   rtc::scoped_refptr<AudioRtpReceiver> audio_rtp_receiver_;
   rtc::scoped_refptr<VideoRtpReceiver> video_rtp_receiver_;
   rtc::scoped_refptr<MediaStreamInterface> local_stream_;
   rtc::scoped_refptr<VideoTrackInterface> video_track_;
@@ skipping 529 matching lines @@
 // Make sure the signal from "GetOnDestroyedSignal()" fires when the sender is
 // destroyed, which is needed for the DTMF sender.
 TEST_F(RtpSenderReceiverTest, TestOnDestroyedSignal) {
   CreateAudioRtpSender();
   EXPECT_FALSE(audio_sender_destroyed_signal_fired_);
   audio_rtp_sender_ = nullptr;
   EXPECT_TRUE(audio_sender_destroyed_signal_fired_);
 }
 
 }  // namespace webrtc