diff --git a/quic/core/quic_flags_list.h b/quic/core/quic_flags_list.h
index 285ee08..0be4be7 100644
--- a/quic/core/quic_flags_list.h
+++ b/quic/core/quic_flags_list.h
@@ -60,7 +60,6 @@
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_tls_use_per_handshaker_proof_source, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_unified_iw_options, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_update_packet_content_returns_connected, false)
-QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_circular_deque_for_unacked_packets_v2, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_encryption_level_context, true)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_quic_use_write_or_buffer_data_at_level, false)
 QUIC_FLAG(FLAGS_quic_reloadable_flag_send_quic_fallback_server_config_on_leto_error, false)
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 61d680c..97c7c25 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -495,76 +495,42 @@
 }
 
 void QuicSentPacketManager::MarkInitialPacketsForRetransmission() {
-  if (unacked_packets_.use_circular_deque()) {
-    if (unacked_packets_.empty()) {
-      return;
-    }
-    QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    QuicPacketNumber largest_sent_packet =
-        unacked_packets_.largest_sent_packet();
-    for (; packet_number <= largest_sent_packet; ++packet_number) {
-      QuicTransmissionInfo* transmission_info =
-          unacked_packets_.GetMutableTransmissionInfo(packet_number);
-      if (transmission_info->encryption_level == ENCRYPTION_INITIAL) {
-        if (transmission_info->in_flight) {
-          unacked_packets_.RemoveFromInFlight(transmission_info);
-        }
-        if (unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
-          MarkForRetransmission(packet_number, ALL_INITIAL_RETRANSMISSION);
-        }
+  if (unacked_packets_.empty()) {
+    return;
+  }
+  QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
+  QuicPacketNumber largest_sent_packet = unacked_packets_.largest_sent_packet();
+  for (; packet_number <= largest_sent_packet; ++packet_number) {
+    QuicTransmissionInfo* transmission_info =
+        unacked_packets_.GetMutableTransmissionInfo(packet_number);
+    if (transmission_info->encryption_level == ENCRYPTION_INITIAL) {
+      if (transmission_info->in_flight) {
+        unacked_packets_.RemoveFromInFlight(transmission_info);
       }
-    }
-  } else {
-    QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    for (QuicUnackedPacketMap::iterator it = unacked_packets_.begin();
-         it != unacked_packets_.end(); ++it, ++packet_number) {
-      if (it->encryption_level == ENCRYPTION_INITIAL) {
-        if (it->in_flight) {
-          unacked_packets_.RemoveFromInFlight(&*it);
-        }
-        if (unacked_packets_.HasRetransmittableFrames(*it)) {
-          MarkForRetransmission(packet_number, ALL_INITIAL_RETRANSMISSION);
-        }
+      if (unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
+        MarkForRetransmission(packet_number, ALL_INITIAL_RETRANSMISSION);
       }
     }
   }
 }
 
 void QuicSentPacketManager::MarkZeroRttPacketsForRetransmission() {
-  if (unacked_packets_.use_circular_deque()) {
-    if (unacked_packets_.empty()) {
-      return;
-    }
-    QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    QuicPacketNumber largest_sent_packet =
-        unacked_packets_.largest_sent_packet();
-    for (; packet_number <= largest_sent_packet; ++packet_number) {
-      QuicTransmissionInfo* transmission_info =
-          unacked_packets_.GetMutableTransmissionInfo(packet_number);
-      if (transmission_info->encryption_level == ENCRYPTION_ZERO_RTT) {
-        if (transmission_info->in_flight) {
-          // Remove 0-RTT packets and packets of the wrong version from flight,
-          // because neither can be processed by the peer.
-          unacked_packets_.RemoveFromInFlight(transmission_info);
-        }
-        if (unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
-          MarkForRetransmission(packet_number, ALL_ZERO_RTT_RETRANSMISSION);
-        }
+  if (unacked_packets_.empty()) {
+    return;
+  }
+  QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
+  QuicPacketNumber largest_sent_packet = unacked_packets_.largest_sent_packet();
+  for (; packet_number <= largest_sent_packet; ++packet_number) {
+    QuicTransmissionInfo* transmission_info =
+        unacked_packets_.GetMutableTransmissionInfo(packet_number);
+    if (transmission_info->encryption_level == ENCRYPTION_ZERO_RTT) {
+      if (transmission_info->in_flight) {
+        // Remove 0-RTT packets and packets of the wrong version from flight,
+        // because neither can be processed by the peer.
+        unacked_packets_.RemoveFromInFlight(transmission_info);
       }
-    }
-  } else {
-    QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    for (QuicUnackedPacketMap::iterator it = unacked_packets_.begin();
-         it != unacked_packets_.end(); ++it, ++packet_number) {
-      if (it->encryption_level == ENCRYPTION_ZERO_RTT) {
-        if (it->in_flight) {
-          // Remove 0-RTT packets and packets of the wrong version from
-          // flight, because neither can be processed by the peer.
-          unacked_packets_.RemoveFromInFlight(&*it);
-        }
-        if (unacked_packets_.HasRetransmittableFrames(*it)) {
-          MarkForRetransmission(packet_number, ALL_ZERO_RTT_RETRANSMISSION);
-        }
+      if (unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
+        MarkForRetransmission(packet_number, ALL_ZERO_RTT_RETRANSMISSION);
       }
     }
   }
@@ -695,14 +661,9 @@
     // transmission_info owning these frames may be deallocated after each
     // retransimission. Make a copy of retransmissible frames to prevent the
     // invalidation.
-    if (unacked_packets_.use_circular_deque()) {
-      unacked_packets_.RetransmitFrames(
-          QuicFrames(transmission_info->retransmittable_frames),
-          transmission_type);
-    } else {
-      unacked_packets_.RetransmitFrames(
-          transmission_info->retransmittable_frames, transmission_type);
-    }
+    unacked_packets_.RetransmitFrames(
+        QuicFrames(transmission_info->retransmittable_frames),
+        transmission_type);
     return;
   }
 
@@ -928,36 +889,19 @@
   ++consecutive_crypto_retransmission_count_;
   bool packet_retransmitted = false;
   std::vector<QuicPacketNumber> crypto_retransmissions;
-  if (unacked_packets_.use_circular_deque()) {
-    if (!unacked_packets_.empty()) {
-      QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-      QuicPacketNumber largest_sent_packet =
-          unacked_packets_.largest_sent_packet();
-      for (; packet_number <= largest_sent_packet; ++packet_number) {
-        QuicTransmissionInfo* transmission_info =
-            unacked_packets_.GetMutableTransmissionInfo(packet_number);
-        // Only retransmit frames which are in flight, and therefore have been
-        // sent.
-        if (!transmission_info->in_flight ||
-            transmission_info->state != OUTSTANDING ||
-            !transmission_info->has_crypto_handshake ||
-            !unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
-          continue;
-        }
-        packet_retransmitted = true;
-        crypto_retransmissions.push_back(packet_number);
-        ++pending_timer_transmission_count_;
-      }
-    }
-  } else {
+  if (!unacked_packets_.empty()) {
     QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    for (auto it = unacked_packets_.begin(); it != unacked_packets_.end();
-         ++it, ++packet_number) {
+    QuicPacketNumber largest_sent_packet =
+        unacked_packets_.largest_sent_packet();
+    for (; packet_number <= largest_sent_packet; ++packet_number) {
+      QuicTransmissionInfo* transmission_info =
+          unacked_packets_.GetMutableTransmissionInfo(packet_number);
       // Only retransmit frames which are in flight, and therefore have been
       // sent.
-      if (!it->in_flight || it->state != OUTSTANDING ||
-          !it->has_crypto_handshake ||
-          !unacked_packets_.HasRetransmittableFrames(*it)) {
+      if (!transmission_info->in_flight ||
+          transmission_info->state != OUTSTANDING ||
+          !transmission_info->has_crypto_handshake ||
+          !unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
         continue;
       }
       packet_retransmitted = true;
@@ -984,33 +928,18 @@
 }
 
 bool QuicSentPacketManager::MaybeRetransmitOldestPacket(TransmissionType type) {
-  if (unacked_packets_.use_circular_deque()) {
-    if (!unacked_packets_.empty()) {
-      QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-      QuicPacketNumber largest_sent_packet =
-          unacked_packets_.largest_sent_packet();
-      for (; packet_number <= largest_sent_packet; ++packet_number) {
-        QuicTransmissionInfo* transmission_info =
-            unacked_packets_.GetMutableTransmissionInfo(packet_number);
-        // Only retransmit frames which are in flight, and therefore have been
-        // sent.
-        if (!transmission_info->in_flight ||
-            transmission_info->state != OUTSTANDING ||
-            !unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
-          continue;
-        }
-        MarkForRetransmission(packet_number, type);
-        return true;
-      }
-    }
-  } else {
+  if (!unacked_packets_.empty()) {
     QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    for (auto it = unacked_packets_.begin(); it != unacked_packets_.end();
-         ++it, ++packet_number) {
+    QuicPacketNumber largest_sent_packet =
+        unacked_packets_.largest_sent_packet();
+    for (; packet_number <= largest_sent_packet; ++packet_number) {
+      QuicTransmissionInfo* transmission_info =
+          unacked_packets_.GetMutableTransmissionInfo(packet_number);
       // Only retransmit frames which are in flight, and therefore have been
       // sent.
-      if (!it->in_flight || it->state != OUTSTANDING ||
-          !unacked_packets_.HasRetransmittableFrames(*it)) {
+      if (!transmission_info->in_flight ||
+          transmission_info->state != OUTSTANDING ||
+          !unacked_packets_.HasRetransmittableFrames(*transmission_info)) {
         continue;
       }
       MarkForRetransmission(packet_number, type);
@@ -1028,31 +957,17 @@
       << "Retransmissions already queued:" << pending_timer_transmission_count_;
   // Mark two packets for retransmission.
   std::vector<QuicPacketNumber> retransmissions;
-  if (unacked_packets_.use_circular_deque()) {
-    if (!unacked_packets_.empty()) {
-      QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-      QuicPacketNumber largest_sent_packet =
-          unacked_packets_.largest_sent_packet();
-      for (; packet_number <= largest_sent_packet; ++packet_number) {
-        QuicTransmissionInfo* transmission_info =
-            unacked_packets_.GetMutableTransmissionInfo(packet_number);
-        if (transmission_info->state == OUTSTANDING &&
-            unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
-            pending_timer_transmission_count_ < max_rto_packets_) {
-          QUICHE_DCHECK(transmission_info->in_flight);
-          retransmissions.push_back(packet_number);
-          ++pending_timer_transmission_count_;
-        }
-      }
-    }
-  } else {
+  if (!unacked_packets_.empty()) {
     QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    for (auto it = unacked_packets_.begin(); it != unacked_packets_.end();
-         ++it, ++packet_number) {
-      if (it->state == OUTSTANDING &&
-          unacked_packets_.HasRetransmittableFrames(*it) &&
+    QuicPacketNumber largest_sent_packet =
+        unacked_packets_.largest_sent_packet();
+    for (; packet_number <= largest_sent_packet; ++packet_number) {
+      QuicTransmissionInfo* transmission_info =
+          unacked_packets_.GetMutableTransmissionInfo(packet_number);
+      if (transmission_info->state == OUTSTANDING &&
+          unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
           pending_timer_transmission_count_ < max_rto_packets_) {
-        QUICHE_DCHECK(it->in_flight);
+        QUICHE_DCHECK(transmission_info->in_flight);
         retransmissions.push_back(packet_number);
         ++pending_timer_transmission_count_;
       }
@@ -1092,37 +1007,19 @@
     }
   }
   std::vector<QuicPacketNumber> probing_packets;
-  if (unacked_packets_.use_circular_deque()) {
-    if (!unacked_packets_.empty()) {
-      QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-      QuicPacketNumber largest_sent_packet =
-          unacked_packets_.largest_sent_packet();
-      for (; packet_number <= largest_sent_packet; ++packet_number) {
-        QuicTransmissionInfo* transmission_info =
-            unacked_packets_.GetMutableTransmissionInfo(packet_number);
-        if (transmission_info->state == OUTSTANDING &&
-            unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
-            (!supports_multiple_packet_number_spaces() ||
-             unacked_packets_.GetPacketNumberSpace(
-                 transmission_info->encryption_level) == packet_number_space)) {
-          QUICHE_DCHECK(transmission_info->in_flight);
-          probing_packets.push_back(packet_number);
-          if (probing_packets.size() == pending_timer_transmission_count_) {
-            break;
-          }
-        }
-      }
-    }
-  } else {
+  if (!unacked_packets_.empty()) {
     QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    for (auto it = unacked_packets_.begin(); it != unacked_packets_.end();
-         ++it, ++packet_number) {
-      if (it->state == OUTSTANDING &&
-          unacked_packets_.HasRetransmittableFrames(*it) &&
+    QuicPacketNumber largest_sent_packet =
+        unacked_packets_.largest_sent_packet();
+    for (; packet_number <= largest_sent_packet; ++packet_number) {
+      QuicTransmissionInfo* transmission_info =
+          unacked_packets_.GetMutableTransmissionInfo(packet_number);
+      if (transmission_info->state == OUTSTANDING &&
+          unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
           (!supports_multiple_packet_number_spaces() ||
-           unacked_packets_.GetPacketNumberSpace(it->encryption_level) ==
-               packet_number_space)) {
-        QUICHE_DCHECK(it->in_flight);
+           unacked_packets_.GetPacketNumberSpace(
+               transmission_info->encryption_level) == packet_number_space)) {
+        QUICHE_DCHECK(transmission_info->in_flight);
         probing_packets.push_back(packet_number);
         if (probing_packets.size() == pending_timer_transmission_count_) {
           break;
@@ -1179,44 +1076,25 @@
     // No in flight data of space.
     return;
   }
-  if (unacked_packets_.use_circular_deque()) {
-    if (unacked_packets_.empty()) {
+  if (unacked_packets_.empty()) {
+    return;
+  }
+  QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
+  QuicPacketNumber largest_sent_packet = unacked_packets_.largest_sent_packet();
+  for (; packet_number <= largest_sent_packet; ++packet_number) {
+    QuicTransmissionInfo* transmission_info =
+        unacked_packets_.GetMutableTransmissionInfo(packet_number);
+    if (transmission_info->state == OUTSTANDING &&
+        unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
+        unacked_packets_.GetPacketNumberSpace(
+            transmission_info->encryption_level) == space) {
+      QUICHE_DCHECK(transmission_info->in_flight);
+      if (pending_timer_transmission_count_ == 0) {
+        pending_timer_transmission_count_ = 1;
+      }
+      MarkForRetransmission(packet_number, PTO_RETRANSMISSION);
       return;
     }
-    QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    QuicPacketNumber largest_sent_packet =
-        unacked_packets_.largest_sent_packet();
-    for (; packet_number <= largest_sent_packet; ++packet_number) {
-      QuicTransmissionInfo* transmission_info =
-          unacked_packets_.GetMutableTransmissionInfo(packet_number);
-      if (transmission_info->state == OUTSTANDING &&
-          unacked_packets_.HasRetransmittableFrames(*transmission_info) &&
-          unacked_packets_.GetPacketNumberSpace(
-              transmission_info->encryption_level) == space) {
-        QUICHE_DCHECK(transmission_info->in_flight);
-        if (pending_timer_transmission_count_ == 0) {
-          pending_timer_transmission_count_ = 1;
-        }
-        MarkForRetransmission(packet_number, PTO_RETRANSMISSION);
-        return;
-      }
-    }
-  } else {
-    QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
-    for (auto it = unacked_packets_.begin(); it != unacked_packets_.end();
-         ++it, ++packet_number) {
-      if (it->state == OUTSTANDING &&
-          unacked_packets_.HasRetransmittableFrames(*it) &&
-          unacked_packets_.GetPacketNumberSpace(it->encryption_level) ==
-              space) {
-        QUICHE_DCHECK(it->in_flight);
-        if (pending_timer_transmission_count_ == 0) {
-          pending_timer_transmission_count_ = 1;
-        }
-        MarkForRetransmission(packet_number, PTO_RETRANSMISSION);
-        return;
-      }
-    }
   }
 }
 
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index b6872ff..eeda215 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -124,20 +124,11 @@
       last_crypto_packet_sent_time_(QuicTime::Zero()),
       session_notifier_(nullptr),
       supports_multiple_packet_number_spaces_(false) {
-  if (use_circular_deque_) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_use_circular_deque_for_unacked_packets_v2);
-  }
 }
 
 QuicUnackedPacketMap::~QuicUnackedPacketMap() {
-  if (use_circular_deque_) {
-    for (QuicTransmissionInfo& transmission_info : unacked_packets_) {
-      DeleteFrames(&(transmission_info.retransmittable_frames));
-    }
-  } else {
-    for (QuicTransmissionInfo& transmission_info : unacked_packets_deque_) {
-      DeleteFrames(&(transmission_info.retransmittable_frames));
-    }
+  for (QuicTransmissionInfo& transmission_info : unacked_packets_) {
+    DeleteFrames(&(transmission_info.retransmittable_frames));
   }
 }
 
@@ -153,10 +144,10 @@
               largest_sent_packet_ >= packet_number)
       << "largest_sent_packet_: " << largest_sent_packet_
       << ", packet_number: " << packet_number;
-  QUICHE_DCHECK_GE(packet_number, least_unacked_ + unacked_packets_size());
-  while (least_unacked_ + unacked_packets_size() < packet_number) {
-    unacked_packets_push_back(QuicTransmissionInfo());
-    unacked_packets_back().state = NEVER_SENT;
+  QUICHE_DCHECK_GE(packet_number, least_unacked_ + unacked_packets_.size());
+  while (least_unacked_ + unacked_packets_.size() < packet_number) {
+    unacked_packets_.push_back(QuicTransmissionInfo());
+    unacked_packets_.back().state = NEVER_SENT;
   }
 
   const bool has_crypto_handshake = packet.has_crypto_handshake == IS_HANDSHAKE;
@@ -183,7 +174,7 @@
     last_inflight_packet_sent_time_ = sent_time;
     last_inflight_packets_sent_time_[packet_number_space] = sent_time;
   }
-  unacked_packets_push_back(info);
+  unacked_packets_.push_back(info);
   // Swap the retransmittable frames to avoid allocations.
   // TODO(ianswett): Could use emplace_back when Chromium can.
   if (has_crypto_handshake) {
@@ -191,16 +182,16 @@
   }
 
   mutable_packet->retransmittable_frames.swap(
-      unacked_packets_back().retransmittable_frames);
+      unacked_packets_.back().retransmittable_frames);
 }
 
 void QuicUnackedPacketMap::RemoveObsoletePackets() {
-  while (!unacked_packets_empty()) {
-    if (!IsPacketUseless(least_unacked_, unacked_packets_front())) {
+  while (!unacked_packets_.empty()) {
+    if (!IsPacketUseless(least_unacked_, unacked_packets_.front())) {
       break;
     }
-    DeleteFrames(&unacked_packets_front().retransmittable_frames);
-    unacked_packets_pop_front();
+    DeleteFrames(&unacked_packets_.front().retransmittable_frames);
+    unacked_packets_.pop_front();
     ++least_unacked_;
   }
 }
@@ -208,9 +199,9 @@
 bool QuicUnackedPacketMap::HasRetransmittableFrames(
     QuicPacketNumber packet_number) const {
   QUICHE_DCHECK_GE(packet_number, least_unacked_);
-  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
+  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_.size());
   return HasRetransmittableFrames(
-      unacked_packets_at(packet_number - least_unacked_));
+      unacked_packets_[packet_number - least_unacked_]);
 }
 
 bool QuicUnackedPacketMap::HasRetransmittableFrames(
@@ -236,9 +227,9 @@
 void QuicUnackedPacketMap::RemoveRetransmittability(
     QuicPacketNumber packet_number) {
   QUICHE_DCHECK_GE(packet_number, least_unacked_);
-  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
+  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_.size());
   QuicTransmissionInfo* info =
-      &unacked_packets_at(packet_number - least_unacked_);
+      &unacked_packets_[packet_number - least_unacked_];
   RemoveRetransmittability(info);
 }
 
@@ -289,11 +280,11 @@
 
 bool QuicUnackedPacketMap::IsUnacked(QuicPacketNumber packet_number) const {
   if (packet_number < least_unacked_ ||
-      packet_number >= least_unacked_ + unacked_packets_size()) {
+      packet_number >= least_unacked_ + unacked_packets_.size()) {
     return false;
   }
   return !IsPacketUseless(packet_number,
-                          unacked_packets_at(packet_number - least_unacked_));
+                          unacked_packets_[packet_number - least_unacked_]);
 }
 
 void QuicUnackedPacketMap::RemoveFromInFlight(QuicTransmissionInfo* info) {
@@ -327,9 +318,9 @@
 
 void QuicUnackedPacketMap::RemoveFromInFlight(QuicPacketNumber packet_number) {
   QUICHE_DCHECK_GE(packet_number, least_unacked_);
-  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_size());
+  QUICHE_DCHECK_LT(packet_number, least_unacked_ + unacked_packets_.size());
   QuicTransmissionInfo* info =
-      &unacked_packets_at(packet_number - least_unacked_);
+      &unacked_packets_[packet_number - least_unacked_];
   RemoveFromInFlight(info);
 }
 
@@ -391,12 +382,12 @@
 
 const QuicTransmissionInfo& QuicUnackedPacketMap::GetTransmissionInfo(
     QuicPacketNumber packet_number) const {
-  return unacked_packets_at(packet_number - least_unacked_);
+  return unacked_packets_[packet_number - least_unacked_];
 }
 
 QuicTransmissionInfo* QuicUnackedPacketMap::GetMutableTransmissionInfo(
     QuicPacketNumber packet_number) {
-  return &unacked_packets_at(packet_number - least_unacked_);
+  return &unacked_packets_[packet_number - least_unacked_];
 }
 
 QuicTime QuicUnackedPacketMap::GetLastInFlightPacketSentTime() const {
@@ -641,7 +632,7 @@
     return -1;
   }
   int32_t content = 0;
-  const QuicTransmissionInfo& last_packet = unacked_packets_back();
+  const QuicTransmissionInfo& last_packet = unacked_packets_.back();
   for (const auto& frame : last_packet.retransmittable_frames) {
     content |= GetFrameTypeBitfield(frame.type);
   }
diff --git a/quic/core/quic_unacked_packet_map.h b/quic/core/quic_unacked_packet_map.h
index 227c4f1..75c835d 100644
--- a/quic/core/quic_unacked_packet_map.h
+++ b/quic/core/quic_unacked_packet_map.h
@@ -92,9 +92,7 @@
   bool HasUnackedRetransmittableFrames() const;
 
   // Returns true if there are no packets present in the unacked packet map.
-  bool empty() const { return unacked_packets_empty(); }
-
-  bool use_circular_deque() const { return use_circular_deque_; }
+  bool empty() const { return unacked_packets_.empty(); }
 
   // Returns the largest packet number that has been sent.
   QuicPacketNumber largest_sent_packet() const { return largest_sent_packet_; }
@@ -114,83 +112,18 @@
   // been acked by the peer.  If there are no unacked packets, returns 0.
   QuicPacketNumber GetLeastUnacked() const;
 
-  template <typename Itr1, typename Itr2>
-  class QUIC_EXPORT_PRIVATE IteratorWrapper {
-   public:
-    explicit IteratorWrapper(Itr1 itr1) {
-      itr_.template emplace<0>(std::move(itr1));
-    }
-    explicit IteratorWrapper(Itr2 itr2) {
-      itr_.template emplace<1>(std::move(itr2));
-    }
-
-    auto& operator*() const {
-      return absl::visit(
-          [](const auto& itr) -> auto& { return *itr; }, itr_);
-    }
-
-    auto* operator->() const {
-      return absl::visit([](const auto& itr) { return &*itr; }, itr_);
-    }
-
-    IteratorWrapper& operator++() {
-      absl::visit([](auto& itr) { ++itr; }, itr_);
-      return *this;
-    }
-
-    IteratorWrapper& operator+=(int difference) {
-      absl::visit([difference](auto& itr) { itr += difference; }, itr_);
-      return *this;
-    }
-
-    IteratorWrapper operator++(int) {
-      return absl::visit([](auto& itr) { IteratorWrapper(itr++); }, itr_);
-    }
-
-    bool operator!=(const IteratorWrapper& other) const {
-      return itr_ != other.itr_;
-    }
-
-   private:
-    absl::variant<Itr1, Itr2> itr_;
-  };
-
   using const_iterator =
-      IteratorWrapper<std::deque<QuicTransmissionInfo>::const_iterator,
-                      QuicCircularDeque<QuicTransmissionInfo>::const_iterator>;
-  using const_reverse_iterator = IteratorWrapper<
-      std::deque<QuicTransmissionInfo>::const_reverse_iterator,
-      QuicCircularDeque<QuicTransmissionInfo>::const_reverse_iterator>;
-  using iterator =
-      IteratorWrapper<std::deque<QuicTransmissionInfo>::iterator,
-                      QuicCircularDeque<QuicTransmissionInfo>::iterator>;
+      QuicCircularDeque<QuicTransmissionInfo>::const_iterator;
+  using const_reverse_iterator =
+      QuicCircularDeque<QuicTransmissionInfo>::const_reverse_iterator;
+  using iterator = QuicCircularDeque<QuicTransmissionInfo>::iterator;
 
-  const_iterator begin() const {
-    return use_circular_deque_ ? const_iterator(unacked_packets_.begin())
-                               : const_iterator(unacked_packets_deque_.begin());
-  }
-  const_iterator end() const {
-    return use_circular_deque_ ? const_iterator(unacked_packets_.end())
-                               : const_iterator(unacked_packets_deque_.end());
-  }
-  const_reverse_iterator rbegin() const {
-    return use_circular_deque_
-               ? const_reverse_iterator(unacked_packets_.rbegin())
-               : const_reverse_iterator(unacked_packets_deque_.rbegin());
-  }
-  const_reverse_iterator rend() const {
-    return use_circular_deque_
-               ? const_reverse_iterator(unacked_packets_.rend())
-               : const_reverse_iterator(unacked_packets_deque_.rend());
-  }
-  iterator begin() {
-    return use_circular_deque_ ? iterator(unacked_packets_.begin())
-                               : iterator(unacked_packets_deque_.begin());
-  }
-  iterator end() {
-    return use_circular_deque_ ? iterator(unacked_packets_.end())
-                               : iterator(unacked_packets_deque_.end());
-  }
+  const_iterator begin() const { return unacked_packets_.begin(); }
+  const_iterator end() const { return unacked_packets_.end(); }
+  const_reverse_iterator rbegin() const { return unacked_packets_.rbegin(); }
+  const_reverse_iterator rend() const { return unacked_packets_.rend(); }
+  iterator begin() { return unacked_packets_.begin(); }
+  iterator end() { return unacked_packets_.end(); }
 
   // Returns true if there are unacked packets that are in flight.
   bool HasInFlightPackets() const;
@@ -312,14 +245,12 @@
   }
 
   void ReserveInitialCapacity(size_t initial_capacity) {
-    if (use_circular_deque_) {
-      unacked_packets_.reserve(initial_capacity);
-    }
+    unacked_packets_.reserve(initial_capacity);
   }
 
   std::string DebugString() const {
     return absl::StrCat(
-        "{size: ", unacked_packets_size(),
+        "{size: ", unacked_packets_.size(),
         ", least_unacked: ", least_unacked_.ToString(),
         ", largest_sent_packet: ", largest_sent_packet_.ToString(),
         ", largest_acked: ", largest_acked_.ToString(),
@@ -330,64 +261,6 @@
  private:
   friend class test::QuicUnackedPacketMapPeer;
 
-  // TODO(haoyuewang) Remove these methods when deprecate
-  // quic_use_circular_deque_for_unacked_packets_v2 flag.
-  size_t unacked_packets_size() const {
-    return use_circular_deque_ ? unacked_packets_.size()
-                               : unacked_packets_deque_.size();
-  }
-
-  const QuicTransmissionInfo& unacked_packets_at(int index) const {
-    return use_circular_deque_ ? unacked_packets_[index]
-                               : unacked_packets_deque_[index];
-  }
-
-  QuicTransmissionInfo& unacked_packets_at(int index) {
-    return use_circular_deque_ ? unacked_packets_[index]
-                               : unacked_packets_deque_[index];
-  }
-
-  const QuicTransmissionInfo& unacked_packets_front() const {
-    return use_circular_deque_ ? unacked_packets_.front()
-                               : unacked_packets_deque_.front();
-  }
-
-  QuicTransmissionInfo& unacked_packets_front() {
-    return use_circular_deque_ ? unacked_packets_.front()
-                               : unacked_packets_deque_.front();
-  }
-
-  const QuicTransmissionInfo& unacked_packets_back() const {
-    return use_circular_deque_ ? unacked_packets_.back()
-                               : unacked_packets_deque_.back();
-  }
-
-  QuicTransmissionInfo& unacked_packets_back() {
-    return use_circular_deque_ ? unacked_packets_.back()
-                               : unacked_packets_deque_.back();
-  }
-
-  void unacked_packets_push_back(QuicTransmissionInfo info) {
-    if (use_circular_deque_) {
-      unacked_packets_.push_back(std::move(info));
-    } else {
-      unacked_packets_deque_.push_back(std::move(info));
-    }
-  }
-
-  void unacked_packets_pop_front() {
-    if (use_circular_deque_) {
-      unacked_packets_.pop_front();
-    } else {
-      unacked_packets_deque_.pop_front();
-    }
-  }
-
-  bool unacked_packets_empty() const {
-    return use_circular_deque_ ? unacked_packets_.empty()
-                               : unacked_packets_deque_.empty();
-  }
-
   // Returns true if packet may be useful for an RTT measurement.
   bool IsPacketUsefulForMeasuringRtt(QuicPacketNumber packet_number,
                                      const QuicTransmissionInfo& info) const;
@@ -428,10 +301,6 @@
   // be removed from the map and the new entry's retransmittable frames will be
   // set to nullptr.
   QuicCircularDeque<QuicTransmissionInfo> unacked_packets_;
-  std::deque<QuicTransmissionInfo> unacked_packets_deque_;
-
-  const bool use_circular_deque_ =
-      GetQuicReloadableFlag(quic_use_circular_deque_for_unacked_packets_v2);
 
   // The packet at the 0th index of unacked_packets_.
   QuicPacketNumber least_unacked_;
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index eb6b0a6..07efee9 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -658,7 +658,6 @@
 }
 
 TEST_P(QuicUnackedPacketMapTest, ReserveInitialCapacityTest) {
-  SetQuicReloadableFlag(quic_use_circular_deque_for_unacked_packets_v2, true);
   QuicUnackedPacketMap unacked_packets(GetParam());
   ASSERT_EQ(QuicUnackedPacketMapPeer::GetCapacity(unacked_packets), 0u);
   unacked_packets.ReserveInitialCapacity(16);