Adding "adapter" ORTC objects on top of ChannelManager/BaseChannel/etc.

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.
  */
 
@@ skipping 20 matching lines @@
 #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;
 
-static const char kStreamLabel1[] = "local_stream_1";
+static const char kStreamLabel1[] = "local_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;
 
 namespace webrtc {
 
 class RtpSenderReceiverTest : public testing::Test {
  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_(media_engine_,
-                         rtc::Thread::Current(),
-                         rtc::Thread::Current()),
+        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_),
-        stream_(MediaStream::Create(kStreamLabel1)) {
+        local_stream_(MediaStream::Create(kStreamLabel1)) {
     // Create channels to be used by the RtpSenders and RtpReceivers.
     channel_manager_.Init();
-    bool rtcp_mux_required = true;
     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(),
-        cricket::CN_AUDIO, nullptr, rtcp_mux_required, srtp_required,
-        cricket::AudioOptions());
+        cricket::CN_AUDIO, srtp_required, cricket::AudioOptions());
     video_channel_ = channel_manager_.CreateVideoChannel(
         &fake_media_controller_, rtp_transport, nullptr, rtc::Thread::Current(),
-        cricket::CN_VIDEO, nullptr, rtcp_mux_required, srtp_required,
-        cricket::VideoOptions());
+        cricket::CN_VIDEO, srtp_required, cricket::VideoOptions());
     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_);
 
     // Create streams for predefined SSRCs. Streams need to exist in order
     // for the senders and receievers to apply parameters to them.
     // Normally these would be created by SetLocalDescription and
@@ skipping 17 matching lines @@
   }
 
   void TearDown() override { channel_manager_.Terminate(); }
 
   void AddVideoTrack() { AddVideoTrack(false); }
 
   void AddVideoTrack(bool is_screencast) {
     rtc::scoped_refptr<VideoTrackSourceInterface> source(
         FakeVideoTrackSource::Create(is_screencast));
     video_track_ = VideoTrack::Create(kVideoTrackId, source);
-    EXPECT_TRUE(stream_->AddTrack(video_track_));
+    EXPECT_TRUE(local_stream_->AddTrack(video_track_));
   }
 
   void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
 
   void CreateAudioRtpSender(rtc::scoped_refptr<LocalAudioSource> source) {
     audio_track_ = AudioTrack::Create(kAudioTrackId, source);
-    EXPECT_TRUE(stream_->AddTrack(audio_track_));
+    EXPECT_TRUE(local_stream_->AddTrack(audio_track_));
     audio_rtp_sender_ =
-        new AudioRtpSender(stream_->GetAudioTracks()[0], stream_->label(),
-                           voice_channel_, nullptr);
+        new AudioRtpSender(local_stream_->GetAudioTracks()[0],
+                           local_stream_->label(), voice_channel_, nullptr);
     audio_rtp_sender_->SetSsrc(kAudioSsrc);
     VerifyVoiceChannelInput();
   }
 
   void CreateVideoRtpSender() { CreateVideoRtpSender(false); }
 
   void CreateVideoRtpSender(bool is_screencast) {
     AddVideoTrack(is_screencast);
-    video_rtp_sender_ = new VideoRtpSender(stream_->GetVideoTracks()[0],
-                                           stream_->label(), video_channel_);
+    video_rtp_sender_ =
+        new VideoRtpSender(local_stream_->GetVideoTracks()[0],
+                           local_stream_->label(), video_channel_);
     video_rtp_sender_->SetSsrc(kVideoSsrc);
     VerifyVideoChannelInput();
   }
 
   void DestroyAudioRtpSender() {
     audio_rtp_sender_ = nullptr;
     VerifyVoiceChannelNoInput();
   }
 
   void DestroyVideoRtpSender() {
     video_rtp_sender_ = nullptr;
     VerifyVideoChannelNoInput();
   }
 
   void CreateAudioRtpReceiver() {
-    audio_track_ = AudioTrack::Create(
-        kAudioTrackId, RemoteAudioSource::Create(kAudioSsrc, NULL));
-    EXPECT_TRUE(stream_->AddTrack(audio_track_));
-    audio_rtp_receiver_ = new AudioRtpReceiver(stream_, kAudioTrackId,
-                                               kAudioSsrc, voice_channel_);
+    audio_rtp_receiver_ =
+        new AudioRtpReceiver(kAudioTrackId, kAudioSsrc, voice_channel_);
     audio_track_ = audio_rtp_receiver_->audio_track();
     VerifyVoiceChannelOutput();
   }
 
   void CreateVideoRtpReceiver() {
-    video_rtp_receiver_ =
-        new VideoRtpReceiver(stream_, kVideoTrackId, rtc::Thread::Current(),
-                             kVideoSsrc, video_channel_);
+    video_rtp_receiver_ = new VideoRtpReceiver(
+        kVideoTrackId, rtc::Thread::Current(), kVideoSsrc, video_channel_);
     video_track_ = video_rtp_receiver_->video_track();
     VerifyVideoChannelOutput();
   }
 
   void DestroyAudioRtpReceiver() {
     audio_rtp_receiver_ = nullptr;
     VerifyVoiceChannelNoOutput();
   }
 
   void DestroyVideoRtpReceiver() {
@@ skipping 50 matching lines @@
     EXPECT_EQ(0, volume);
   }
 
   void VerifyVideoChannelNoOutput() {
     // Verify that the media channel's sink is reset.
     EXPECT_FALSE(video_media_channel_->HasSink(kVideoSsrc));
   }
 
  protected:
   webrtc::RtcEventLogNullImpl event_log_;
