Delete MediaController class, move Call ownership to PeerConnection.

webrtc/pc/webrtcsession_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.
  */
 
@@ skipping 23 matching lines @@
 #include "webrtc/media/base/mediachannel.h"
 #include "webrtc/media/engine/fakewebrtccall.h"
 #include "webrtc/media/sctp/sctptransportinternal.h"
 #include "webrtc/p2p/base/packettransportinternal.h"
 #include "webrtc/p2p/base/stunserver.h"
 #include "webrtc/p2p/base/teststunserver.h"
 #include "webrtc/p2p/base/testturnserver.h"
 #include "webrtc/p2p/client/basicportallocator.h"
 #include "webrtc/pc/audiotrack.h"
 #include "webrtc/pc/channelmanager.h"
-#include "webrtc/pc/fakemediacontroller.h"
 #include "webrtc/pc/mediasession.h"
 #include "webrtc/pc/peerconnection.h"
 #include "webrtc/pc/sctputils.h"
 #include "webrtc/pc/test/fakertccertificategenerator.h"
 #include "webrtc/pc/videotrack.h"
 #include "webrtc/pc/webrtcsession.h"
 #include "webrtc/pc/webrtcsessiondescriptionfactory.h"
 
 using cricket::FakeVoiceMediaChannel;
 using cricket::TransportInfo;
