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

net/quic/quic_protocol.cc

 // Copyright (c) 2012 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_protocol.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_utils.h"
 
 using base::StringPiece;
@@ skipping 192 matching lines @@
      << ", entropy hash: " << static_cast<int>(header.entropy_hash)
      << ", packet_number: " << header.packet_packet_number
      << ", is_in_fec_group:" << header.is_in_fec_group
      << ", fec_group: " << header.fec_group << "}\n";
   return os;
 }
 
 bool IsAwaitingPacket(const QuicAckFrame& ack_frame,
                       QuicPacketNumber packet_number) {
   return packet_number > ack_frame.largest_observed ||
-         ContainsKey(ack_frame.missing_packets, packet_number);
-}
-
-void InsertMissingPacketsBetween(QuicAckFrame* ack_frame,
-                                 QuicPacketNumber lower,
-                                 QuicPacketNumber higher) {
-  for (QuicPacketNumber i = lower; i < higher; ++i) {
-    ack_frame->missing_packets.insert(i);
-  }
+         ack_frame.missing_packets.Contains(packet_number);
 }
 
 QuicStopWaitingFrame::QuicStopWaitingFrame()
     : entropy_hash(0),
       least_unacked(0) {
 }
 
 QuicStopWaitingFrame::~QuicStopWaitingFrame() {}
 
 QuicAckFrame::QuicAckFrame()
@@ skipping 83 matching lines @@
 }
 
 QuicFecData::QuicFecData() : fec_group(0) {}
 
 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
   os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
      << " least_unacked: " << sent_info.least_unacked;
   return os;
 }
 
+PacketNumberQueue::PacketNumberQueue() {}
+
+PacketNumberQueue::~PacketNumberQueue() {}
+
+void PacketNumberQueue::Add(QuicPacketNumber packet_number) {
+  packet_numbers_.insert(packet_number);
+}
+
+void PacketNumberQueue::Add(QuicPacketNumber lower, QuicPacketNumber higher) {
+  for (QuicPacketNumber packet_number = lower; packet_number < higher;
+       ++packet_number) {
+    Add(packet_number);
+  }
+}
+
+void PacketNumberQueue::Remove(QuicPacketNumber packet_number) {
+  packet_numbers_.erase(packet_number);
+}
+
+bool PacketNumberQueue::RemoveUpTo(QuicPacketNumber higher) {
+  size_t orig_size = packet_numbers_.size();
+  packet_numbers_.erase(packet_numbers_.begin(),
+                        packet_numbers_.lower_bound(higher));
+  return orig_size != packet_numbers_.size();
+}
+
+bool PacketNumberQueue::Contains(QuicPacketNumber packet_number) const {
+  return ContainsKey(packet_numbers_, packet_number);
+}
+
+bool PacketNumberQueue::Empty() const {
+  return packet_numbers_.empty();
+}
+
+QuicPacketNumber PacketNumberQueue::Min() const {
+  DCHECK(!Empty());
+  return *packet_numbers_.begin();
+}
+
+QuicPacketNumber PacketNumberQueue::Max() const {
+  DCHECK(!Empty());
+  return *packet_numbers_.rbegin();
+}
+
+size_t PacketNumberQueue::NumPackets() const {
+  return packet_numbers_.size();
+}
+
+PacketNumberQueue::const_iterator PacketNumberQueue::begin() const {
+  return packet_numbers_.cbegin();
+}
+
+PacketNumberQueue::const_iterator PacketNumberQueue::end() const {
+  return packet_numbers_.cend();
+}
+
+PacketNumberQueue::const_iterator PacketNumberQueue::lower_bound(
+    QuicPacketNumber packet_number) const {
+  return packet_numbers_.lower_bound(packet_number);
+}
+
+PacketNumberQueue::const_iterator PacketNumberQueue::upper_bound(
+    QuicPacketNumber packet_number) const {
+  return packet_numbers_.upper_bound(packet_number);
+}
+
+ostream& operator<<(ostream& os, const PacketNumberQueue& q) {
+  for (QuicPacketNumber packet_number : q.packet_numbers_) {
+    os << packet_number << " ";
+  }
+  return os;
+}
+
 ostream& operator<<(ostream& os, const QuicAckFrame& ack_frame) {
   os << "entropy_hash: " << static_cast<int>(ack_frame.entropy_hash)
      << " largest_observed: " << ack_frame.largest_observed
      << " delta_time_largest_observed: "
      << ack_frame.delta_time_largest_observed.ToMicroseconds()
-     << " missing_packets: [ ";
-  for (PacketNumberSet::const_iterator it = ack_frame.missing_packets.begin();
-       it != ack_frame.missing_packets.end(); ++it) {
-    os << *it << " ";
-  }
-  os << " ] is_truncated: " << ack_frame.is_truncated;
+     << " missing_packets: [ " << ack_frame.missing_packets
+     << " ] is_truncated: " << ack_frame.is_truncated;
   os << " revived_packets: [ ";
   for (PacketNumberSet::const_iterator it = ack_frame.revived_packets.begin();
        it != ack_frame.revived_packets.end(); ++it) {
     os << *it << " ";
   }
   os << " ] received_packets: [ ";
   for (PacketTimeList::const_iterator it =
            ack_frame.received_packet_times.begin();
            it != ack_frame.received_packet_times.end(); ++it) {
     os << it->first << " at " << it->second.ToDebuggingValue() << " ";
@@ skipping 326 matching lines @@
       sent_time(sent_time),
       bytes_sent(bytes_sent),
       nack_count(0),
       transmission_type(transmission_type),
       all_transmissions(nullptr),
       in_flight(false),
       is_unackable(false),
       is_fec_packet(is_fec_packet) {}
 
 }  // namespace net