Re-enable RestartingSendStreamPreservesRtpState.

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 <list>
 #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"
@@ skipping 2907 matching lines @@
    private:
     size_t ssrcs_to_observe_;
     std::map<uint32_t, bool> observed_redundant_retransmission_;
     std::map<uint32_t, bool> registered_rtx_ssrc_;
   } test;
 
   RunBaseTest(&test);
 }
 
 void EndToEndTest::TestRtpStatePreservation(bool use_rtx) {
-  static const uint32_t kMaxSequenceNumberGap = 100;
   static const uint64_t kMaxTimestampGap = kDefaultTimeoutMs * 90;
   class RtpSequenceObserver : public test::RtpRtcpObserver {
    public:
     explicit RtpSequenceObserver(bool use_rtx)
         : test::RtpRtcpObserver(kDefaultTimeoutMs),
           ssrcs_to_observe_(kNumSsrcs) {
       for (size_t i = 0; i < kNumSsrcs; ++i) {
         configured_ssrcs_[kVideoSendSsrcs[i]] = true;
         if (use_rtx)
           configured_ssrcs_[kSendRtxSsrcs[i]] = true;
@@ skipping 12 matching lines @@
       EXPECT_TRUE(parser_->Parse(packet, length, &header));
       const uint32_t ssrc = header.ssrc;
       const uint16_t sequence_number = header.sequenceNumber;
       const uint32_t timestamp = header.timestamp;
       const bool only_padding =
           header.headerLength + header.paddingLength == length;
 
       EXPECT_TRUE(configured_ssrcs_[ssrc])
           << "Received SSRC that wasn't configured: " << ssrc;
 
-      std::map<uint32_t, uint16_t>::iterator it =
-          last_observed_sequence_number_.find(header.ssrc);
-      if (it == last_observed_sequence_number_.end()) {
-        last_observed_sequence_number_[ssrc] = sequence_number;
+      static const uint16_t kMaxSequenceNumberGap = 100;
+      std::list<uint16_t>& seq_numbers = last_observed_seq_numbers_[ssrc];

[pbos-webrtc, 2016/02/03 13:03:27]

pointer instead of reference here please.

[danilchap, 2016/02/03 14:04:48]

Done.

+      if (seq_numbers.empty()) {
+        seq_numbers.push_back(sequence_number);
+      } else {
+        // We shouldn't get replays of previous sequence numbers.
+        for (uint16_t observed : seq_numbers) {
+          EXPECT_NE(observed, sequence_number)
+              << "Received sequence number " << sequence_number
+              << " for SSRC " << ssrc << " 2nd time.";
+        }
+        // Verify sequence numbers are reasonably close.

[pbos-webrtc, 2016/02/03 13:03:27]

There should be some timediff function that does this abs_diff for you already.

[danilchap, 2016/02/03 14:04:48]

Failed to find it. Thank you for pointing where it is.
instead of IsNewer used Unwrapper since that fits better how seq numbers are
used in this test.
The case where 1st packet starts with 2^16-1 and comes before packet with seq_no
0 is silently ignored because maximum starting seq_no is 2^15-1.

+        uint16_t latest_observed = seq_numbers.back();
+        uint16_t diff = sequence_number - latest_observed;
+        uint16_t abs_diff;
+        if (diff < 0x8000) {  // Positive difference.
+          abs_diff = diff;
+        } else {  // Negative difference.
+          abs_diff = (0xffff - diff) + 1;
+        }
+        EXPECT_LE(abs_diff, kMaxSequenceNumberGap)
+          << "Gap in sequence numbers ("
+          << latest_observed << " -> " << sequence_number
+          << ") too large for SSRC: " << ssrc << ".";
+        seq_numbers.push_back(sequence_number);
+        if (seq_numbers.size() >= kMaxSequenceNumberGap) {
+          seq_numbers.pop_front();
+        }
+      }
+
+      std::map<uint32_t, uint32_t>::iterator it =
+          last_observed_timestamp_.find(ssrc);
+      if (it == last_observed_timestamp_.end()) {
         last_observed_timestamp_[ssrc] = timestamp;
       } else {
-        // Verify sequence numbers are reasonably close.
-        uint32_t extended_sequence_number = sequence_number;
-        // Check for roll-over.
-        if (sequence_number < last_observed_sequence_number_[ssrc])
-          extended_sequence_number += 0xFFFFu + 1;
-        EXPECT_LE(
-            extended_sequence_number - last_observed_sequence_number_[ssrc],
-            kMaxSequenceNumberGap)
-            << "Gap in sequence numbers ("
-            << last_observed_sequence_number_[ssrc] << " -> " << sequence_number
-            << ") too large for SSRC: " << ssrc << ".";
-        last_observed_sequence_number_[ssrc] = sequence_number;
-
         // TODO(pbos): Remove this check if we ever have monotonically
         // increasing timestamps. Right now padding packets add a delta which
         // can cause reordering between padding packets and regular packets,
         // hence we drop padding-only packets to not flake.
         if (only_padding) {
           // Verify that timestamps are reasonably close.
           uint64_t extended_timestamp = timestamp;
           // Check for roll-over.
           if (timestamp < last_observed_timestamp_[ssrc])
             extended_timestamp += static_cast<uint64_t>(0xFFFFFFFFu) + 1;
           EXPECT_LE(extended_timestamp - last_observed_timestamp_[ssrc],
                     kMaxTimestampGap)
               << "Gap in timestamps (" << last_observed_timestamp_[ssrc]
               << " -> " << timestamp << ") too large for SSRC: " << ssrc << ".";
         }
         last_observed_timestamp_[ssrc] = timestamp;
       }
 
       rtc::CritScope lock(&crit_);
       // Wait for media packets on all ssrcs.
       if (!ssrc_observed_[ssrc] && !only_padding) {
         ssrc_observed_[ssrc] = true;
         if (--ssrcs_to_observe_ == 0)
           observation_complete_.Set();
       }
 
       return SEND_PACKET;
     }
 
-    std::map<uint32_t, uint16_t> last_observed_sequence_number_;
+    std::map<uint32_t, std::list<uint16_t>> last_observed_seq_numbers_;
     std::map<uint32_t, uint32_t> last_observed_timestamp_;
     std::map<uint32_t, bool> configured_ssrcs_;
 
     rtc::CriticalSection crit_;
     size_t ssrcs_to_observe_ GUARDED_BY(crit_);
     std::map<uint32_t, bool> ssrc_observed_ GUARDED_BY(crit_);
   } observer(use_rtx);
 
   CreateCalls(Call::Config(), Call::Config());
 
@@ skipping 78 matching lines @@
         << "Timed out waiting for all SSRCs to send packets.";
   }
 
   send_transport.StopSending();
   receive_transport.StopSending();
 
   Stop();
   DestroyStreams();
 }
 
-TEST_F(EndToEndTest, DISABLED_RestartingSendStreamPreservesRtpState) {
+TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpState) {
   TestRtpStatePreservation(false);
 }
 
 TEST_F(EndToEndTest, RestartingSendStreamPreservesRtpStatesWithRtx) {
   TestRtpStatePreservation(true);
 }
 
 TEST_F(EndToEndTest, RespectsNetworkState) {
   // TODO(pbos): Remove accepted downtime packets etc. when signaling network
   // down blocks until no more packets will be sent.
@@ skipping 370 matching lines @@
    private:
     bool video_observed_;
     bool audio_observed_;
     SequenceNumberUnwrapper unwrapper_;
     std::set<int64_t> received_packet_ids_;
   } test;
 
   RunBaseTest(&test);
 }
 }  // namespace webrtc