@@ skipping 193 matching lines @@
     return last_fake_sctp_transport_;
   }
 
  private:
   FakeSctpTransport* last_fake_sctp_transport_ = nullptr;
 };
 
 class WebRtcSessionForTest : public webrtc::WebRtcSession {
  public:
   WebRtcSessionForTest(
-      webrtc::MediaControllerInterface* media_controller,
+      cricket::ChannelManager* channel_manager,
+      const cricket::MediaConfig& media_config,
+      webrtc::RtcEventLog* event_log,
       rtc::Thread* network_thread,
       rtc::Thread* worker_thread,
       rtc::Thread* signaling_thread,
       cricket::PortAllocator* port_allocator,
       webrtc::IceObserver* ice_observer,
       std::unique_ptr<cricket::TransportController> transport_controller,
-      std::unique_ptr<FakeSctpTransportFactory> sctp_factory)
-      : WebRtcSession(media_controller,
+      std::unique_ptr<FakeSctpTransportFactory> sctp_factory,
+      webrtc::Call*fake_call)
+      : WebRtcSession(channel_manager, media_config, event_log,
                       network_thread,
                       worker_thread,
                       signaling_thread,
                       port_allocator,
                       std::move(transport_controller),
-                      std::move(sctp_factory)) {
+                      std::move(sctp_factory)),
+        fake_call_(fake_call) {
     RegisterIceObserver(ice_observer);
   }
   virtual ~WebRtcSessionForTest() {}
 
   // Note that these methods are only safe to use if the signaling thread
   // is the same as the worker thread
   rtc::PacketTransportInternal* voice_rtp_transport_channel() {
     return rtp_transport_channel(voice_channel());
   }
 
   rtc::PacketTransportInternal* voice_rtcp_transport_channel() {
     return rtcp_transport_channel(voice_channel());
   }
 
   rtc::PacketTransportInternal* video_rtp_transport_channel() {
     return rtp_transport_channel(video_channel());
   }
 
   rtc::PacketTransportInternal* video_rtcp_transport_channel() {
     return rtcp_transport_channel(video_channel());
   }
 
  private:
+  webrtc::Call* call() override {
+    if (fake_call_)
+      return fake_call_;
+    return WebRtcSession::call();
+  }
+
   rtc::PacketTransportInternal* rtp_transport_channel(
       cricket::BaseChannel* ch) {
     if (!ch) {
       return nullptr;
     }
     return ch->rtp_dtls_transport();
   }
 
   rtc::PacketTransportInternal* rtcp_transport_channel(
       cricket::BaseChannel* ch) {
     if (!ch) {
       return nullptr;
     }
     return ch->rtcp_dtls_transport();
   }
+
+  webrtc::Call* fake_call_ = nullptr;
 };
 
 class WebRtcSessionCreateSDPObserverForTest
     : public rtc::RefCountedObject<CreateSessionDescriptionObserver> {
  public:
   enum State {
     kInit,
     kFailed,
     kSucceeded,
   };
@@ skipping 47 matching lines @@
   // TODO Investigate why ChannelManager crashes, if it's created
   // after stun_server.
   WebRtcSessionTest()
       : media_engine_(new cricket::FakeMediaEngine()),
         data_engine_(new cricket::FakeDataEngine()),
         channel_manager_(new cricket::ChannelManager(
             std::unique_ptr<cricket::MediaEngineInterface>(media_engine_),
             std::unique_ptr<cricket::DataEngineInterface>(data_engine_),
             rtc::Thread::Current())),
         fake_call_(webrtc::Call::Config(&event_log_)),
-        media_controller_(
-            webrtc::MediaControllerInterface::Create(cricket::MediaConfig(),
-                                                     rtc::Thread::Current(),
-                                                     channel_manager_.get(),
-                                                     &event_log_)),
         tdesc_factory_(new cricket::TransportDescriptionFactory()),
         desc_factory_(
             new cricket::MediaSessionDescriptionFactory(channel_manager_.get(),
                                                         tdesc_factory_.get())),
         pss_(new rtc::PhysicalSocketServer),
         vss_(new rtc::VirtualSocketServer(pss_.get())),
         fss_(new rtc::FirewallSocketServer(vss_.get())),
         ss_scope_(fss_.get()),
         stun_socket_addr_(
             rtc::SocketAddress(kStunAddrHost, cricket::STUN_SERVER_PORT)),
@@ skipping 21 matching lines @@
     network_manager_.RemoveInterface(addr);
   }
 
   // If |cert_generator| != null or |rtc_configuration| contains |certificates|
   // then DTLS will be enabled unless explicitly disabled by |rtc_configuration|
   // options. When DTLS is enabled a certificate will be used if provided,
   // otherwise one will be generated using the |cert_generator|.
   void Init(
       std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_generator,
       PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy,
-      const rtc::CryptoOptions& crypto_options) {
+      const rtc::CryptoOptions& crypto_options,
+      webrtc::Call* fake_call) {
     ASSERT_TRUE(session_.get() == NULL);
     fake_sctp_transport_factory_ = new FakeSctpTransportFactory();
     session_.reset(new WebRtcSessionForTest(
-        media_controller_.get(), rtc::Thread::Current(), rtc::Thread::Current(),
+        channel_manager_.get(), cricket::MediaConfig(), &event_log_,
+        rtc::Thread::Current(), rtc::Thread::Current(),
         rtc::Thread::Current(), allocator_.get(), &observer_,
         std::unique_ptr<cricket::TransportController>(
             new cricket::TransportController(
                 rtc::Thread::Current(), rtc::Thread::Current(),
                 allocator_.get(),
                 /*redetermine_role_on_ice_restart=*/true, crypto_options)),
         std::unique_ptr<FakeSctpTransportFactory>(
-            fake_sctp_transport_factory_)));
+            fake_sctp_transport_factory_),
+        fake_call));
     session_->SignalDataChannelOpenMessage.connect(
         this, &WebRtcSessionTest::OnDataChannelOpenMessage);
 
     configuration_.rtcp_mux_policy = rtcp_mux_policy;
     EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
         observer_.ice_connection_state_);
     EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
         observer_.ice_gathering_state_);
 
     EXPECT_TRUE(session_->Initialize(options_, std::move(cert_generator),
                                      configuration_));
     session_->set_metrics_observer(metrics_observer_);
     crypto_options_ = crypto_options;
   }
 
   void OnDataChannelOpenMessage(const std::string& label,
                                 const InternalDataChannelInit& config) {
     last_data_channel_label_ = label;
     last_data_channel_config_ = config;
   }
 
   void Init() {
     Init(nullptr, PeerConnectionInterface::kRtcpMuxPolicyNegotiate,
-         rtc::CryptoOptions());
+         rtc::CryptoOptions(), nullptr);
+  }
+
+  void InitWithFakeCall(webrtc::Call* fake_call) {
+    Init(nullptr, PeerConnectionInterface::kRtcpMuxPolicyNegotiate,
+         rtc::CryptoOptions(), fake_call);
   }
 
   void InitWithBundlePolicy(
       PeerConnectionInterface::BundlePolicy bundle_policy) {
     configuration_.bundle_policy = bundle_policy;
     Init();
   }
 
   void InitWithRtcpMuxPolicy(
       PeerConnectionInterface::RtcpMuxPolicy rtcp_mux_policy) {
     PeerConnectionInterface::RTCConfiguration configuration;
-    Init(nullptr, rtcp_mux_policy, rtc::CryptoOptions());
+    Init(nullptr, rtcp_mux_policy, rtc::CryptoOptions(), nullptr);
   }
 
   void InitWithCryptoOptions(const rtc::CryptoOptions& crypto_options) {
     Init(nullptr, PeerConnectionInterface::kRtcpMuxPolicyNegotiate,
-         crypto_options);
+         crypto_options, nullptr);
   }
 
   // Successfully init with DTLS; with a certificate generated and supplied or
   // with a store that generates it for us.
   void InitWithDtls(RTCCertificateGenerationMethod cert_gen_method) {
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator;
     if (cert_gen_method == ALREADY_GENERATED) {
       configuration_.certificates.push_back(
           FakeRTCCertificateGenerator::GenerateCertificate());
     } else if (cert_gen_method == DTLS_IDENTITY_STORE) {
       cert_generator.reset(new FakeRTCCertificateGenerator());
       cert_generator->set_should_fail(false);
     } else {
       RTC_CHECK(false);
     }
     Init(std::move(cert_generator),
          PeerConnectionInterface::kRtcpMuxPolicyNegotiate,
-         rtc::CryptoOptions());
+         rtc::CryptoOptions(), nullptr);
   }
 
   // Init with DTLS with a store that will fail to generate a certificate.
   void InitWithDtlsIdentityGenFail() {
     std::unique_ptr<FakeRTCCertificateGenerator> cert_generator(
         new FakeRTCCertificateGenerator());
     cert_generator->set_should_fail(true);
     Init(std::move(cert_generator),
          PeerConnectionInterface::kRtcpMuxPolicyNegotiate,
-         rtc::CryptoOptions());
+         rtc::CryptoOptions(), nullptr);
   }
 
   void InitWithGcm() {
     rtc::CryptoOptions crypto_options;
     crypto_options.enable_gcm_crypto_suites = true;
     InitWithCryptoOptions(crypto_options);
   }
 
   void SendAudioVideoStream1() {
     send_stream_1_ = true;
@@ skipping 784 matching lines @@
   // This code is placed in a method so that it can be invoked
   // by multiple tests with different allocators (e.g. with and without BUNDLE).
   // While running the call, this method also checks if the session goes through
   // the correct sequence of ICE states when a connection is established,
   // broken, and re-established.
   // The Connection state should go:
   // New -> Checking -> (Connected) -> Completed -> Disconnected -> Completed
   //     -> Failed.
   // The Gathering state should go: New -> Gathering -> Completed.
 
-  void SetupLoopbackCall() {
-    Init();
+  void SetupLoopbackCall(webrtc::Call* fake_call = nullptr) {
+    InitWithFakeCall(fake_call);
     SendAudioVideoStream1();
     SessionDescriptionInterface* offer = CreateOffer();
 
     EXPECT_EQ(PeerConnectionInterface::kIceGatheringNew,
               observer_.ice_gathering_state_);
     SetLocalDescriptionWithoutError(offer);
     EXPECT_EQ(PeerConnectionInterface::kIceConnectionNew,
               observer_.ice_connection_state_);
     EXPECT_EQ_WAIT(PeerConnectionInterface::kIceGatheringGathering,
                    observer_.ice_gathering_state_, kIceCandidatesTimeout);
@@ skipping 51 matching lines @@
                    observer_.ice_connection_state_,
                    kIceCandidatesTimeout + port_timeout);
   }
 
   void TestLoopbackCall() {
     LoopbackNetworkConfiguration config;
     TestLoopbackCall(config);
   }
 
   void TestPacketOptions() {
-    media_controller_.reset(
-        new cricket::FakeMediaController(channel_manager_.get(), &fake_call_));
     LoopbackNetworkConfiguration config;
     LoopbackNetworkManager loopback_network_manager(this, config);
 
-    SetupLoopbackCall();
+    SetupLoopbackCall(&fake_call_);
 
     // Wait for channel to be ready for sending.
     EXPECT_TRUE_WAIT(media_engine_->GetVideoChannel(0)->sending(), 100);
     uint8_t test_packet[15] = {0};
     rtc::PacketOptions options;
     options.packet_id = 10;
     media_engine_->GetVideoChannel(0)
         ->SendRtp(test_packet, sizeof(test_packet), options);
 
     const int kPacketTimeout = 2000;
@@ skipping 109 matching lines @@
 
   webrtc::RtcEventLogNullImpl event_log_;
   // |media_engine_| and |data_engine_| are actually owned by
   // |channel_manager_|.
   cricket::FakeMediaEngine* media_engine_;
   cricket::FakeDataEngine* data_engine_;
   // Actually owned by session_.
   FakeSctpTransportFactory* fake_sctp_transport_factory_ = nullptr;
   std::unique_ptr<cricket::ChannelManager> channel_manager_;
   cricket::FakeCall fake_call_;
-  std::unique_ptr<webrtc::MediaControllerInterface> media_controller_;
   std::unique_ptr<cricket::TransportDescriptionFactory> tdesc_factory_;
   std::unique_ptr<cricket::MediaSessionDescriptionFactory> desc_factory_;
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> vss_;
   std::unique_ptr<rtc::FirewallSocketServer> fss_;
   rtc::SocketServerScope ss_scope_;
   rtc::SocketAddress stun_socket_addr_;
   std::unique_ptr<cricket::TestStunServer> stun_server_;
   cricket::TestTurnServer turn_server_;
   rtc::FakeNetworkManager network_manager_;
@@ skipping 2818 matching lines @@
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));