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

net/quic/quic_framer.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_framer.h"
 
 #include <stdint.h>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 966 matching lines @@
     default:
       LOG(DFATAL) << "Unreachable case statement.";
       return PACKET_FLAGS_6BYTE_PACKET;
   }
 }
 
 // static
 QuicFramer::AckFrameInfo QuicFramer::GetAckFrameInfo(
     const QuicAckFrame& frame) {
   AckFrameInfo ack_info;
-  if (frame.missing_packets.empty()) {
+  if (frame.missing_packets.Empty()) {
     return ack_info;
   }
-  DCHECK_GE(frame.largest_observed, *frame.missing_packets.rbegin());
+  DCHECK_GE(frame.largest_observed, frame.missing_packets.Max());
   size_t cur_range_length = 0;
   PacketNumberSet::const_iterator iter = frame.missing_packets.begin();
   QuicPacketNumber last_missing = *iter;
   ++iter;
   for (; iter != frame.missing_packets.end(); ++iter) {
     if (cur_range_length < numeric_limits<uint8>::max() &&
         *iter == (last_missing + 1)) {
       ++cur_range_length;
     } else {
       ack_info.nack_ranges[last_missing - cur_range_length] =
@@ skipping 353 matching lines @@
     if (!reader->ReadBytes(&missing_delta, missing_packet_number_length)) {
       set_detailed_error("Unable to read missing packet number delta.");
       return false;
     }
     last_packet_number -= missing_delta;
     QuicPacketNumber range_length = 0;
     if (!reader->ReadBytes(&range_length, PACKET_1BYTE_PACKET_NUMBER)) {
       set_detailed_error("Unable to read missing packet number range.");
       return false;
     }
-    for (size_t j = 0; j <= range_length; ++j) {
-      ack_frame->missing_packets.insert(last_packet_number - j);
-    }
+    ack_frame->missing_packets.Add(last_packet_number - range_length,
+                                   last_packet_number + 1);
     // Subtract an extra 1 to ensure ranges are represented efficiently and
     // can't overlap by 1 packet number.  This allows a missing_delta of 0
     // to represent an adjacent nack range.
     last_packet_number -= (range_length + 1);
   }
 
   // Parse the revived packets list.
   uint8 num_revived_packets;
   if (!reader->ReadBytes(&num_revived_packets, 1)) {
     set_detailed_error("Unable to read num revived packets.");
@@ skipping 679 matching lines @@
       static_cast<uint8>(min(frame.revived_packets.size(), kMaxRevivedPackets));
   num_revived_packets = static_cast<uint8>(min(
       static_cast<size_t>(num_revived_packets),
       (writer->capacity() - writer->length()) / largest_observed_length));
   if (!writer->WriteBytes(&num_revived_packets, 1)) {
     return false;
   }
 
   PacketNumberSet::const_iterator iter = frame.revived_packets.begin();
   for (int i = 0; i < num_revived_packets; ++i, ++iter) {
-    LOG_IF(DFATAL, !ContainsKey(frame.missing_packets, *iter));
+    LOG_IF(DFATAL, !frame.missing_packets.Contains(*iter));
     if (!AppendPacketSequenceNumber(largest_observed_length,
                                     *iter, writer)) {
       return false;
     }
   }
 
   return true;
 }
 
 bool QuicFramer::AppendTimestampToAckFrame(const QuicAckFrame& frame,
@@ skipping 167 matching lines @@
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error: " << QuicUtils::ErrorToString(error)
            << " detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
   return false;
 }
 
 }  // namespace net