Require negotiation to send transport cc feedback over RTCP.

webrtc/video/end_to_end_tests.cc

 /*
  *  Copyright (c) 2013 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 <algorithm>
@@ skipping 1515 matching lines @@
 
    private:
     uint32_t first_media_ssrc_;
     std::map<uint32_t, uint32_t> rtx_to_media_ssrcs_;
     RtpExtensionHeaderObserver* observer_;
   } tester;
 
   tester.RunTest();
 }
 
-TEST_F(EndToEndTest, ReceivesTransportFeedback) {
+void TransportFeedbackTest(bool feedback_enabled) {
   static const int kExtensionId = 5;
-
   class TransportFeedbackObserver : public test::DirectTransport {
    public:
     TransportFeedbackObserver(Call* receiver_call, rtc::Event* done_event)
         : DirectTransport(receiver_call), done_(done_event) {}
     virtual ~TransportFeedbackObserver() {}
 
     bool SendRtcp(const uint8_t* data, size_t length) override {
       RTCPUtility::RTCPParserV2 parser(data, length, true);
       EXPECT_TRUE(parser.IsValid());
 
       RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
       while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
         if (packet_type == RTCPUtility::RTCPPacketTypes::kTransportFeedback) {
           done_->Set();
           break;
         }
         packet_type = parser.Iterate();
       }
 
       return test::DirectTransport::SendRtcp(data, length);
     }
 
     rtc::Event* done_;
   };
 
   class TransportFeedbackTester : public MultiStreamTest {
    public:
-    TransportFeedbackTester() : done_(false, false) {}
+    explicit TransportFeedbackTester(bool feedback_enabled)
+        : feedback_enabled_(feedback_enabled), done_(false, false) {}
     virtual ~TransportFeedbackTester() {}
 
    protected:
     void Wait() override {
-      EXPECT_TRUE(done_.Wait(CallTest::kDefaultTimeoutMs));
+      const int64_t kDisabledFeedbackTimeoutMs = 5000;
+      EXPECT_EQ(feedback_enabled_, done_.Wait(feedback_enabled_
+                                  ? test::CallTest::kDefaultTimeoutMs
+                                  : kDisabledFeedbackTimeoutMs));
     }
 
     void UpdateSendConfig(
         size_t stream_index,
         VideoSendStream::Config* send_config,
         VideoEncoderConfig* encoder_config,
         test::FrameGeneratorCapturer** frame_generator) override {
       send_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
     }
 
     void UpdateReceiveConfig(
         size_t stream_index,
         VideoReceiveStream::Config* receive_config) override {
       receive_config->rtp.extensions.push_back(
           RtpExtension(RtpExtension::kTransportSequenceNumber, kExtensionId));
+      receive_config->rtp.transport_cc = feedback_enabled_;
     }
 
     test::DirectTransport* CreateReceiveTransport(
         Call* receiver_call) override {
       return new TransportFeedbackObserver(receiver_call, &done_);
     }
 
    private:
+    const bool feedback_enabled_;
     rtc::Event done_;
-  } tester;
+  } tester(feedback_enabled);
   tester.RunTest();
 }
+
+TEST_F(EndToEndTest, ReceivesTransportFeedback) {
+  TransportFeedbackTest(true);
+}
+
+TEST_F(EndToEndTest, TransportFeedbackNotConfigured) {
+  TransportFeedbackTest(false);
+}
+
 TEST_F(EndToEndTest, ObserversEncodedFrames) {
   class EncodedFrameTestObserver : public EncodedFrameObserver {
    public:
     EncodedFrameTestObserver()
         : length_(0),
           frame_type_(kEmptyFrame),
           called_(EventWrapper::Create()) {}
     virtual ~EncodedFrameTestObserver() {}
 
     virtual void EncodedFrameCallback(const EncodedFrame& encoded_frame) {
@@ skipping 1570 matching lines @@
   EXPECT_TRUE(default_receive_config.rtp.rtx.empty())
       << "Enabling RTX requires rtpmap: rtx negotiation.";
   EXPECT_TRUE(default_receive_config.rtp.extensions.empty())
       << "Enabling RTP extensions require negotiation.";
 
   VerifyEmptyNackConfig(default_receive_config.rtp.nack);
   VerifyEmptyFecConfig(default_receive_config.rtp.fec);
 }
 
 }  // namespace webrtc