Transport sequence number should be set also for retransmissions.

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>
 #include <map>
 #include <sstream>
 #include <string>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/call.h"
 #include "webrtc/call/transport_adapter.h"
 #include "webrtc/frame_callback.h"
+#include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
 #include "webrtc/modules/video_coding/codecs/vp8/include/vp8.h"
 #include "webrtc/modules/video_coding/codecs/vp9/include/vp9.h"
 #include "webrtc/modules/video_coding/main/interface/video_coding_defines.h"
 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
 #include "webrtc/system_wrappers/interface/event_wrapper.h"
 #include "webrtc/system_wrappers/interface/metrics.h"
 #include "webrtc/system_wrappers/interface/sleep.h"
 #include "webrtc/test/call_test.h"
 #include "webrtc/test/direct_transport.h"
@@ skipping 1295 matching lines @@
     }
 
    private:
     rtc::scoped_ptr<VideoOutputObserver> observers_[kNumStreams];
   } tester;
 
   tester.RunTest();
 }
 
 TEST_F(EndToEndTest, AssignsTransportSequenceNumbers) {
-  // TODO(sprang): Extend this to verify received values once send-side BWE
-  // is in place.
-
   static const int kExtensionId = 5;
 
   class RtpExtensionHeaderObserver : public test::DirectTransport {
    public:
     RtpExtensionHeaderObserver()
         : done_(EventWrapper::Create()),
           parser_(RtpHeaderParser::Create()),
           last_seq_(0),
           padding_observed_(false),
-          rtx_padding_observed_(false) {
+          rtx_padding_observed_(false),
+          retransmit_observed_(false) {
       parser_->RegisterRtpHeaderExtension(kRtpExtensionTransportSequenceNumber,
                                           kExtensionId);
     }
     virtual ~RtpExtensionHeaderObserver() {}
 
     bool SendRtp(const uint8_t* data,
                  size_t length,
                  const PacketOptions& options) override {
       if (IsDone())
         return false;
 
       RTPHeader header;
       EXPECT_TRUE(parser_->Parse(data, length, &header));
+      bool drop_packet = false;
+
       if (header.extension.hasTransportSequenceNumber) {
         EXPECT_EQ(options.packet_id,
                   header.extension.transportSequenceNumber);
         if (!streams_observed_.empty()) {
           EXPECT_EQ(static_cast<uint16_t>(last_seq_ + 1),
                     header.extension.transportSequenceNumber);
         }
         last_seq_ = header.extension.transportSequenceNumber;
 
+        // Drop every 20th packet, so we get retransmits.
+        if (header.sequenceNumber % 20 == 0) {
+          dropped_seq_.insert(header.sequenceNumber);
+          drop_packet = true;
+        }
+
         size_t payload_length =
             length - (header.headerLength + header.paddingLength);
         if (payload_length == 0) {
           padding_observed_ = true;
         } else if (header.payloadType == kSendRtxPayloadType) {
-          rtx_padding_observed_ = true;
+          uint16_t original_sequence_number =
+              ByteReader<uint16_t>::ReadBigEndian(&data[header.headerLength]);
+          if (dropped_seq_.find(original_sequence_number) !=
+              dropped_seq_.end()) {
+            retransmit_observed_ = true;
+          } else {
+            rtx_padding_observed_ = true;
+          }
         } else {
           streams_observed_.insert(header.ssrc);
         }
 
         if (IsDone())
           done_->Set();
       }
+      if (drop_packet)
+        return true;
       return test::DirectTransport::SendRtp(data, length, options);
     }
 
     bool IsDone() {
       return streams_observed_.size() == MultiStreamTest::kNumStreams &&
-             padding_observed_ && rtx_padding_observed_;
+             padding_observed_ && retransmit_observed_ && rtx_padding_observed_;
     }
 
     EventTypeWrapper Wait() { return done_->Wait(kDefaultTimeoutMs); }
 
     rtc::scoped_ptr<EventWrapper> done_;
     rtc::scoped_ptr<RtpHeaderParser> parser_;
     uint16_t last_seq_;
     std::set<uint32_t> streams_observed_;
+    std::set<uint16_t> dropped_seq_;
     bool padding_observed_;
     bool rtx_padding_observed_;
+    bool retransmit_observed_;
   };
 
   class TransportSequenceNumberTester : public MultiStreamTest {
    public:
     TransportSequenceNumberTester() : observer_(nullptr) {}
     virtual ~TransportSequenceNumberTester() {}
 
    protected:
     void Wait() override {
       RTC_DCHECK(observer_ != nullptr);
@@ skipping 1719 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