Revert of Refactoring of RTCP options in BaseChannel.

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 77 matching lines @@
                                  cricket::FakeDataMediaChannel,
                                  cricket::DataContentDescription,
                                  cricket::DataCodec,
                                  cricket::DataMediaInfo,
                                  cricket::DataOptions> {};
 
 // Base class for Voice/Video/RtpDataChannel tests
 template<class T>
 class ChannelTest : public testing::Test, public sigslot::has_slots<> {
  public:
-  enum Flags {
-    RTCP_MUX = 0x1,
-    RTCP_MUX_REQUIRED = 0x2,
-    SECURE = 0x4,
-    SSRC_MUX = 0x8,
-    DTLS = 0x10,
-    GCM_CIPHER = 0x20
-  };
+  enum Flags { RTCP = 0x1, RTCP_MUX = 0x2, SECURE = 0x4, SSRC_MUX = 0x8,
+               DTLS = 0x10, GCM_CIPHER = 0x20 };
 
   ChannelTest(bool verify_playout,
               rtc::ArrayView<const uint8_t> rtp_data,
               rtc::ArrayView<const uint8_t> rtcp_data,
               NetworkIsWorker network_is_worker)
       : verify_playout_(verify_playout),
         media_channel1_(NULL),
         media_channel2_(NULL),
         rtp_packet_(rtp_data.data(), rtp_data.size()),
         rtcp_packet_(rtcp_data.data(), rtcp_data.size()),
@@ skipping 15 matching lines @@
 
   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);
   }
   void CreateChannels(typename T::MediaChannel* ch1,
                       typename T::MediaChannel* ch2,
                       int flags1,
                       int flags2) {
-    // Make sure RTCP_MUX_REQUIRED isn't set without RTCP_MUX.
-    ASSERT_NE(RTCP_MUX_REQUIRED, flags1 & (RTCP_MUX | RTCP_MUX_REQUIRED));
-    ASSERT_NE(RTCP_MUX_REQUIRED, flags2 & (RTCP_MUX | RTCP_MUX_REQUIRED));
     rtc::Thread* worker_thread = rtc::Thread::Current();
     media_channel1_ = ch1;
     media_channel2_ = ch2;
     channel1_.reset(
         CreateChannel(worker_thread, network_thread_, &media_engine_, ch1,
                       transport_controller1_.get(), flags1));
     channel2_.reset(
         CreateChannel(worker_thread, network_thread_, &media_engine_, ch2,
                       transport_controller2_.get(), flags2));
     channel1_->SignalMediaMonitor.connect(this,
                                           &ChannelTest<T>::OnMediaMonitor1);
     channel2_->SignalMediaMonitor.connect(this,
                                           &ChannelTest<T>::OnMediaMonitor2);
-    channel1_->SignalRtcpMuxFullyActive.connect(
+    channel1_->SignalDestroyRtcpTransport.connect(
         transport_controller1_.get(),
         &cricket::FakeTransportController::DestroyRtcpTransport);
-    channel2_->SignalRtcpMuxFullyActive.connect(
+    channel2_->SignalDestroyRtcpTransport.connect(
         transport_controller2_.get(),
         &cricket::FakeTransportController::DestroyRtcpTransport);
     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_);
@@ skipping 32 matching lines @@
       rtc::Thread* network_thread,
       cricket::MediaEngineInterface* engine,
       typename T::MediaChannel* ch,
       cricket::TransportController* transport_controller,
       int flags) {
     rtc::Thread* signaling_thread =
         transport_controller ? transport_controller->signaling_thread()
                              : nullptr;
     typename T::Channel* channel = new typename T::Channel(
         worker_thread, network_thread, signaling_thread, engine, ch,
-        cricket::CN_AUDIO, (flags & RTCP_MUX_REQUIRED) != 0,
-        (flags & SECURE) != 0);
+        cricket::CN_AUDIO, (flags & RTCP) != 0, (flags & SECURE) != 0);
     rtc::CryptoOptions crypto_options;
     crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
     channel->SetCryptoOptions(crypto_options);
     cricket::TransportChannel* rtp_transport =
         transport_controller->CreateTransportChannel(
             channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTP);
     cricket::TransportChannel* rtcp_transport = nullptr;
     if (channel->NeedsRtcpTransport()) {
       rtcp_transport = transport_controller->CreateTransportChannel(
           channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTCP);
@@ skipping 307 matching lines @@
     EXPECT_EQ(0U, media_channel1_->codecs().size());
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
                              media_channel1_->codecs()[0]));
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
   // mux.
   void TestSetContentsRtcpMux() {
-    CreateChannels(0, 0);
+    CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(channel1_->rtcp_transport() != NULL);
     EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     // Both sides agree on mux. Should no longer be a separate RTCP channel.
     content.set_rtcp_mux(true);
     EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     EXPECT_TRUE(channel1_->rtcp_transport() == NULL);
     // Only initiator supports mux. Should still have a separate RTCP channel.
     EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
     content.set_rtcp_mux(false);
     EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
     EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
   }
 
   // Test that SetLocalContent and SetRemoteContent properly set RTCP
   // mux when a provisional answer is received.
   void TestSetContentsRtcpMuxWithPrAnswer() {
-    CreateChannels(0, 0);
+    CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(channel1_->rtcp_transport() != NULL);
     EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     content.set_rtcp_mux(true);
     EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_PRANSWER, NULL));
     EXPECT_TRUE(channel1_->rtcp_transport() != NULL);
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     // Both sides agree on mux. Should no longer be a separate RTCP channel.
     EXPECT_TRUE(channel1_->rtcp_transport() == NULL);
     // Only initiator supports mux. Should still have a separate RTCP channel.
     EXPECT_TRUE(channel2_->SetLocalContent(&content, CA_OFFER, NULL));
     content.set_rtcp_mux(false);
     EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_PRANSWER, NULL));
     EXPECT_TRUE(channel2_->SetRemoteContent(&content, CA_ANSWER, NULL));
     EXPECT_TRUE(channel2_->rtcp_transport() != NULL);
   }
 
   // Test that SetRemoteContent properly deals with a content update.
   void TestSetRemoteContentUpdate() {
     CreateChannels(0, 0);
     typename T::Content content;
-    CreateContent(RTCP_MUX | SECURE, kPcmuCodec, kH264Codec, &content);
+    CreateContent(RTCP | RTCP_MUX | SECURE,
+                  kPcmuCodec, kH264Codec,
+                  &content);
     EXPECT_EQ(0U, media_channel1_->codecs().size());
     EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     ASSERT_EQ(1U, media_channel1_->codecs().size());
     EXPECT_TRUE(CodecMatches(content.codecs()[0],
                              media_channel1_->codecs()[0]));
     // Now update with other codecs.
     typename T::Content update_content;
     update_content.set_partial(true);
     CreateContent(0, kIsacCodec, kH264SvcCodec,
@@ skipping 428 matching lines @@
     class LastWordMediaChannel : public T::MediaChannel {
      public:
       LastWordMediaChannel() : T::MediaChannel(NULL, typename T::Options()) {}
       ~LastWordMediaChannel() {
         T::MediaChannel::SendRtp(kPcmuFrame, sizeof(kPcmuFrame),
                                  rtc::PacketOptions());
         T::MediaChannel::SendRtcp(kRtcpReport, sizeof(kRtcpReport));
       }
     };
     CreateChannels(new LastWordMediaChannel(), new LastWordMediaChannel(),
-                   RTCP_MUX, RTCP_MUX);
+                   RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_TRUE(SendTerminate());
   }
 
   // Send voice RTP data to the other side and ensure it gets there.
   void SendRtpToRtp() {
-    CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX | RTCP_MUX_REQUIRED);
+    CreateChannels(0, 0);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(1U, GetChannels1().size());
     EXPECT_EQ(1U, GetChannels2().size());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
   }
 
   void TestDeinit() {
-    CreateChannels(0, 0);
+    CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     // Do not wait, destroy channels.
     channel1_.reset(nullptr);
     channel2_.reset(nullptr);
   }
 
