Remove unused SignalMediaError and infrastructure.

talk/session/media/channel_unittest.cc

 /*
  * libjingle
  * Copyright 2009 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  *  1. Redistributions of source code must retain the above copyright notice,
  *     this list of conditions and the following disclaimer.
  *  2. Redistributions in binary form must reproduce the above copyright notice,
@@ skipping 121 matching lines @@
               const uint8* rtcp_data,
               int rtcp_len)
       : verify_playout_(verify_playout),
         transport_controller1_(cricket::ICEROLE_CONTROLLING),
         transport_controller2_(cricket::ICEROLE_CONTROLLED),
         media_channel1_(NULL),
         media_channel2_(NULL),
         rtp_packet_(reinterpret_cast<const char*>(rtp_data), rtp_len),
         rtcp_packet_(reinterpret_cast<const char*>(rtcp_data), rtcp_len),
         media_info_callbacks1_(),
-        media_info_callbacks2_(),
-        ssrc_(0),
-        error_(T::MediaChannel::ERROR_NONE) {}
+        media_info_callbacks2_() {}
 
   void CreateChannels(int flags1, int flags2) {
     CreateChannels(new typename T::MediaChannel(NULL, typename T::Options()),
                    new typename T::MediaChannel(NULL, typename T::Options()),
                    flags1, flags2, rtc::Thread::Current());
   }
   void CreateChannels(
       typename T::MediaChannel* ch1, typename T::MediaChannel* ch2,
       int flags1, int flags2, rtc::Thread* thread) {
     media_channel1_ = ch1;
     media_channel2_ = ch2;
     channel1_.reset(CreateChannel(thread, &media_engine_, ch1,
                                   &transport_controller1_,
                                   (flags1 & RTCP) != 0));
     channel2_.reset(CreateChannel(thread, &media_engine_, ch2,
                                   &transport_controller2_,
                                   (flags2 & RTCP) != 0));
     channel1_->SignalMediaMonitor.connect(
         this, &ChannelTest<T>::OnMediaMonitor);
     channel2_->SignalMediaMonitor.connect(
         this, &ChannelTest<T>::OnMediaMonitor);
-    channel1_->SignalMediaError.connect(
-        this, &ChannelTest<T>::OnMediaChannelError);
-    channel2_->SignalMediaError.connect(
-        this, &ChannelTest<T>::OnMediaChannelError);
     if ((flags1 & DTLS) && (flags2 & DTLS)) {
       flags1 = (flags1 & ~SECURE);
       flags2 = (flags2 & ~SECURE);
     }
     CreateContent(flags1, kPcmuCodec, kH264Codec,
                   &local_media_content1_);
     CreateContent(flags2, kPcmuCodec, kH264Codec,
                   &local_media_content2_);
     CopyContent(local_media_content1_, &remote_media_content1_);
     CopyContent(local_media_content2_, &remote_media_content2_);
@@ skipping 285 matching lines @@
 
   void OnMediaMonitor(typename T::Channel* channel,
                       const typename T::MediaInfo& info) {
     if (channel == channel1_.get()) {
       media_info_callbacks1_++;
     } else if (channel == channel2_.get()) {
       media_info_callbacks2_++;
     }
   }
 
-  void OnMediaChannelError(typename T::Channel* channel,
-                           uint32 ssrc,
-                           typename T::MediaChannel::Error error) {
-    ssrc_ = ssrc;
-    error_ = error;
-  }
-
   void AddLegacyStreamInContent(uint32 ssrc, int flags,
                         typename T::Content* content) {
     // Base implementation.
   }
 
   // Tests that can be used by derived classes.
 
   // Basic sanity check.
   void TestInit() {
     CreateChannels(0, 0);
@@ skipping 1178 matching lines @@
     EXPECT_TRUE(send_rtcp1);
     // The sending message is only posted.  channel2_ should be empty.
     EXPECT_TRUE(CheckNoRtcp2());
 
     // When channel1_ is deleted, the RTCP packet should be sent out to
     // channel2_.
     channel1_.reset();
     EXPECT_TRUE(CheckRtcp2());
   }
 
-  void TestChangeStateError() {
-    CreateChannels(RTCP, RTCP);
-    EXPECT_TRUE(SendInitiate());
-    media_channel2_->set_fail_set_send(true);
-    EXPECT_TRUE(channel2_->Enable(true));
-    EXPECT_EQ(cricket::VoiceMediaChannel::ERROR_REC_DEVICE_OPEN_FAILED,
-              error_);
-  }
+  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;
 
-  void TestSrtpError(int pl_type) {
     // 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.
     unsigned const char kBadPacket[] = {0x84,
                                         static_cast<unsigned char>(pl_type),
                                         0x00,
                                         0x01,
                                         0x00,
                                         0x00,
                                         0x00,
                                         0x00,
                                         0x00,
                                         0x00,
                                         0x00,
                                         0x01};
     CreateChannels(RTCP | SECURE, RTCP | SECURE);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(channel2_->secure());
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_TRUE(channel1_->secure());
     EXPECT_TRUE(channel2_->secure());
-    channel2_->set_srtp_signal_silent_time(200);
+
+    channel2_->srtp_filter()->SignalSrtpError.connect(
+        &error_handler, &SrtpErrorHandler::OnSrtpError);
 
     // Testing failures in sending packets.
     EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
     // The first failure will trigger an error.
-    EXPECT_EQ_WAIT(T::MediaChannel::ERROR_REC_SRTP_ERROR, error_, 500);
-    error_ = T::MediaChannel::ERROR_NONE;
+    EXPECT_EQ_WAIT(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_, 500);
+    EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
+    error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
     // The next 1 sec failures will not trigger an error.
     EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
     // Wait for a while to ensure no message comes in.
     rtc::Thread::Current()->ProcessMessages(210);
-    EXPECT_EQ(T::MediaChannel::ERROR_NONE, error_);
+    EXPECT_EQ(cricket::SrtpFilter::ERROR_NONE, error_handler.error_);
     // The error will be triggered again.
     EXPECT_FALSE(media_channel2_->SendRtp(kBadPacket, sizeof(kBadPacket)));
-    EXPECT_EQ_WAIT(T::MediaChannel::ERROR_REC_SRTP_ERROR, error_, 500);
+    EXPECT_EQ_WAIT(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_, 500);
+    EXPECT_EQ(cricket::SrtpFilter::PROTECT, error_handler.mode_);
 
     // Testing failures in receiving packets.
-    error_ = T::MediaChannel::ERROR_NONE;
+    error_handler.error_ = cricket::SrtpFilter::ERROR_NONE;
+
     cricket::TransportChannel* transport_channel =
         channel2_->transport_channel();
     transport_channel->SignalReadPacket(
         transport_channel, reinterpret_cast<const char*>(kBadPacket),
         sizeof(kBadPacket), rtc::PacketTime(), 0);
-    EXPECT_EQ_WAIT(T::MediaChannel::ERROR_PLAY_SRTP_ERROR, error_, 500);
+    EXPECT_EQ_WAIT(cricket::SrtpFilter::ERROR_FAIL, error_handler.error_, 500);
+    EXPECT_EQ(cricket::SrtpFilter::UNPROTECT, error_handler.mode_);
   }
 
   void TestOnReadyToSend() {
     CreateChannels(RTCP, RTCP);
     TransportChannel* rtp = channel1_->transport_channel();
     TransportChannel* rtcp = channel1_->rtcp_transport_channel();
     EXPECT_FALSE(media_channel1_->ready_to_send());
     rtp->SignalReadyToSend(rtp);
     EXPECT_FALSE(media_channel1_->ready_to_send());
     rtcp->SignalReadyToSend(rtcp);
@@ skipping 47 matching lines @@
   rtc::scoped_ptr<typename T::Channel> channel2_;
   typename T::Content local_media_content1_;
   typename T::Content local_media_content2_;
   typename T::Content remote_media_content1_;
   typename T::Content remote_media_content2_;
   // The RTP and RTCP packets to send in the tests.
   std::string rtp_packet_;
   std::string rtcp_packet_;
   int media_info_callbacks1_;
   int media_info_callbacks2_;
-
-  uint32 ssrc_;
-  typename T::MediaChannel::Error error_;
 };
 
 template<>
 void ChannelTest<VoiceTraits>::CreateContent(
     int flags,
     const cricket::AudioCodec& audio_codec,
     const cricket::VideoCodec& video_codec,
     cricket::AudioContentDescription* audio) {
   audio->AddCodec(audio_codec);
   audio->set_rtcp_mux((flags & RTCP_MUX) != 0);
@@ skipping 343 matching lines @@
 }
 
 TEST_F(VoiceChannelTest, TestReceivePrAnswer) {
   Base::TestReceivePrAnswer();
 }
 
 TEST_F(VoiceChannelTest, TestFlushRtcp) {
   Base::TestFlushRtcp();
 }
 
-TEST_F(VoiceChannelTest, TestChangeStateError) {
-  Base::TestChangeStateError();
-}
-
 TEST_F(VoiceChannelTest, TestSrtpError) {
   Base::TestSrtpError(kAudioPts[0]);
 }
 
 TEST_F(VoiceChannelTest, TestOnReadyToSend) {
   Base::TestOnReadyToSend();
 }
 
 TEST_F(VoiceChannelTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
@@ skipping 332 matching lines @@
 TEST_F(VideoChannelTest, SendBundleToBundleWithRtcpMux) {
   Base::SendBundleToBundle(
       kVideoPts, ARRAY_SIZE(kVideoPts), true, false);
 }
 
 TEST_F(VideoChannelTest, SendBundleToBundleWithRtcpMuxSecure) {
   Base::SendBundleToBundle(
       kVideoPts, ARRAY_SIZE(kVideoPts), true, true);
 }
 
-// TODO(gangji): Add VideoChannelTest.TestChangeStateError.
-
 TEST_F(VideoChannelTest, TestSrtpError) {
   Base::TestSrtpError(kVideoPts[0]);
 }
 
 TEST_F(VideoChannelTest, TestOnReadyToSend) {
   Base::TestOnReadyToSend();
 }
 
 TEST_F(VideoChannelTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
@@ skipping 263 matching lines @@
   };
   rtc::Buffer payload(data, 3);
   cricket::SendDataResult result;
   ASSERT_TRUE(media_channel1_->SendData(params, payload, &result));
   EXPECT_EQ(params.ssrc,
             media_channel1_->last_sent_data_params().ssrc);
   EXPECT_EQ("foo", media_channel1_->last_sent_data());
 }
 
 // TODO(pthatcher): TestSetReceiver?