Reland: Deliver reordered packets in arrival time order after parsing feedback message.

webrtc/modules/remote_bitrate_estimator/transport_feedback_adapter_unittest.cc

 /*
  *  Copyright (c) 2015 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 205 matching lines @@
     EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
         .Times(1)
         .WillOnce(Invoke([expected_packets, this](
             const std::vector<PacketInfo>& feedback_vector) {
           ComparePacketVectors(expected_packets, feedback_vector);
         }));
     adapter_->OnTransportFeedback(*feedback.get());
   }
 }
 
+TEST_F(TransportFeedbackAdapterTest, HandlesReordering) {
+  std::vector<PacketInfo> packets;
+  packets.push_back(PacketInfo(120, 200, 0, 1500, true));
+  packets.push_back(PacketInfo(110, 210, 1, 1500, true));
+  packets.push_back(PacketInfo(100, 220, 2, 1500, true));
+  std::vector<PacketInfo> expected_packets;
+  expected_packets.push_back(packets[2]);
+  expected_packets.push_back(packets[1]);
+  expected_packets.push_back(packets[0]);
+
+  for (const PacketInfo& packet : packets)
+    OnSentPacket(packet);
+
+  rtcp::TransportFeedback feedback;
+  feedback.WithBase(packets[0].sequence_number,
+                    packets[0].arrival_time_ms * 1000);
+
+  for (const PacketInfo& packet : packets) {
+    EXPECT_TRUE(feedback.WithReceivedPacket(packet.sequence_number,
+                                            packet.arrival_time_ms * 1000));
+  }
+
+  feedback.Build();
+
+  EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
+      .Times(1)
+      .WillOnce(Invoke([expected_packets,
+                        this](const std::vector<PacketInfo>& feedback_vector) {
+        ComparePacketVectors(expected_packets, feedback_vector);
+      }));
+  adapter_->OnTransportFeedback(feedback);
+}
+
 TEST_F(TransportFeedbackAdapterTest, TimestampDeltas) {
   std::vector<PacketInfo> sent_packets;
   const int64_t kSmallDeltaUs =
       rtcp::TransportFeedback::kDeltaScaleFactor * ((1 << 8) - 1);
   const int64_t kLargePositiveDeltaUs =
       rtcp::TransportFeedback::kDeltaScaleFactor *
       std::numeric_limits<int16_t>::max();
   const int64_t kLargeNegativeDeltaUs =
       rtcp::TransportFeedback::kDeltaScaleFactor *
       std::numeric_limits<int16_t>::min();
@@ skipping 14 matching lines @@
   info.send_time_ms += kLargeNegativeDeltaUs / 1000;
   info.arrival_time_ms += kLargeNegativeDeltaUs / 1000;
   ++info.sequence_number;
   sent_packets.push_back(info);
 
   // Too large, delta - will need two feedback messages.
   info.send_time_ms += (kLargePositiveDeltaUs + 1000) / 1000;
   info.arrival_time_ms += (kLargePositiveDeltaUs + 1000) / 1000;
   ++info.sequence_number;
 
+  // Expected to be ordered on arrival time when the feedback message has been
+  // parsed.
+  std::vector<PacketInfo> expected_packets;
+  expected_packets.push_back(sent_packets[0]);
+  expected_packets.push_back(sent_packets[3]);
+  expected_packets.push_back(sent_packets[1]);
+  expected_packets.push_back(sent_packets[2]);
+
   // Packets will be added to send history.
   for (const PacketInfo& packet : sent_packets)
     OnSentPacket(packet);
   OnSentPacket(info);
 
   // Create expected feedback and send into adapter.
   std::unique_ptr<rtcp::TransportFeedback> feedback(
       new rtcp::TransportFeedback());
   feedback->WithBase(sent_packets[0].sequence_number,
                      sent_packets[0].arrival_time_ms * 1000);
 
   for (const PacketInfo& packet : sent_packets) {
     EXPECT_TRUE(feedback->WithReceivedPacket(packet.sequence_number,
                                              packet.arrival_time_ms * 1000));
   }
   EXPECT_FALSE(feedback->WithReceivedPacket(info.sequence_number,
                                             info.arrival_time_ms * 1000));
 
   rtc::Buffer raw_packet = feedback->Build();
   feedback =
       rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
 
   std::vector<PacketInfo> received_feedback;
 
   EXPECT_TRUE(feedback.get() != nullptr);
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
-      .WillOnce(Invoke([sent_packets, &received_feedback](
+      .WillOnce(Invoke([expected_packets, &received_feedback](
           const std::vector<PacketInfo>& feedback_vector) {
-        EXPECT_EQ(sent_packets.size(), feedback_vector.size());
+        EXPECT_EQ(expected_packets.size(), feedback_vector.size());
         received_feedback = feedback_vector;
       }));
   adapter_->OnTransportFeedback(*feedback.get());
 
   // Create a new feedback message and add the trailing item.
   feedback.reset(new rtcp::TransportFeedback());
   feedback->WithBase(info.sequence_number, info.arrival_time_ms * 1000);
   EXPECT_TRUE(feedback->WithReceivedPacket(info.sequence_number,
                                            info.arrival_time_ms * 1000));
   raw_packet = feedback->Build();
   feedback =
       rtcp::TransportFeedback::ParseFrom(raw_packet.data(), raw_packet.size());
 
   EXPECT_TRUE(feedback.get() != nullptr);
   EXPECT_CALL(*bitrate_estimator_, IncomingPacketFeedbackVector(_))
       .Times(1)
       .WillOnce(Invoke(
           [&received_feedback](const std::vector<PacketInfo>& feedback_vector) {
             EXPECT_EQ(1u, feedback_vector.size());
             received_feedback.push_back(feedback_vector[0]);
           }));
   adapter_->OnTransportFeedback(*feedback.get());
 
-  sent_packets.push_back(info);
+  expected_packets.push_back(info);
 
-  ComparePacketVectors(sent_packets, received_feedback);
+  ComparePacketVectors(expected_packets, received_feedback);
 }
 
 }  // namespace test
 }  // namespace webrtc