Move DTMF sender to RtpSender (as opposed to WebRtcSession).

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 {
+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_(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)) {
     // 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());
     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());
+    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_);
 
     // 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
     // SetRemoteDescription.
     voice_media_channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kAudioSsrc));
     voice_media_channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kAudioSsrc));
     voice_media_channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kAudioSsrc2));
     voice_media_channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kAudioSsrc2));
     video_media_channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kVideoSsrc));
     video_media_channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kVideoSsrc));
     video_media_channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(kVideoSsrc2));
     video_media_channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kVideoSsrc2));
   }
 
-  void TearDown() override { channel_manager_.Terminate(); }
+  // Needed to use DTMF sender.
+  void AddDtmfCodec() {
+    cricket::AudioSendParameters params;
+    const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000,
+                                                   0, 1);
+    params.codecs.push_back(kTelephoneEventCodec);
+    voice_media_channel_->SetSendParameters(params);
+  }
 
   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_));
   }
 
   void CreateAudioRtpSender() { CreateAudioRtpSender(nullptr); }
 
   void CreateAudioRtpSender(rtc::scoped_refptr<LocalAudioSource> source) {
     audio_track_ = AudioTrack::Create(kAudioTrackId, source);
     EXPECT_TRUE(stream_->AddTrack(audio_track_));
     audio_rtp_sender_ =
         new AudioRtpSender(stream_->GetAudioTracks()[0], stream_->label(),
                            voice_channel_, nullptr);
     audio_rtp_sender_->SetSsrc(kAudioSsrc);
+    audio_rtp_sender_->GetOnDestroyedSignal()->connect(
+        this, &RtpSenderReceiverTest::OnAudioSenderDestroyed);
     VerifyVoiceChannelInput();
   }
 
+  void OnAudioSenderDestroyed() { audio_sender_destroyed_signal_fired_ = true; }
+
   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_->SetSsrc(kVideoSsrc);
     VerifyVideoChannelInput();
   }
 
@@ skipping 100 matching lines @@
   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<VideoTrackInterface> video_track_;
   rtc::scoped_refptr<AudioTrackInterface> audio_track_;
+  bool audio_sender_destroyed_signal_fired_ = false;
 };
 
 // Test that |voice_channel_| is updated when an audio track is associated
 // and disassociated with an AudioRtpSender.
 TEST_F(RtpSenderReceiverTest, AddAndDestroyAudioRtpSender) {
   CreateAudioRtpSender();
   DestroyAudioRtpSender();
 }
 
 // Test that |video_channel_| is updated when a video track is associated and
@@ skipping 454 matching lines @@
 
   // 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();
 }
 
+TEST_F(RtpSenderReceiverTest, AudioSenderHasDtmfSender) {
+  CreateAudioRtpSender();
+  EXPECT_NE(nullptr, audio_rtp_sender_->GetDtmfSender());
+}
+
+TEST_F(RtpSenderReceiverTest, VideoSenderDoesNotHaveDtmfSender) {
+  CreateVideoRtpSender();
+  EXPECT_EQ(nullptr, video_rtp_sender_->GetDtmfSender());
+}
+
+// Test that the DTMF sender is really using |voice_channel_|, and thus returns
+// true/false from CanSendDtmf based on what |voice_channel_| returns.
+TEST_F(RtpSenderReceiverTest, CanInsertDtmf) {
+  AddDtmfCodec();
+  CreateAudioRtpSender();
+  auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
+  ASSERT_NE(nullptr, dtmf_sender);
+  EXPECT_TRUE(dtmf_sender->CanInsertDtmf());
+}
+
+TEST_F(RtpSenderReceiverTest, CanNotInsertDtmf) {
+  CreateAudioRtpSender();
+  auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
+  ASSERT_NE(nullptr, dtmf_sender);
+  // DTMF codec has not been added, as it was in the above test.
+  EXPECT_FALSE(dtmf_sender->CanInsertDtmf());
+}
+
+TEST_F(RtpSenderReceiverTest, InsertDtmf) {
+  AddDtmfCodec();
+  CreateAudioRtpSender();
+  auto dtmf_sender = audio_rtp_sender_->GetDtmfSender();
+  ASSERT_NE(nullptr, dtmf_sender);
+
+  EXPECT_EQ(0U, voice_media_channel_->dtmf_info_queue().size());
+
+  // Insert DTMF
+  const int expected_duration = 90;
+  dtmf_sender->InsertDtmf("012", expected_duration, 100);
+
+  // Verify
+  ASSERT_EQ_WAIT(3U, voice_media_channel_->dtmf_info_queue().size(),
+                 kDefaultTimeout);
+  const uint32_t send_ssrc =
+      voice_media_channel_->send_streams()[0].first_ssrc();
+  EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[0],
+                              send_ssrc, 0, expected_duration));
+  EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[1],
+                              send_ssrc, 1, expected_duration));
+  EXPECT_TRUE(CompareDtmfInfo(voice_media_channel_->dtmf_info_queue()[2],
+                              send_ssrc, 2, expected_duration));
+}
+
+// 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