relnote: Refactor QuicAckFrame::missing_packets to support a change to a

net/quic/quic_received_packet_manager.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_received_packet_manager.h"
 
 #include <limits>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 130 matching lines @@
 
 QuicReceivedPacketManager::~QuicReceivedPacketManager() {}
 
 void QuicReceivedPacketManager::RecordPacketReceived(
     QuicByteCount bytes,
     const QuicPacketHeader& header,
     QuicTime receipt_time) {
   QuicPacketNumber packet_number = header.packet_packet_number;
   DCHECK(IsAwaitingPacket(packet_number));
 
-  InsertMissingPacketsBetween(&ack_frame_, max(ack_frame_.largest_observed + 1,
-                                               peer_least_packet_awaiting_ack_),
-                              packet_number);
+  // Adds the range of packet numbers from max(largest observed + 1, least
+  // awaiting ack) up to packet_number not including packet_number.
+  ack_frame_.missing_packets.Add(
+      max(ack_frame_.largest_observed + 1, peer_least_packet_awaiting_ack_),
+      packet_number);
 
   if (ack_frame_.largest_observed > packet_number) {
     // We've gotten one of the out of order packets - remove it from our
     // "missing packets" list.
     DVLOG(1) << "Removing " << packet_number << " from missing list";
-    ack_frame_.missing_packets.erase(packet_number);
+    ack_frame_.missing_packets.Remove(packet_number);
 
     // Record how out of order stats.
     ++stats_->packets_reordered;
     stats_->max_sequence_reordering =
         max(stats_->max_sequence_reordering,
             ack_frame_.largest_observed - packet_number);
     int64 reordering_time_us =
         receipt_time.Subtract(time_largest_observed_).ToMicroseconds();
     stats_->max_time_reordering_us = max(stats_->max_time_reordering_us,
                                          reordering_time_us);
   }
   if (packet_number > ack_frame_.largest_observed) {
     ack_frame_.largest_observed = packet_number;
     time_largest_observed_ = receipt_time;
   }
   entropy_tracker_.RecordPacketEntropyHash(packet_number, header.entropy_hash);
 
   received_packet_times_.push_back(std::make_pair(packet_number, receipt_time));
 
   ack_frame_.revived_packets.erase(packet_number);
 }
 
 void QuicReceivedPacketManager::RecordPacketRevived(
     QuicPacketNumber packet_number) {
   LOG_IF(DFATAL, !IsAwaitingPacket(packet_number));
   ack_frame_.revived_packets.insert(packet_number);
 }
 
 bool QuicReceivedPacketManager::IsMissing(QuicPacketNumber packet_number) {
-  return ContainsKey(ack_frame_.missing_packets, packet_number);
+  return ack_frame_.missing_packets.Contains(packet_number);
 }
 
 bool QuicReceivedPacketManager::IsAwaitingPacket(
     QuicPacketNumber packet_number) {
   return ::net::IsAwaitingPacket(ack_frame_, packet_number);
 }
 
 namespace {
 struct isTooLarge {
   explicit isTooLarge(QuicPacketNumber n) : largest_observed_(n) {}
@@ skipping 34 matching lines @@
 QuicPacketEntropyHash QuicReceivedPacketManager::EntropyHash(
     QuicPacketNumber packet_number) const {
   return entropy_tracker_.EntropyHash(packet_number);
 }
 
 bool QuicReceivedPacketManager::DontWaitForPacketsBefore(
     QuicPacketNumber least_unacked) {
   ack_frame_.revived_packets.erase(
       ack_frame_.revived_packets.begin(),
       ack_frame_.revived_packets.lower_bound(least_unacked));
-  size_t missing_packets_count = ack_frame_.missing_packets.size();
-  ack_frame_.missing_packets.erase(
-      ack_frame_.missing_packets.begin(),
-      ack_frame_.missing_packets.lower_bound(least_unacked));
-  return missing_packets_count != ack_frame_.missing_packets.size();
+  return ack_frame_.missing_packets.RemoveUpTo(least_unacked);
 }
 
 void QuicReceivedPacketManager::UpdatePacketInformationSentByPeer(
     const QuicStopWaitingFrame& stop_waiting) {
   // ValidateAck() should fail if peer_least_packet_awaiting_ack_ shrinks.
   DCHECK_LE(peer_least_packet_awaiting_ack_, stop_waiting.least_unacked);
   if (stop_waiting.least_unacked > peer_least_packet_awaiting_ack_) {
     bool missed_packets = DontWaitForPacketsBefore(stop_waiting.least_unacked);
     if (missed_packets) {
       DVLOG(1) << "Updating entropy hashed since we missed packets";
       // There were some missing packets that we won't ever get now. Recalculate
       // the received entropy hash.
       entropy_tracker_.SetCumulativeEntropyUpTo(stop_waiting.least_unacked,
                                                 stop_waiting.entropy_hash);
     }
     peer_least_packet_awaiting_ack_ = stop_waiting.least_unacked;
   }
-  DCHECK(ack_frame_.missing_packets.empty() ||
-         *ack_frame_.missing_packets.begin() >=
-             peer_least_packet_awaiting_ack_);
+  DCHECK(ack_frame_.missing_packets.Empty() ||
+         ack_frame_.missing_packets.Min() >= peer_least_packet_awaiting_ack_);
 }
 
 bool QuicReceivedPacketManager::HasNewMissingPackets() const {
-  return !ack_frame_.missing_packets.empty() &&
-      (ack_frame_.largest_observed -
-       *ack_frame_.missing_packets.rbegin()) <= kMaxPacketsAfterNewMissing;
+  return !ack_frame_.missing_packets.Empty() &&
+         (ack_frame_.largest_observed - ack_frame_.missing_packets.Max()) <=
+             kMaxPacketsAfterNewMissing;
 }
 
 size_t QuicReceivedPacketManager::NumTrackedPackets() const {
   return entropy_tracker_.size();
 }
 
 }  // namespace net