Replace QuicIntervalSet with an std::deque in PacketNumberQueue. Protected by...

Replace QuicIntervalSet with an std::deque in PacketNumberQueue. Protected by --FLAGS_quic_reloadable_flag_quic_frames_deque.

Merge internal change: 161114283

R=rch@chromium.org

Bug: 
Change-Id: Id2af2ecf02388973e3e2ea9a6ad001a08752d8ec
Reviewed-on: https://chromium-review.googlesource.com/574648
Commit-Queue: Victor Vasiliev <vasilvv@google.com>
Reviewed-by: Ryan Hamilton <rch@chromium.org>
Cr-Commit-Position: refs/heads/master@{#487639}

net/quic/core/frames/quic_ack_frame.h

@@ -5,12 +5,14 @@
 #ifndef NET_QUIC_CORE_FRAMES_QUIC_ACK_FRAME_H_
 #define NET_QUIC_CORE_FRAMES_QUIC_ACK_FRAME_H_
 
+#include <deque>
 #include <ostream>
 #include <string>
 
 #include "net/quic/core/quic_types.h"
 #include "net/quic/platform/api/quic_containers.h"
 #include "net/quic/platform/api/quic_export.h"
+#include "net/quic/platform/api/quic_flags.h"
 
 namespace net {
 
@@ -19,10 +21,6 @@ namespace net {
 // larger new packet numbers are added, with the occasional random access.
 class QUIC_EXPORT_PRIVATE PacketNumberQueue {
  public:
-  using const_iterator = QuicIntervalSet<QuicPacketNumber>::const_iterator;
-  using const_reverse_iterator =
-      QuicIntervalSet<QuicPacketNumber>::const_reverse_iterator;
-
   PacketNumberQueue();
   PacketNumberQueue(const PacketNumberQueue& other);
   PacketNumberQueue(PacketNumberQueue&& other);
@@ -31,6 +29,170 @@ class QUIC_EXPORT_PRIVATE PacketNumberQueue {
   PacketNumberQueue& operator=(const PacketNumberQueue& other);
   PacketNumberQueue& operator=(PacketNumberQueue&& other);
 
+  class QUIC_EXPORT_PRIVATE const_iterator {
+   public:
+    const_iterator(const const_iterator& other);
+    const_iterator(const_iterator&& other);
+    ~const_iterator();
+
+    explicit const_iterator(
+        typename QuicIntervalSet<QuicPacketNumber>::const_iterator it);
+
+    explicit const_iterator(
+        typename std::deque<Interval<QuicPacketNumber>>::const_iterator it);
+
+    typedef std::input_iterator_tag iterator_category;
+    typedef Interval<QuicPacketNumber> value_type;
+    typedef value_type& reference;
+    typedef value_type* pointer;
+    typedef typename std::vector<value_type>::iterator::difference_type
+        difference_type;
+
+    inline const Interval<QuicPacketNumber>& operator*() {
+      if (use_deque_it_) {
+        return *deque_it_;
+      } else {
+        return *vector_it_;
+      }
+    }
+
+    inline const_iterator& operator++() {
+      if (use_deque_it_) {
+        deque_it_++;
+      } else {
+        vector_it_++;
+      }
+      return *this;
+    }
+
+    inline const_iterator& operator--() {
+      if (use_deque_it_) {
+        deque_it_--;
+      } else {
+        vector_it_--;
+      }
+      return *this;
+    }
+
+    inline const_iterator& operator++(int) {
+      if (use_deque_it_) {
+        ++deque_it_;
+      } else {
+        ++vector_it_;
+      }
+      return *this;
+    }
+
+    inline bool operator==(const const_iterator& other) {
+      if (use_deque_it_ != other.use_deque_it_) {
+        return false;
+      }
+
+      if (use_deque_it_) {
+        return deque_it_ == other.deque_it_;
+      } else {
+        return vector_it_ == other.vector_it_;
+      }
+    }
+
+    inline bool operator!=(const const_iterator& other) {
+      return !(*this == other);
+    }
+
+   private:
+    typename QuicIntervalSet<QuicPacketNumber>::const_iterator vector_it_;
+    typename std::deque<Interval<QuicPacketNumber>>::const_iterator deque_it_;
+    const bool use_deque_it_;
+  };
+
+  class QUIC_EXPORT_PRIVATE const_reverse_iterator {
+   public:
+    const_reverse_iterator(const const_reverse_iterator& other);
+    const_reverse_iterator(const_reverse_iterator&& other);
+    ~const_reverse_iterator();
+
+    explicit const_reverse_iterator(
+        const typename QuicIntervalSet<
+            QuicPacketNumber>::const_reverse_iterator& it);
+
+    explicit const_reverse_iterator(
+        const typename std::deque<
+            Interval<QuicPacketNumber>>::const_reverse_iterator& it);
+
+    typedef std::input_iterator_tag iterator_category;
+    typedef Interval<QuicPacketNumber> value_type;
+    typedef value_type& reference;
+    typedef value_type* pointer;
+    typedef typename std::vector<value_type>::iterator::difference_type
+        difference_type;
+
+    inline const Interval<QuicPacketNumber>& operator*() {
+      if (use_deque_it_) {
+        return *deque_it_;
+      } else {
+        return *vector_it_;
+      }
+    }
+
+    inline const Interval<QuicPacketNumber>* operator->() {
+      if (use_deque_it_) {
+        return &*deque_it_;
+      } else {
+        return &*vector_it_;
+      }
+    }
+
+    inline const_reverse_iterator& operator++() {
+      if (use_deque_it_) {
+        deque_it_++;
+      } else {
+        vector_it_++;
+      }
+      return *this;
+    }
+
+    inline const_reverse_iterator& operator--() {
+      if (use_deque_it_) {
+        deque_it_--;
+      } else {
+        vector_it_--;
+      }
+      return *this;
+    }
+
+    inline const_reverse_iterator& operator++(int) {
+      if (use_deque_it_) {
+        ++deque_it_;
+      } else {
+        ++vector_it_;
+      }
+      return *this;
+    }
+
+    inline bool operator==(const const_reverse_iterator& other) {
+      if (use_deque_it_ != other.use_deque_it_) {
+        return false;
+      }
+
+      if (use_deque_it_) {
+        return deque_it_ == other.deque_it_;
+      } else {
+        return vector_it_ == other.vector_it_;
+      }
+    }
+
+    inline bool operator!=(const const_reverse_iterator& other) {
+      return !(*this == other);
+    }
+
+   private:
+    typename QuicIntervalSet<QuicPacketNumber>::const_reverse_iterator
+        vector_it_;
+    typename std::deque<Interval<QuicPacketNumber>>::const_reverse_iterator
+        deque_it_;
+    const bool use_deque_it_;
+  };
+
   // Adds |packet_number| to the set of packets in the queue.
   void Add(QuicPacketNumber packet_number);
 
@@ -81,7 +243,11 @@ class QUIC_EXPORT_PRIVATE PacketNumberQueue {
       const PacketNumberQueue& q);
 
  private:
+  // TODO(lilika): Remove QuicIntervalSet<QuicPacketNumber>
+  // once FLAGS_quic_reloadable_flag_quic_frames_deque is removed
   QuicIntervalSet<QuicPacketNumber> packet_number_intervals_;
+  std::deque<Interval<QuicPacketNumber>> packet_number_deque_;
+  bool use_deque_;
 };
 
 struct QUIC_EXPORT_PRIVATE QuicAckFrame {
@@ -89,8 +255,9 @@ struct QUIC_EXPORT_PRIVATE QuicAckFrame {
   QuicAckFrame(const QuicAckFrame& other);
   ~QuicAckFrame();
 
-  friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(std::ostream& os,
-                                                      const QuicAckFrame& s);
+  friend QUIC_EXPORT_PRIVATE std::ostream& operator<<(
+      std::ostream& os,
+      const QuicAckFrame& ack_frame);
 
   // The highest packet number we've observed from the peer.
   QuicPacketNumber largest_observed;

net/quic/core/quic_flags_list.h

@@ -193,3 +193,6 @@ QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_disable_packets_based_cc, false)
 QUIC_FLAG(bool,
           FLAGS_quic_reloadable_flag_quic_bbr_ack_aggregation_bytes3,
           false)
+
+// When enabled, ack frame uses a deque internally instead of a set.
+QUIC_FLAG(bool, FLAGS_quic_reloadable_flag_quic_frames_deque, false)