-  // Check that RTCP can be transmitted between both sides.
-  void SendRtcpToRtcp() {
+  // Check that RTCP is not transmitted if both sides don't support RTCP.
+  void SendNoRtcpToNoRtcp() {
     CreateChannels(0, 0);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
+    EXPECT_EQ(1U, GetChannels1().size());
+    EXPECT_EQ(1U, GetChannels2().size());
+    SendRtcp1();
+    SendRtcp2();
+    WaitForThreads();
+    EXPECT_TRUE(CheckNoRtcp1());
+    EXPECT_TRUE(CheckNoRtcp2());
+  }
+
+  // Check that RTCP is not transmitted if the callee doesn't support RTCP.
+  void SendNoRtcpToRtcp() {
+    CreateChannels(0, RTCP);
+    EXPECT_TRUE(SendInitiate());
+    EXPECT_TRUE(SendAccept());
+    EXPECT_EQ(1U, GetChannels1().size());
+    EXPECT_EQ(2U, GetChannels2().size());
+    SendRtcp1();
+    SendRtcp2();
+    WaitForThreads();
+    EXPECT_TRUE(CheckNoRtcp1());
+    EXPECT_TRUE(CheckNoRtcp2());
+  }
+
+  // Check that RTCP is not transmitted if the caller doesn't support RTCP.
+  void SendRtcpToNoRtcp() {
+    CreateChannels(RTCP, 0);
+    EXPECT_TRUE(SendInitiate());
+    EXPECT_TRUE(SendAccept());
     EXPECT_EQ(2U, GetChannels1().size());
+    EXPECT_EQ(1U, GetChannels2().size());
+    SendRtcp1();
+    SendRtcp2();
+    WaitForThreads();
+    EXPECT_TRUE(CheckNoRtcp1());
+    EXPECT_TRUE(CheckNoRtcp2());
+  }
+
+  // Check that RTCP is transmitted if both sides support RTCP.
+  void SendRtcpToRtcp() {
+    CreateChannels(RTCP, RTCP);
+    EXPECT_TRUE(SendInitiate());
+    EXPECT_TRUE(SendAccept());
+    EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(2U, GetChannels2().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTCP is transmitted if only the initiator supports mux.
   void SendRtcpMuxToRtcp() {
-    CreateChannels(RTCP_MUX, 0);
+    CreateChannels(RTCP | RTCP_MUX, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(2U, GetChannels2().size());
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides support mux.
   void SendRtcpMuxToRtcpMux() {
-    CreateChannels(RTCP_MUX, RTCP_MUX);
+    CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(1U, GetChannels2().size());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(1U, GetChannels1().size());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides
   // support mux and one the offerer requires mux.
   void SendRequireRtcpMuxToRtcpMux() {
-    CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX);
+    CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
+    channel1_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(1U, GetChannels1().size());
     EXPECT_EQ(1U, GetChannels2().size());
     EXPECT_TRUE(SendAccept());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides
-  // support mux and only the answerer requires rtcp mux.
+  // support mux and one the answerer requires rtcp mux.
   void SendRtcpMuxToRequireRtcpMux() {
-    CreateChannels(RTCP_MUX, RTCP_MUX | RTCP_MUX_REQUIRED);
+    CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
+    channel2_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(1U, GetChannels2().size());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(1U, GetChannels1().size());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that RTP and RTCP are transmitted ok when both sides
   // require mux.
   void SendRequireRtcpMuxToRequireRtcpMux() {
-    CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX | RTCP_MUX_REQUIRED);
+    CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
+    channel1_->ActivateRtcpMux();
+    channel2_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(1U, GetChannels1().size());
     EXPECT_EQ(1U, GetChannels2().size());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(1U, GetChannels1().size());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Check that SendAccept fails if the answerer doesn't support mux
   // and the offerer requires it.
   void SendRequireRtcpMuxToNoRtcpMux() {
-    CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, 0);
+    CreateChannels(RTCP | RTCP_MUX, RTCP);
+    channel1_->ActivateRtcpMux();
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(1U, GetChannels1().size());
     EXPECT_EQ(2U, GetChannels2().size());
     EXPECT_FALSE(SendAccept());
   }
 
   // Check that RTCP data sent by the initiator before the accept is not muxed.
   void SendEarlyRtcpMuxToRtcp() {
-    CreateChannels(RTCP_MUX, 0);
+    CreateChannels(RTCP | RTCP_MUX, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(2U, GetChannels2().size());
 
     // RTCP can be sent before the call is accepted, if the transport is ready.
     // It should not be muxed though, as the remote side doesn't support mux.
     SendRtcp1();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp2());
@@ skipping 12 matching lines @@
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckRtcp1());
   }
 
 
   // Check that RTCP data is not muxed until both sides have enabled muxing,
   // but that we properly demux before we get the accept message, since there
   // is a race between RTP data and the jingle accept.
   void SendEarlyRtcpMuxToRtcpMux() {
-    CreateChannels(RTCP_MUX, RTCP_MUX);
+    CreateChannels(RTCP | RTCP_MUX, RTCP | RTCP_MUX);
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(1U, GetChannels2().size());
 
     // RTCP can't be sent yet, since the RTCP transport isn't writable, and
     // we haven't yet received the accept that says we should mux.
     SendRtcp1();
     WaitForThreads();
     EXPECT_TRUE(CheckNoRtcp2());
 
@@ skipping 12 matching lines @@
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckRtcp1());
   }
 
   // Test that we properly send SRTP with RTCP in both directions.
   // You can pass in DTLS and/or RTCP_MUX as flags.
   void SendSrtpToSrtp(int flags1_in = 0, int flags2_in = 0) {
     ASSERT((flags1_in & ~(RTCP_MUX | DTLS | GCM_CIPHER)) == 0);
     ASSERT((flags2_in & ~(RTCP_MUX | DTLS | GCM_CIPHER)) == 0);
 
-    int flags1 = SECURE | flags1_in;
-    int flags2 = SECURE | flags2_in;
+    int flags1 = RTCP | SECURE | flags1_in;
+    int flags2 = RTCP | SECURE | flags2_in;
     bool dtls1 = !!(flags1_in & DTLS);
     bool dtls2 = !!(flags2_in & DTLS);
     CreateChannels(flags1, flags2);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(channel2_->secure());
     EXPECT_TRUE(SendInitiate());
     WaitForThreads();
     EXPECT_TRUE(channel1_->writable());
     EXPECT_TRUE(channel2_->writable());
     EXPECT_TRUE(SendAccept());
@@ skipping 19 matching lines @@
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Test that we properly handling SRTP negotiating down to RTP.
   void SendSrtpToRtp() {
-    CreateChannels(SECURE, 0);
+    CreateChannels(RTCP | SECURE, RTCP);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(channel2_->secure());
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(channel2_->secure());
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Test that we can send and receive early media when a provisional answer is
   // sent and received. The test uses SRTP, RTCP mux and SSRC mux.
   void SendEarlyMediaUsingRtcpMuxSrtp() {
       int sequence_number1_1 = 0, sequence_number2_2 = 0;
 
-      CreateChannels(SSRC_MUX | RTCP_MUX | SECURE,
-                     SSRC_MUX | RTCP_MUX | SECURE);
+      CreateChannels(SSRC_MUX | RTCP | RTCP_MUX | SECURE,
+                     SSRC_MUX | RTCP | RTCP_MUX | SECURE);
       EXPECT_TRUE(SendOffer());
       EXPECT_TRUE(SendProvisionalAnswer());
       EXPECT_TRUE(channel1_->secure());
       EXPECT_TRUE(channel2_->secure());
       EXPECT_EQ(2U, GetChannels1().size());
       EXPECT_EQ(2U, GetChannels2().size());
       WaitForThreads();  // Wait for 'sending' flag go through network thread.
       SendCustomRtcp1(kSsrc1);
       SendCustomRtp1(kSsrc1, ++sequence_number1_1);
       WaitForThreads();
@@ skipping 19 matching lines @@
       SendCustomRtp2(kSsrc2, ++sequence_number2_2);
       WaitForThreads();
       EXPECT_TRUE(CheckCustomRtcp2(kSsrc1));
       EXPECT_TRUE(CheckCustomRtp2(kSsrc1, sequence_number1_1));
       EXPECT_TRUE(CheckCustomRtcp1(kSsrc2));
       EXPECT_TRUE(CheckCustomRtp1(kSsrc2, sequence_number2_2));
   }
 
   // Test that we properly send RTP without SRTP from a thread.
   void SendRtpToRtpOnThread() {
-    CreateChannels(0, 0);
+    CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     ScopedCallThread send_rtp1([this] { SendRtp1(); });
     ScopedCallThread send_rtp2([this] { SendRtp2(); });
     ScopedCallThread send_rtcp1([this] { SendRtcp1(); });
     ScopedCallThread send_rtcp2([this] { SendRtcp2(); });
     rtc::Thread* involved_threads[] = {send_rtp1.thread(), send_rtp2.thread(),
                                        send_rtcp1.thread(),
                                        send_rtcp2.thread()};
     WaitForThreads(involved_threads);
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Test that we properly send SRTP with RTCP from a thread.
   void SendSrtpToSrtpOnThread() {
-    CreateChannels(SECURE, SECURE);
+    CreateChannels(RTCP | SECURE, RTCP | SECURE);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     ScopedCallThread send_rtp1([this] { SendRtp1(); });
     ScopedCallThread send_rtp2([this] { SendRtp2(); });
     ScopedCallThread send_rtcp1([this] { SendRtcp1(); });
     ScopedCallThread send_rtcp2([this] { SendRtcp2(); });
     rtc::Thread* involved_threads[] = {send_rtp1.thread(), send_rtp2.thread(),
                                        send_rtcp1.thread(),
                                        send_rtcp2.thread()};
     WaitForThreads(involved_threads);
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckNoRtcp1());
     EXPECT_TRUE(CheckNoRtcp2());
   }
 
   // Test that the mediachannel retains its sending state after the transport
   // becomes non-writable.
   void SendWithWritabilityLoss() {
-    CreateChannels(RTCP_MUX | RTCP_MUX_REQUIRED, RTCP_MUX | RTCP_MUX_REQUIRED);
+    CreateChannels(0, 0);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(1U, GetChannels1().size());
     EXPECT_EQ(1U, GetChannels2().size());
     SendRtp1();
     SendRtp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
@@ skipping 47 matching lines @@
   }
 
   void SendBundleToBundle(
       const int* pl_types, int len, bool rtcp_mux, bool secure) {
     ASSERT_EQ(2, len);
     int sequence_number1_1 = 0, sequence_number2_2 = 0;
     // Only pl_type1 was added to the bundle filter for both |channel1_|
     // and |channel2_|.
     int pl_type1 = pl_types[0];
     int pl_type2 = pl_types[1];
-    int flags = SSRC_MUX;
+    int flags = SSRC_MUX | RTCP;
     if (secure) flags |= SECURE;
     uint32_t expected_channels = 2U;
     if (rtcp_mux) {
       flags |= RTCP_MUX;
       expected_channels = 1U;
     }
     CreateChannels(flags, flags);
     EXPECT_TRUE(SendInitiate());
     EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(expected_channels, GetChannels2().size());
@@ skipping 169 matching lines @@
     std::unique_ptr<cricket::SessionDescription> sdesc3(
         CreateSessionDescriptionWithStream(3));
     EXPECT_TRUE(channel1_->PushdownRemoteDescription(
         sdesc3.get(), cricket::CA_ANSWER, &err));
     EXPECT_TRUE(media_channel1_->HasSendStream(1));
     EXPECT_FALSE(media_channel1_->HasRecvStream(2));
     EXPECT_TRUE(media_channel1_->HasRecvStream(3));
   }
 
   void TestFlushRtcp() {
-    CreateChannels(0, 0);
+    CreateChannels(RTCP, RTCP);
     EXPECT_TRUE(SendInitiate());
     EXPECT_TRUE(SendAccept());
     EXPECT_EQ(2U, GetChannels1().size());
     EXPECT_EQ(2U, GetChannels2().size());
 
     // Send RTCP1 from a different thread.
     ScopedCallThread send_rtcp([this] { SendRtcp1(); });
     // The sending message is only posted.  channel2_ should be empty.
     EXPECT_TRUE(CheckNoRtcp2());
     rtc::Thread* wait_for[] = {send_rtcp.thread()};
@@ skipping 34 matching lines @@
         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;
     // 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));
 
-    CreateChannels(SECURE, SECURE);
+    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_->srtp_filter()->set_signal_silent_time(250);
     channel2_->srtp_filter()->SignalSrtpError.connect(
         &error_handler, &SrtpErrorHandler::OnSrtpError);
 
@@ skipping 32 matching lines @@
           transport_channel, 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 before the fake clock is destroyed.
     EXPECT_TRUE(SendTerminate());
   }
 
   void TestOnReadyToSend() {
-    CreateChannels(0, 0);
+    CreateChannels(RTCP, RTCP);
     TransportChannel* rtp = channel1_->rtp_transport();
     TransportChannel* rtcp = channel1_->rtcp_transport();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE,
                                   [rtp] { rtp->SignalReadyToSend(rtp); });
     WaitForThreads();
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE,
@@ skipping 24 matching lines @@
     EXPECT_FALSE(media_channel1_->ready_to_send());
 
     network_thread_->Invoke<void>(RTC_FROM_HERE, [this] {
       channel1_->SetTransportChannelReadyToSend(true, true);
     });
     WaitForThreads();
     EXPECT_TRUE(media_channel1_->ready_to_send());
   }
 
   void TestOnReadyToSendWithRtcpMux() {
-    CreateChannels(0, 0);
+    CreateChannels(RTCP, RTCP);
     typename T::Content content;
     CreateContent(0, kPcmuCodec, kH264Codec, &content);
     // Both sides agree on mux. Should no longer be a separate RTCP channel.
     content.set_rtcp_mux(true);
     EXPECT_TRUE(channel1_->SetLocalContent(&content, CA_OFFER, NULL));
     EXPECT_TRUE(channel1_->SetRemoteContent(&content, CA_ANSWER, NULL));
     EXPECT_TRUE(channel1_->rtcp_transport() == NULL);
     TransportChannel* rtp = channel1_->rtp_transport();
     EXPECT_FALSE(media_channel1_->ready_to_send());
     // In the case of rtcp mux, the SignalReadyToSend() from rtp channel
@@ skipping 162 matching lines @@
     rtc::Thread* worker_thread,
     rtc::Thread* network_thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeVideoMediaChannel* ch,
     cricket::TransportController* transport_controller,
     int flags) {
   rtc::Thread* signaling_thread =
       transport_controller ? transport_controller->signaling_thread() : nullptr;
   cricket::VideoChannel* channel = new cricket::VideoChannel(
       worker_thread, network_thread, signaling_thread, ch, cricket::CN_VIDEO,
-      (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
+      (flags & RTCP) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
   cricket::TransportChannel* rtp_transport =
       transport_controller->CreateTransportChannel(
           channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTP);
   cricket::TransportChannel* rtcp_transport = nullptr;
   if (channel->NeedsRtcpTransport()) {
     rtcp_transport = transport_controller->CreateTransportChannel(
         channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTCP);
@@ skipping 147 matching lines @@
 }
 
 TEST_F(VoiceChannelSingleThreadTest, TestCallTeardownRtcpMux) {
   Base::TestCallTeardownRtcpMux();
 }
 
 TEST_F(VoiceChannelSingleThreadTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
 }
 
+TEST_F(VoiceChannelSingleThreadTest, SendNoRtcpToNoRtcp) {
+  Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(VoiceChannelSingleThreadTest, SendNoRtcpToRtcp) {
+  Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(VoiceChannelSingleThreadTest, SendRtcpToNoRtcp) {
+  Base::SendRtcpToNoRtcp();
+}
+
 TEST_F(VoiceChannelSingleThreadTest, SendRtcpToRtcp) {
   Base::SendRtcpToRtcp();
 }
 
 TEST_F(VoiceChannelSingleThreadTest, SendRtcpMuxToRtcp) {
   Base::SendRtcpMuxToRtcp();
 }
 
 TEST_F(VoiceChannelSingleThreadTest, SendRtcpMuxToRtcpMux) {
   Base::SendRtcpMuxToRtcpMux();
@@ skipping 136 matching lines @@
 TEST_F(VoiceChannelSingleThreadTest, TestOnReadyToSend) {
   Base::TestOnReadyToSend();
 }
 
 TEST_F(VoiceChannelSingleThreadTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
 }
 
 // Test that we can scale the output volume properly for 1:1 calls.
 TEST_F(VoiceChannelSingleThreadTest, TestScaleVolume1to1Call) {
-  CreateChannels(0, 0);
+  CreateChannels(RTCP, RTCP);
   EXPECT_TRUE(SendInitiate());
   EXPECT_TRUE(SendAccept());
   double volume;
 
   // Default is (1.0).
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(1.0, volume);
   // invalid ssrc.
   EXPECT_FALSE(media_channel1_->GetOutputVolume(3, &volume));
 
   // Set scale to (1.5).
   EXPECT_TRUE(channel1_->SetOutputVolume(0, 1.5));
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(1.5, volume);
 
   // Set scale to (0).
   EXPECT_TRUE(channel1_->SetOutputVolume(0, 0.0));
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(0.0, volume);
 }
 
 // Test that we can scale the output volume properly for multiway calls.
 TEST_F(VoiceChannelSingleThreadTest, TestScaleVolumeMultiwayCall) {
-  CreateChannels(0, 0);
+  CreateChannels(RTCP, RTCP);
   EXPECT_TRUE(SendInitiate());
   EXPECT_TRUE(SendAccept());
   EXPECT_TRUE(AddStream1(1));
   EXPECT_TRUE(AddStream1(2));
 
   double volume;
   // Default is (1.0).
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(1.0, volume);
   EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
@@ skipping 132 matching lines @@
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
   Base::TestCallTeardownRtcpMux();
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
 }
 
+TEST_F(VoiceChannelDoubleThreadTest, SendNoRtcpToNoRtcp) {
+  Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(VoiceChannelDoubleThreadTest, SendNoRtcpToRtcp) {
+  Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(VoiceChannelDoubleThreadTest, SendRtcpToNoRtcp) {
+  Base::SendRtcpToNoRtcp();
+}
+
 TEST_F(VoiceChannelDoubleThreadTest, SendRtcpToRtcp) {
   Base::SendRtcpToRtcp();
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, SendRtcpMuxToRtcp) {
   Base::SendRtcpMuxToRtcp();
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, SendRtcpMuxToRtcpMux) {
   Base::SendRtcpMuxToRtcpMux();
@@ skipping 136 matching lines @@
 TEST_F(VoiceChannelDoubleThreadTest, TestOnReadyToSend) {
   Base::TestOnReadyToSend();
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
 }
 
 // Test that we can scale the output volume properly for 1:1 calls.
 TEST_F(VoiceChannelDoubleThreadTest, TestScaleVolume1to1Call) {
-  CreateChannels(0, 0);
+  CreateChannels(RTCP, RTCP);
   EXPECT_TRUE(SendInitiate());
   EXPECT_TRUE(SendAccept());
   double volume;
 
   // Default is (1.0).
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(1.0, volume);
   // invalid ssrc.
   EXPECT_FALSE(media_channel1_->GetOutputVolume(3, &volume));
 
   // Set scale to (1.5).
   EXPECT_TRUE(channel1_->SetOutputVolume(0, 1.5));
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(1.5, volume);
 
   // Set scale to (0).
   EXPECT_TRUE(channel1_->SetOutputVolume(0, 0.0));
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(0.0, volume);
 }
 
 // Test that we can scale the output volume properly for multiway calls.
 TEST_F(VoiceChannelDoubleThreadTest, TestScaleVolumeMultiwayCall) {
-  CreateChannels(0, 0);
+  CreateChannels(RTCP, RTCP);
   EXPECT_TRUE(SendInitiate());
   EXPECT_TRUE(SendAccept());
   EXPECT_TRUE(AddStream1(1));
   EXPECT_TRUE(AddStream1(2));
 
   double volume;
   // Default is (1.0).
   EXPECT_TRUE(media_channel1_->GetOutputVolume(0, &volume));
   EXPECT_DOUBLE_EQ(1.0, volume);
   EXPECT_TRUE(media_channel1_->GetOutputVolume(1, &volume));
@@ skipping 128 matching lines @@
 }
 
 TEST_F(VideoChannelSingleThreadTest, TestCallTeardownRtcpMux) {
   Base::TestCallTeardownRtcpMux();
 }
 
 TEST_F(VideoChannelSingleThreadTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
 }
 
+TEST_F(VideoChannelSingleThreadTest, SendNoRtcpToNoRtcp) {
+  Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(VideoChannelSingleThreadTest, SendNoRtcpToRtcp) {
+  Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(VideoChannelSingleThreadTest, SendRtcpToNoRtcp) {
+  Base::SendRtcpToNoRtcp();
+}
+
 TEST_F(VideoChannelSingleThreadTest, SendRtcpToRtcp) {
   Base::SendRtcpToRtcp();
 }
 
 TEST_F(VideoChannelSingleThreadTest, SendRtcpMuxToRtcp) {
   Base::SendRtcpMuxToRtcp();
 }
 
 TEST_F(VideoChannelSingleThreadTest, SendRtcpMuxToRtcpMux) {
   Base::SendRtcpMuxToRtcpMux();
@@ skipping 212 matching lines @@
 }
 
 TEST_F(VideoChannelDoubleThreadTest, TestCallTeardownRtcpMux) {
   Base::TestCallTeardownRtcpMux();
 }
 
 TEST_F(VideoChannelDoubleThreadTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
 }
 
+TEST_F(VideoChannelDoubleThreadTest, SendNoRtcpToNoRtcp) {
+  Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(VideoChannelDoubleThreadTest, SendNoRtcpToRtcp) {
+  Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(VideoChannelDoubleThreadTest, SendRtcpToNoRtcp) {
+  Base::SendRtcpToNoRtcp();
+}
+
 TEST_F(VideoChannelDoubleThreadTest, SendRtcpToRtcp) {
   Base::SendRtcpToRtcp();
 }
 
 TEST_F(VideoChannelDoubleThreadTest, SendRtcpMuxToRtcp) {
   Base::SendRtcpMuxToRtcp();
 }
 
 TEST_F(VideoChannelDoubleThreadTest, SendRtcpMuxToRtcpMux) {
   Base::SendRtcpMuxToRtcpMux();
@@ skipping 152 matching lines @@
     rtc::Thread* worker_thread,
     rtc::Thread* network_thread,
     cricket::MediaEngineInterface* engine,
     cricket::FakeDataMediaChannel* ch,
     cricket::TransportController* transport_controller,
     int flags) {
   rtc::Thread* signaling_thread =
       transport_controller ? transport_controller->signaling_thread() : nullptr;
   cricket::RtpDataChannel* channel = new cricket::RtpDataChannel(
       worker_thread, network_thread, signaling_thread, ch, cricket::CN_DATA,
-      (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
+      (flags & RTCP) != 0, (flags & SECURE) != 0);
   rtc::CryptoOptions crypto_options;
   crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
   channel->SetCryptoOptions(crypto_options);
   cricket::TransportChannel* rtp_transport =
       transport_controller->CreateTransportChannel(
           channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTP);
   cricket::TransportChannel* rtcp_transport = nullptr;
   if (channel->NeedsRtcpTransport()) {
     rtcp_transport = transport_controller->CreateTransportChannel(
         channel->content_name(), cricket::ICE_CANDIDATE_COMPONENT_RTCP);
@@ skipping 103 matching lines @@
 }
 
 TEST_F(RtpDataChannelSingleThreadTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
 }
 
 TEST_F(RtpDataChannelSingleThreadTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
 }
 
+TEST_F(RtpDataChannelSingleThreadTest, SendNoRtcpToNoRtcp) {
+  Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(RtpDataChannelSingleThreadTest, SendNoRtcpToRtcp) {
+  Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(RtpDataChannelSingleThreadTest, SendRtcpToNoRtcp) {
+  Base::SendRtcpToNoRtcp();
+}
+
 TEST_F(RtpDataChannelSingleThreadTest, SendRtcpToRtcp) {
   Base::SendRtcpToRtcp();
 }
 
 TEST_F(RtpDataChannelSingleThreadTest, SendRtcpMuxToRtcp) {
   Base::SendRtcpMuxToRtcp();
 }
 
 TEST_F(RtpDataChannelSingleThreadTest, SendRtcpMuxToRtcpMux) {
   Base::SendRtcpMuxToRtcpMux();
@@ skipping 112 matching lines @@
 }
 
 TEST_F(RtpDataChannelDoubleThreadTest, TestOnReadyToSendWithRtcpMux) {
   Base::TestOnReadyToSendWithRtcpMux();
 }
 
 TEST_F(RtpDataChannelDoubleThreadTest, SendRtpToRtp) {
   Base::SendRtpToRtp();
 }
 
+TEST_F(RtpDataChannelDoubleThreadTest, SendNoRtcpToNoRtcp) {
+  Base::SendNoRtcpToNoRtcp();
+}
+
+TEST_F(RtpDataChannelDoubleThreadTest, SendNoRtcpToRtcp) {
+  Base::SendNoRtcpToRtcp();
+}
+
+TEST_F(RtpDataChannelDoubleThreadTest, SendRtcpToNoRtcp) {
+  Base::SendRtcpToNoRtcp();
+}
+
 TEST_F(RtpDataChannelDoubleThreadTest, SendRtcpToRtcp) {
   Base::SendRtcpToRtcp();
 }
 
 TEST_F(RtpDataChannelDoubleThreadTest, SendRtcpMuxToRtcp) {
   Base::SendRtcpMuxToRtcp();
 }
 
 TEST_F(RtpDataChannelDoubleThreadTest, SendRtcpMuxToRtcpMux) {
   Base::SendRtcpMuxToRtcpMux();
@@ skipping 47 matching lines @@
   };
   rtc::CopyOnWriteBuffer 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?