Don't clear newer packets from the video_coding::PacketBuffer when calling ClearTo;

webrtc/modules/video_coding/packet_buffer.cc

 /*
  *  Copyright (c) 2016 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 109 matching lines @@
   }
 
   for (std::unique_ptr<RtpFrameObject>& frame : found_frames)
     received_frame_callback_->OnReceivedFrame(std::move(frame));
 
   return true;
 }
 
 void PacketBuffer::ClearTo(uint16_t seq_num) {
   rtc::CritScope lock(&crit_);
+  // We have already cleared past this sequence number, no need to do anything.
+  if (is_cleared_to_first_seq_num_ &&
+      AheadOf<uint16_t>(first_seq_num_, seq_num)) {
+    return;
+  }

[sprang_webrtc, 2017/07/28 15:36:50]

Is this case covered by the new test?

[philipel, 2017/08/01 11:22:03]

It is covered by already existing tests.

 
   // If the packet buffer was cleared between a frame was created and returned.
   if (!first_packet_received_)
     return;
 
-  is_cleared_to_first_seq_num_ = true;
-  while (AheadOrAt<uint16_t>(seq_num, first_seq_num_)) {
+  // Avoid iterating over the buffer more than once by capping the number of
+  // iterations to the |size_| of the buffer.
+  ++seq_num;
+  size_t diff = ForwardDiff<uint16_t>(first_seq_num_, seq_num);
+  size_t iterations = std::min(diff, size_);
+  for (size_t i = 0; i < iterations; ++i) {
     size_t index = first_seq_num_ % size_;
-    delete[] data_buffer_[index].dataPtr;
-    data_buffer_[index].dataPtr = nullptr;
-    sequence_buffer_[index].used = false;
+    RTC_DCHECK_EQ(data_buffer_[index].seqNum, sequence_buffer_[index].seq_num);
+    if (AheadOf<uint16_t>(seq_num, sequence_buffer_[index].seq_num)) {
+      delete[] data_buffer_[index].dataPtr;
+      data_buffer_[index].dataPtr = nullptr;
+      sequence_buffer_[index].used = false;
+    }
     ++first_seq_num_;
   }
 
+  // If |diff| is larger than |iterations| it means that we don't increment
+  // |first_seq_num_| until we reach |seq_num|, so we set it here.
+  first_seq_num_ = seq_num;
+
+  is_cleared_to_first_seq_num_ = true;
   missing_packets_.erase(missing_packets_.begin(),
                          missing_packets_.upper_bound(seq_num));
 }
 
 void PacketBuffer::Clear() {
   rtc::CritScope lock(&crit_);
   for (size_t i = 0; i < size_; ++i) {
     delete[] data_buffer_[i].dataPtr;
     data_buffer_[i].dataPtr = nullptr;
     sequence_buffer_[i].used = false;
@@ skipping 248 matching lines @@
       missing_packets_.insert(*newest_inserted_seq_num_);
       ++*newest_inserted_seq_num_;
     }
   } else {
     missing_packets_.erase(seq_num);
   }
 }
 
 }  // namespace video_coding
 }  // namespace webrtc