TransportFeedbackPacketLossTracker to receive std::vector<PacketFeedback> in place of the entire fe…

webrtc/test/fuzzers/transport_feedback_packet_loss_tracker_fuzzer.cc

 /*
  *  Copyright (c) 2017 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 "webrtc/base/array_view.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
 #include "webrtc/modules/rtp_rtcp/source/byte_io.h"
 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
 #include "webrtc/voice_engine/transport_feedback_packet_loss_tracker.h"
 
 namespace webrtc {
 
 namespace {
 
 template <typename T>
 T FuzzInput(const uint8_t** data, size_t* size) {
@@ skipping 16 matching lines @@
   const size_t offset = (static_cast<float>(fuzzed) / 0x10000) * (range + 1);
   RTC_CHECK_LE(offset, range);  // (fuzzed <= 0xffff) -> (offset < range + 1)
   return lower + offset;
 }
 
 class TransportFeedbackGenerator {
  public:
   explicit TransportFeedbackGenerator(const uint8_t** data, size_t* size)
       : data_(data), size_(size) {}
 
-  bool GetNextTransportFeedback(rtcp::TransportFeedback* feedback) {
-    uint16_t base_seq_num = 0;
-    if (!ReadData<uint16_t>(&base_seq_num)) {
+  bool GetNextTransportFeedbackVector(
+      std::vector<PacketFeedback>* feedback_vector) {
+    RTC_CHECK(feedback_vector->empty());
+
+    uint16_t remaining_packets = 0;
+    if (!ReadData<uint16_t>(&remaining_packets)) {
       return false;
     }
-    constexpr int64_t kBaseTimeUs = 1234;  // Irrelevant to this test.
-    feedback->SetBase(base_seq_num, kBaseTimeUs);
 
-    uint16_t remaining_packets = 0;
-    if (!ReadData<uint16_t>(&remaining_packets))
+    if (remaining_packets == 0) {
+      return true;
+    }
+
+    uint16_t seq_num;
+    if (!ReadData<uint16_t>(&seq_num)) {  // Fuzz base sequence number.
       return false;
-    // Range is [0x00001 : 0x10000], but we keep it 0x0000 to 0xffff for now,
-    // and add the last status as RECEIVED. That is because of a limitation
-    // that says that the last status cannot be LOST.
+    }
 
-    uint16_t seq_num = base_seq_num;
     while (remaining_packets > 0) {
       uint8_t status_byte = 0;
       if (!ReadData<uint8_t>(&status_byte)) {
         return false;
       }
       // Each status byte contains 8 statuses.
       for (size_t i = 0; i < 8 && remaining_packets > 0; ++i) {
+        // Any positive integer signals reception. kNotReceived signals loss.
+        // Other values are just illegal.
+        constexpr int64_t kArrivalTimeMs = 1234;
+
         const bool received = (status_byte & (0x01 << i));
-        if (received) {
-          feedback->AddReceivedPacket(seq_num, kBaseTimeUs);
-        }
-        ++seq_num;
+        feedback_vector->emplace_back(PacketFeedback(
+            received ? kArrivalTimeMs : PacketFeedback::kNotReceived,
+            seq_num++));
         --remaining_packets;
       }
     }
 
-    // As mentioned above, all feedbacks must report with a received packet.
-    feedback->AddReceivedPacket(seq_num, kBaseTimeUs);
-
     return true;
   }
 
  private:
   template <typename T>
   bool ReadData(T* value) {
     if (*size_ < sizeof(T)) {
       return false;
     } else {
       *value = FuzzInput<T>(data_, size_);
@@ skipping 134 matching lines @@
   // be meaningless - we'd go straight back to fuzzing another packet
   // transmission block.
   if (*size < sizeof(uint8_t)) {
     return false;
   }
 
   size_t feedbacks_num = 1 + (FuzzInput<uint8_t>(data, size) & 0x3f);
   TransportFeedbackGenerator feedback_generator(data, size);
 
   for (size_t i = 0; i < feedbacks_num; i++) {
-    rtcp::TransportFeedback feedback;
-    bool may_continue = feedback_generator.GetNextTransportFeedback(&feedback);
+    std::vector<PacketFeedback> feedback_vector;
+    bool may_continue =
+        feedback_generator.GetNextTransportFeedbackVector(&feedback_vector);
     if (!may_continue) {
       return false;
     }
-    tracker->OnReceivedTransportFeedback(feedback);
+    tracker->OnNewTransportFeedbacks(feedback_vector);
     tracker->Validate();
   }
 
   return true;
 }
 
 }  // namespace
 
 void FuzzOneInput(const uint8_t* data, size_t size) {
   std::unique_ptr<TransportFeedbackPacketLossTracker> tracker;
@@ skipping 11 matching lines @@
   while (may_continue) {
     may_continue = FuzzPacketSendBlock(tracker, &data, &size, &time_ms);
     if (!may_continue) {
       return;
     }
     may_continue = FuzzTransportFeedbackBlock(tracker, &data, &size);
   }
 }
 
 }  // namespace webrtc