Delete SignalSrtpError.

webrtc/pc/channel_unittest.cc

 /*
  *  Copyright 2009 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 1738 matching lines @@
     rtc::Thread* wait_for[] = {send_rtcp.thread()};
     WaitForThreads(wait_for);  // Ensure rtcp was posted
 
     // When channel1_ is deleted, the RTCP packet should be sent out to
     // channel2_.
     channel1_.reset();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp2());
   }
 
-  void TestSrtpError(int pl_type) {
-    struct SrtpErrorHandler : public sigslot::has_slots<> {
-      SrtpErrorHandler() :
-          mode_(cricket::SrtpFilter::UNPROTECT),
-          error_(cricket::SrtpFilter::ERROR_NONE) {}
-      void OnSrtpError(uint32 ssrc, cricket::SrtpFilter::Mode mode,
-                       cricket::SrtpFilter::Error error) {
-        mode_ = mode;
-        error_ = error;
-      }
-      cricket::SrtpFilter::Mode mode_;
-      cricket::SrtpFilter::Error error_;
-    } error_handler;
-
-    // For Audio, only pl_type 0 is added to the bundle filter.
-    // For Video, only pl_type 97 is added to the bundle filter.
-    // So we need to pass in pl_type so that the packet can pass through
-    // the bundle filter before it can be processed by the srtp filter.
-    // The packet is not a valid srtp packet because it is too short.
-    static unsigned const char kBadPacket[] = {
-        0x84, static_cast<unsigned char>(pl_type),
-        0x00, 0x01,
-        0x00, 0x00,
-        0x00, 0x00,
-        0x00, 0x00,
-        0x00, 0x01};
-
-    // Using fake clock because this tests that SRTP errors are signaled at
-    // specific times based on set_signal_silent_time.
-    rtc::ScopedFakeClock fake_clock;
-
-    CreateChannels(SECURE, SECURE);
-    // Some code uses a time of 0 as a special value, so we must start with
-    // a non-zero time.
-    // TODO(deadbeef): Fix this.
-    fake_clock.AdvanceTime(rtc::TimeDelta::FromSeconds(1));
-
-    EXPECT_FALSE(channel1_->secure());
-    EXPECT_FALSE(channel2_->secure());
-    EXPECT_TRUE(SendInitiate());
-    EXPECT_TRUE(SendAccept());
-    EXPECT_TRUE(channel1_->secure());
-    EXPECT_TRUE(channel2_->secure());
-    channel2_->srtp_filter()->set_signal_silent_time(250);
-    channel2_->srtp_filter()->SignalSrtpError.connect(
-        &error_handler, &SrtpErrorHandler::OnSrtpError);
-
-    // Testing failures in sending packets.
-    media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket),
-                             rtc::PacketOptions());
-    WaitForThreads();
-    // The first failure will trigger an error.
-    EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
-    EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
-    error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
-    error_handler.mode_ = cricket::SrtpFilter::UNPROTECT;
-    // The next 250 ms failures will not trigger an error.
-    media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket),
-                             rtc::PacketOptions());
-    // Wait for a while to ensure no message comes in.
-    WaitForThreads();
-    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(200));
-    EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_handler.error_);
-    EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, error_handler.mode_);
-    // Wait for a little more - the error will be triggered again.
-    fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(200));
-    media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket),
-                             rtc::PacketOptions());
-    WaitForThreads();
-    EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
-    EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
-
-    // Testing failures in receiving packets.
-    error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
-    error_handler.mode_ = cricket::SrtpFilter::UNPROTECT;
-
-    network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
-      fake_rtp_dtls_transport2_->SignalReadPacket(
-          fake_rtp_dtls_transport2_.get(),
-          reinterpret_cast<const char*>(kBadPacket), sizeof(kBadPacket),
-          rtc::PacketTime(), 0);
-    });
-    EXPECT_EQ(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_);
-    EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, error_handler.mode_);
-    // Terminate channels/threads before the fake clock is destroyed.
-    EXPECT_TRUE(Terminate());
-  }
-
   void TestOnTransportReadyToSend() {
     CreateChannels(0, 0);
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     channel1_->OnTransportReadyToSend(true);
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
 
     channel1_->OnTransportReadyToSend(false);
     WaitForThreads();
@@ skipping 491 matching lines @@
 }
 
 TEST_F(VoiceChannelSingleThreadTest, TestReceivePrAnswer) {
   Base::TestReceivePrAnswer();
 }
 
 TEST_F(VoiceChannelSingleThreadTest, TestFlushRtcp) {
   Base::TestFlushRtcp();
 }
 
-TEST_F(VoiceChannelSingleThreadTest, TestSrtpError) {
-  Base::TestSrtpError(kAudioPts[0]);
-}
-
 TEST_F(VoiceChannelSingleThreadTest, TestOnTransportReadyToSend) {
   Base::TestOnTransportReadyToSend();
 }
 
 TEST_F(VoiceChannelSingleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
   Base::TestOnTransportReadyToSendWithRtcpMux();
 }
 
 // Test that we can scale the output volume properly for 1:1 calls.
 TEST_F(VoiceChannelSingleThreadTest, TestScaleVolume1to1Call) {
@@ skipping 297 matching lines @@
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, TestReceivePrAnswer) {
   Base::TestReceivePrAnswer();
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, TestFlushRtcp) {
   Base::TestFlushRtcp();
 }
 
-TEST_F(VoiceChannelDoubleThreadTest, TestSrtpError) {
-  Base::TestSrtpError(kAudioPts[0]);
-}
-
 TEST_F(VoiceChannelDoubleThreadTest, TestOnTransportReadyToSend) {
   Base::TestOnTransportReadyToSend();
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
   Base::TestOnTransportReadyToSendWithRtcpMux();
 }
 
 // Test that we can scale the output volume properly for 1:1 calls.
 TEST_F(VoiceChannelDoubleThreadTest, TestScaleVolume1to1Call) {
@@ skipping 289 matching lines @@
 }
 
 TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMux) {
   Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false);
 }
 
 TEST_F(VideoChannelSingleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
   Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true);
 }
 
-TEST_F(VideoChannelSingleThreadTest, TestSrtpError) {
-  Base::TestSrtpError(kVideoPts[0]);
-}
-
 TEST_F(VideoChannelSingleThreadTest, TestOnTransportReadyToSend) {
   Base::TestOnTransportReadyToSend();
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
   Base::TestOnTransportReadyToSendWithRtcpMux();
 }
 
 TEST_F(VideoChannelSingleThreadTest, DefaultMaxBitrateIsUnlimited) {
   Base::DefaultMaxBitrateIsUnlimited();
@@ skipping 211 matching lines @@
 }
 
 TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMux) {
   Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, false);
 }
 
 TEST_F(VideoChannelDoubleThreadTest, SendBundleToBundleWithRtcpMuxSecure) {
   Base::SendBundleToBundle(kVideoPts, arraysize(kVideoPts), true, true);
 }
 
-TEST_F(VideoChannelDoubleThreadTest, TestSrtpError) {
-  Base::TestSrtpError(kVideoPts[0]);
-}
-
 TEST_F(VideoChannelDoubleThreadTest, TestOnTransportReadyToSend) {
   Base::TestOnTransportReadyToSend();
 }
 
 TEST_F(VideoChannelDoubleThreadTest, TestOnTransportReadyToSendWithRtcpMux) {
   Base::TestOnTransportReadyToSendWithRtcpMux();
 }
 
 TEST_F(VideoChannelDoubleThreadTest, DefaultMaxBitrateIsUnlimited) {
   Base::DefaultMaxBitrateIsUnlimited();
@@ skipping 449 matching lines @@
   ASSERT_TRUE(voice_channel_.Init_w(nullptr, nullptr, &fake_rtp_dtls_transport_,
                                     &fake_rtcp_dtls_transport_));
   EXPECT_DEATH(voice_channel_.SetTransports(&fake_rtp_dtls_transport_,
                                             &fake_rtp_dtls_transport_),
                "");
 }
 
 #endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 
 // TODO(pthatcher): TestSetReceiver?