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

net/quic/quic_connection_logger.cc

 // Copyright (c) 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_connection_logger.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 107 matching lines @@
                   base::Uint64ToString(frame->largest_observed));
   dict->SetString(
       "delta_time_largest_observed_us",
       base::Int64ToString(frame->delta_time_largest_observed.ToMicroseconds()));
   dict->SetInteger("entropy_hash",
                    frame->entropy_hash);
   dict->SetBoolean("truncated", frame->is_truncated);
 
   base::ListValue* missing = new base::ListValue();
   dict->Set("missing_packets", missing);
-  const PacketNumberSet& missing_packets = frame->missing_packets;
-  for (PacketNumberSet::const_iterator it = missing_packets.begin();
-       it != missing_packets.end(); ++it) {
-    missing->AppendString(base::Uint64ToString(*it));
-  }
+  for (QuicPacketNumber packet : frame->missing_packets)
+    missing->AppendString(base::Uint64ToString(packet));
 
   base::ListValue* revived = new base::ListValue();
   dict->Set("revived_packets", revived);
   const PacketNumberSet& revived_packets = frame->revived_packets;
   for (PacketNumberSet::const_iterator it = revived_packets.begin();
        it != revived_packets.end(); ++it) {
     revived->AppendString(base::Uint64ToString(*it));
   }
 
   base::ListValue* received = new base::ListValue();
@@ skipping 214 matching lines @@
       break;
     case STREAM_FRAME:
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_STREAM_FRAME_SENT,
           base::Bind(&NetLogQuicStreamFrameCallback, frame.stream_frame));
       break;
     case ACK_FRAME: {
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_ACK_FRAME_SENT,
           base::Bind(&NetLogQuicAckFrameCallback, frame.ack_frame));
-      const PacketNumberSet& missing_packets = frame.ack_frame->missing_packets;
+      const PacketNumberQueue& missing_packets =
+          frame.ack_frame->missing_packets;
       const uint8 max_ranges = std::numeric_limits<uint8>::max();
       // Compute an upper bound on the number of NACK ranges. If the bound
       // is below the max, then it clearly isn't truncated.
-      if (missing_packets.size() < max_ranges ||
-          (*missing_packets.rbegin() - *missing_packets.begin() -
-           missing_packets.size() + 1) < max_ranges) {
+      if (missing_packets.NumPackets() < max_ranges ||
+          (missing_packets.Max() - missing_packets.Min() -
+           missing_packets.NumPackets() + 1) < max_ranges) {
         break;
       }
       size_t num_ranges = 0;
       QuicPacketNumber last_missing = 0;
-      for (PacketNumberSet::const_iterator it = missing_packets.begin();
-           it != missing_packets.end(); ++it) {
-        if (*it != last_missing + 1 && ++num_ranges >= max_ranges) {
+      for (QuicPacketNumber packet : missing_packets) {
+        if (packet != last_missing + 1 && ++num_ranges >= max_ranges) {
           ++num_truncated_acks_sent_;
           break;
         }
-        last_missing = *it;
+        last_missing = packet;
       }
       break;
     }
     case RST_STREAM_FRAME:
       UMA_HISTOGRAM_SPARSE_SLOWLY("Net.QuicSession.RstStreamErrorCodeClient",
                                   frame.rst_stream_frame->error_code);
       net_log_.AddEvent(
           NetLog::TYPE_QUIC_SESSION_RST_STREAM_FRAME_SENT,
           base::Bind(&NetLogQuicRstStreamFrameCallback,
                      frame.rst_stream_frame));
@@ skipping 155 matching lines @@
 
   const size_t kApproximateLargestSoloAckBytes = 100;
   if (last_received_packet_number_ < received_acks_.size() &&
       last_received_packet_size_ < kApproximateLargestSoloAckBytes) {
     received_acks_[static_cast<size_t>(last_received_packet_number_)] = true;
   }
 
   if (frame.is_truncated)
     ++num_truncated_acks_received_;
 
-  if (frame.missing_packets.empty())
+  if (frame.missing_packets.Empty())
     return;
 
-  PacketNumberSet missing_packets = frame.missing_packets;
-  PacketNumberSet::const_iterator it =
+  const PacketNumberQueue& missing_packets = frame.missing_packets;

[ramant (doing other things), 2015/09/10 03:58:26]

Hi Ryan,
  Added lower_bound method. Could you please take a look at the chromium
specific files changes?

  PacketNumberQueue has changed lot more. Will port the changes back to the
internal code.

thanks
raman

+  PacketNumberQueue::const_iterator it =
       missing_packets.lower_bound(largest_received_missing_packet_number_);
   if (it == missing_packets.end())
     return;
 
   if (*it == largest_received_missing_packet_number_) {
     ++it;
     if (it == missing_packets.end())
       return;
   }
   // Scan through the list and log consecutive ranges of missing packets.
   size_t num_consecutive_missing_packets = 0;
   QuicPacketNumber previous_missing_packet = *it - 1;
   while (it != missing_packets.end()) {
     if (previous_missing_packet == *it - 1) {
       ++num_consecutive_missing_packets;
     } else {
       DCHECK_NE(0u, num_consecutive_missing_packets);
       UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
       // Make sure this packet it included in the count.
       num_consecutive_missing_packets = 1;
     }
     previous_missing_packet = *it;
     ++it;
   }
   if (num_consecutive_missing_packets != 0) {
     UpdatePacketGapSentHistogram(num_consecutive_missing_packets);
   }
-  largest_received_missing_packet_number_ = *missing_packets.rbegin();
+  largest_received_missing_packet_number_ = missing_packets.Max();
 }
 
 void QuicConnectionLogger::OnStopWaitingFrame(
     const QuicStopWaitingFrame& frame) {
   net_log_.AddEvent(
       NetLog::TYPE_QUIC_SESSION_STOP_WAITING_FRAME_RECEIVED,
       base::Bind(&NetLogQuicStopWaitingFrameCallback, &frame));
 }
 
 void QuicConnectionLogger::OnRstStreamFrame(const QuicRstStreamFrame& frame) {
@@ skipping 269 matching lines @@
       continue;
     }
     // Record some overlapping patterns, to get a better picture, since this is
     // not very expensive.
     if (i % 3 == 0)
       six_packet_histogram->Add(recent_6_mask);
   }
 }
 
 }  // namespace net