+  // |media_engine_| is 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> stream_;
+  rtc::scoped_refptr<MediaStreamInterface> local_stream_;
   rtc::scoped_refptr<VideoTrackInterface> video_track_;
   rtc::scoped_refptr<AudioTrackInterface> audio_track_;
 };
 
 // Test that |voice_channel_| is updated when an audio track is associated
 // and disassociated with an AudioRtpSender.
 TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) {
   CreateAudioRtpSender();
   DestroyAudioRtpSender();
 }
@@ skipping 16 matching lines @@
 // associated and disassociated with a VideoRtpReceiver.
 TEST_F(RtpSenderReceiverTest, AddAndDestroyVideoRtpReceiver) {
   CreateVideoRtpReceiver();
   DestroyVideoRtpReceiver();
 }
 
 // Test that the AudioRtpSender applies options from the local audio source.
 TEST_F(RtpSenderReceiverTest, LocalAudioSourceOptionsApplied) {
   cricket::AudioOptions options;
   options.echo_cancellation = rtc::Optional<bool>(true);
-  auto source = LocalAudioSource::Create(
-      PeerConnectionFactoryInterface::Options(), &options);
+  auto source = LocalAudioSource::Create(&options);
   CreateAudioRtpSender(source.get());
 
   EXPECT_EQ(rtc::Optional<bool>(true),
             voice_media_channel_->options().echo_cancellation);
 
   DestroyAudioRtpSender();
 }
 
 // Test that the stream is muted when the track is disabled, and unmuted when
 // the track is enabled.
@@ skipping 395 matching lines @@
 }
 
 // Test that makes sure any content hints that are set on a track before
 // VideoRtpSender is ready to send are still applied when it gets ready to send.
 TEST_F(RtpSenderReceiverTest,
        PropagatesVideoTrackContentHintSetBeforeEnabling) {
   AddVideoTrack();
   // Setting detailed overrides the default non-screencast mode. This should be
   // applied even if the track is set on construction.
   video_track_->set_content_hint(VideoTrackInterface::ContentHint::kDetailed);
-  video_rtp_sender_ = new VideoRtpSender(stream_->GetVideoTracks()[0],
-                                         stream_->label(), video_channel_);
+  video_rtp_sender_ =
+      new VideoRtpSender(local_stream_->GetVideoTracks()[0],
+                         local_stream_->label(), video_channel_);
   video_track_->set_enabled(true);
 
   // Sender is not ready to send (no SSRC) so no option should have been set.
   EXPECT_EQ(rtc::Optional<bool>(),
             video_media_channel_->options().is_screencast);
 
   // Verify that the content hint is accounted for when video_rtp_sender_ does
   // get enabled.
   video_rtp_sender_->SetSsrc(kVideoSsrc);
   EXPECT_EQ(rtc::Optional<bool>(true),
             video_media_channel_->options().is_screencast);
 
   // And removing the hint should go back to false (to verify that false was
   // default correctly).
   video_track_->set_content_hint(VideoTrackInterface::ContentHint::kNone);
   EXPECT_EQ(rtc::Optional<bool>(false),
             video_media_channel_->options().is_screencast);
 
   DestroyVideoRtpSender();
 }
 
 }  // namespace webrtc