diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index 001b496..c99befb 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -66,11 +66,6 @@
 // The minimum release time into future in ms.
 const int kMinReleaseTimeIntoFutureMs = 1;
 
-bool Near(QuicPacketNumber a, QuicPacketNumber b) {
-  QuicPacketCount delta = (a > b) ? a - b : b - a;
-  return delta <= kMaxPacketGap;
-}
-
 // An alarm that is scheduled to send an ack if a timeout occurs.
 class AckAlarmDelegate : public QuicAlarm::Delegate {
  public:
@@ -256,7 +251,6 @@
       idle_timeout_connection_close_behavior_(
           ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET),
       close_connection_after_five_rtos_(false),
-      received_packet_manager_(&stats_),
       uber_received_packet_manager_(&stats_),
       stop_waiting_count_(0),
       pending_retransmission_alarm_(false),
@@ -329,16 +323,11 @@
       supports_release_time_(false),
       release_time_into_future_(QuicTime::Delta::Zero()),
       no_version_negotiation_(supported_versions.size() == 1),
-      retry_has_been_parsed_(false),
-      use_uber_received_packet_manager_(
-          GetQuicReloadableFlag(quic_use_uber_received_packet_manager)) {
+      retry_has_been_parsed_(false) {
   if (perspective_ == Perspective::IS_SERVER &&
       supported_versions.size() == 1) {
     QUIC_RESTART_FLAG_COUNT(quic_no_server_conn_ver_negotiation2);
   }
-  if (use_uber_received_packet_manager_) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_use_uber_received_packet_manager);
-  }
   QUIC_DLOG(INFO) << ENDPOINT << "Created connection with server connection ID "
                   << server_connection_id
                   << " and version: " << ParsedQuicVersionToString(version());
@@ -364,11 +353,7 @@
   SetMaxPacketLength(perspective_ == Perspective::IS_SERVER
                          ? kDefaultServerMaxPacketSize
                          : kDefaultMaxPacketSize);
-  if (use_uber_received_packet_manager_) {
-    uber_received_packet_manager_.set_max_ack_ranges(255);
-  } else {
-    received_packet_manager_.set_max_ack_ranges(255);
-  }
+  uber_received_packet_manager_.set_max_ack_ranges(255);
   MaybeEnableSessionDecidesWhatToWrite();
   MaybeEnableMultiplePacketNumberSpacesSupport();
   DCHECK(!GetQuicRestartFlag(quic_no_server_conn_ver_negotiation2) ||
@@ -437,11 +422,7 @@
   if (debug_visitor_ != nullptr) {
     debug_visitor_->OnSetFromConfig(config);
   }
-  if (use_uber_received_packet_manager_) {
-    uber_received_packet_manager_.SetFromConfig(config, perspective_);
-  } else {
-    received_packet_manager_.SetFromConfig(config, perspective_);
-  }
+  uber_received_packet_manager_.SetFromConfig(config, perspective_);
   if (config.HasClientSentConnectionOption(k5RTO, perspective_)) {
     close_connection_after_five_rtos_ = true;
   }
@@ -456,11 +437,7 @@
       config.HasClientSentConnectionOption(kSTMP, perspective_)) {
     QUIC_RELOADABLE_FLAG_COUNT(quic_send_timestamps);
     framer_.set_process_timestamps(true);
-    if (use_uber_received_packet_manager_) {
-      uber_received_packet_manager_.set_save_timestamps(true);
-    } else {
-      received_packet_manager_.set_save_timestamps(true);
-    }
+    uber_received_packet_manager_.set_save_timestamps(true);
   }
 
   supports_release_time_ =
@@ -912,14 +889,9 @@
 
   // Record packet receipt to populate ack info before processing stream
   // frames, since the processing may result in sending a bundled ack.
-  if (use_uber_received_packet_manager_) {
-    uber_received_packet_manager_.RecordPacketReceived(
-        last_decrypted_packet_level_, last_header_,
-        time_of_last_received_packet_);
-  } else {
-    received_packet_manager_.RecordPacketReceived(
-        last_header_, time_of_last_received_packet_);
-  }
+  uber_received_packet_manager_.RecordPacketReceived(
+      last_decrypted_packet_level_, last_header_,
+      time_of_last_received_packet_);
   DCHECK(connected_);
   return true;
 }
@@ -1138,12 +1110,8 @@
   }
 
   largest_seen_packet_with_stop_waiting_ = last_header_.packet_number;
-  if (use_uber_received_packet_manager_) {
-    uber_received_packet_manager_.DontWaitForPacketsBefore(
-        last_decrypted_packet_level_, frame.least_unacked);
-  } else {
-    received_packet_manager_.DontWaitForPacketsBefore(frame.least_unacked);
-  }
+  uber_received_packet_manager_.DontWaitForPacketsBefore(
+      last_decrypted_packet_level_, frame.least_unacked);
   return connected_;
 }
 
@@ -1171,9 +1139,7 @@
 const char* QuicConnection::ValidateStopWaitingFrame(
     const QuicStopWaitingFrame& stop_waiting) {
   const QuicPacketNumber peer_least_packet_awaiting_ack =
-      use_uber_received_packet_manager_
-          ? uber_received_packet_manager_.peer_least_packet_awaiting_ack()
-          : received_packet_manager_.peer_least_packet_awaiting_ack();
+      uber_received_packet_manager_.peer_least_packet_awaiting_ack();
   if (peer_least_packet_awaiting_ack.IsInitialized() &&
       stop_waiting.least_unacked < peer_least_packet_awaiting_ack) {
     QUIC_DLOG(ERROR) << ENDPOINT << "Peer's sent low least_unacked: "
@@ -1451,38 +1417,30 @@
 
   current_effective_peer_migration_type_ = NO_CHANGE;
 
-  if (use_uber_received_packet_manager_) {
-    // Some encryption levels share a packet number space, it is therefore
-    // possible for us to want to ack some packets even though we do not yet
-    // have the appropriate keys to encrypt the acks. In this scenario we
-    // do not update the ACK timeout. This can happen for example with
-    // IETF QUIC on the server when we receive 0-RTT packets and do not yet
-    // have 1-RTT keys (0-RTT packets are acked at the 1-RTT level).
-    // Note that this could cause slight performance degradations in the edge
-    // case where one packet is received, then the encrypter is installed,
-    // then a second packet is received; as that could cause the ACK for the
-    // second packet to be delayed instead of immediate. This is currently
-    // considered to be small enough of an edge case to not be optimized for.
-    if (!SupportsMultiplePacketNumberSpaces() ||
-        framer_.HasEncrypterOfEncryptionLevel(QuicUtils::GetEncryptionLevel(
-            QuicUtils::GetPacketNumberSpace(last_decrypted_packet_level_)))) {
-      uber_received_packet_manager_.MaybeUpdateAckTimeout(
-          should_last_packet_instigate_acks_, last_decrypted_packet_level_,
-          last_header_.packet_number, time_of_last_received_packet_,
-          clock_->ApproximateNow(), sent_packet_manager_.GetRttStats(),
-          sent_packet_manager_.delayed_ack_time());
-    } else {
-      QUIC_DLOG(INFO) << ENDPOINT << "Not updating ACK timeout for "
-                      << QuicUtils::EncryptionLevelToString(
-                             last_decrypted_packet_level_)
-                      << " as we do not have the corresponding encrypter";
-    }
-  } else {
-    received_packet_manager_.MaybeUpdateAckTimeout(
-        should_last_packet_instigate_acks_, last_header_.packet_number,
-        time_of_last_received_packet_, clock_->ApproximateNow(),
-        sent_packet_manager_.GetRttStats(),
+  // Some encryption levels share a packet number space, it is therefore
+  // possible for us to want to ack some packets even though we do not yet
+  // have the appropriate keys to encrypt the acks. In this scenario we
+  // do not update the ACK timeout. This can happen for example with
+  // IETF QUIC on the server when we receive 0-RTT packets and do not yet
+  // have 1-RTT keys (0-RTT packets are acked at the 1-RTT level).
+  // Note that this could cause slight performance degradations in the edge
+  // case where one packet is received, then the encrypter is installed,
+  // then a second packet is received; as that could cause the ACK for the
+  // second packet to be delayed instead of immediate. This is currently
+  // considered to be small enough of an edge case to not be optimized for.
+  if (!SupportsMultiplePacketNumberSpaces() ||
+      framer_.HasEncrypterOfEncryptionLevel(QuicUtils::GetEncryptionLevel(
+          QuicUtils::GetPacketNumberSpace(last_decrypted_packet_level_)))) {
+    uber_received_packet_manager_.MaybeUpdateAckTimeout(
+        should_last_packet_instigate_acks_, last_decrypted_packet_level_,
+        last_header_.packet_number, time_of_last_received_packet_,
+        clock_->ApproximateNow(), sent_packet_manager_.GetRttStats(),
         sent_packet_manager_.delayed_ack_time());
+  } else {
+    QUIC_DLOG(INFO) << ENDPOINT << "Not updating ACK timeout for "
+                    << QuicUtils::EncryptionLevelToString(
+                           last_decrypted_packet_level_)
+                    << " as we do not have the corresponding encrypter";
   }
 
   ClearLastFrames();
@@ -1527,12 +1485,9 @@
 }
 
 const QuicFrame QuicConnection::GetUpdatedAckFrame() {
-  if (use_uber_received_packet_manager_) {
-    return uber_received_packet_manager_.GetUpdatedAckFrame(
-        QuicUtils::GetPacketNumberSpace(encryption_level_),
-        clock_->ApproximateNow());
-  }
-  return received_packet_manager_.GetUpdatedAckFrame(clock_->ApproximateNow());
+  return uber_received_packet_manager_.GetUpdatedAckFrame(
+      QuicUtils::GetPacketNumberSpace(encryption_level_),
+      clock_->ApproximateNow());
 }
 
 void QuicConnection::PopulateStopWaitingFrame(
@@ -1853,9 +1808,7 @@
 
   WriteQueuedPackets();
   const QuicTime ack_timeout =
-      use_uber_received_packet_manager_
-          ? uber_received_packet_manager_.GetEarliestAckTimeout()
-          : received_packet_manager_.ack_timeout();
+      uber_received_packet_manager_.GetEarliestAckTimeout();
   if (ack_timeout.IsInitialized() && ack_timeout <= clock_->ApproximateNow()) {
     // Send an ACK now because either 1) we were write blocked when we last
     // tried to send an ACK, or 2) both ack alarm and send alarm were set to
@@ -1977,49 +1930,18 @@
     QuicPacketNumber packet_number) {
   // If this packet has already been seen, or the sender has told us that it
   // will not be retransmitted, then stop processing the packet.
-  const bool is_awaiting =
-      use_uber_received_packet_manager_
-          ? uber_received_packet_manager_.IsAwaitingPacket(
-                last_decrypted_packet_level_, packet_number)
-          : received_packet_manager_.IsAwaitingPacket(packet_number);
-  if (!is_awaiting) {
-    if (use_uber_received_packet_manager_) {
-      QUIC_DLOG(INFO) << ENDPOINT << "Packet " << packet_number
-                      << " no longer being waited for at level "
-                      << static_cast<int>(last_decrypted_packet_level_)
-                      << ".  Discarding.";
-    } else {
-      QUIC_DLOG(INFO) << ENDPOINT << "Packet " << packet_number
-                      << " no longer being waited for.  Discarding.";
-    }
+  if (!uber_received_packet_manager_.IsAwaitingPacket(
+          last_decrypted_packet_level_, packet_number)) {
+    QUIC_DLOG(INFO) << ENDPOINT << "Packet " << packet_number
+                    << " no longer being waited for at level "
+                    << static_cast<int>(last_decrypted_packet_level_)
+                    << ".  Discarding.";
     if (debug_visitor_ != nullptr) {
       debug_visitor_->OnDuplicatePacket(packet_number);
     }
     return false;
   }
 
-  if (use_uber_received_packet_manager_) {
-    // When using uber_received_packet_manager, accept any packet numbers.
-    return true;
-  }
-
-  // Configured to accept any packet number in range 1...0x7fffffff as initial
-  // packet number.
-  bool out_of_bound = false;
-  std::string error_detail = "Packet number out of bounds.";
-  if (last_header_.packet_number.IsInitialized()) {
-    out_of_bound = !Near(packet_number, last_header_.packet_number);
-  } else if ((packet_number > MaxRandomInitialPacketNumber())) {
-    out_of_bound = true;
-    error_detail = "Initial packet number out of bounds.";
-  }
-  if (out_of_bound) {
-    QUIC_DLOG(INFO) << ENDPOINT << "Packet " << packet_number
-                    << " out of bounds.  Discarding";
-    CloseConnection(QUIC_INVALID_PACKET_HEADER, error_detail,
-                    ConnectionCloseBehavior::SEND_CONNECTION_CLOSE_PACKET);
-    return false;
-  }
   return true;
 }
 
@@ -2131,15 +2053,10 @@
 
 const QuicFrames QuicConnection::MaybeBundleAckOpportunistically() {
   QuicFrames frames;
-  bool has_pending_ack = false;
-  if (use_uber_received_packet_manager_) {
-    has_pending_ack =
-        uber_received_packet_manager_
-            .GetAckTimeout(QuicUtils::GetPacketNumberSpace(encryption_level_))
-            .IsInitialized();
-  } else {
-    has_pending_ack = received_packet_manager_.ack_timeout().IsInitialized();
-  }
+  const bool has_pending_ack =
+      uber_received_packet_manager_
+          .GetAckTimeout(QuicUtils::GetPacketNumberSpace(encryption_level_))
+          .IsInitialized();
   if (!has_pending_ack && stop_waiting_count_ <= 1) {
     // No need to send an ACK.
     return frames;
@@ -3080,9 +2997,7 @@
 
   if (flush_and_set_pending_retransmission_alarm_on_delete_) {
     const QuicTime ack_timeout =
-        connection_->use_uber_received_packet_manager_
-            ? connection_->uber_received_packet_manager_.GetEarliestAckTimeout()
-            : connection_->received_packet_manager_.ack_timeout();
+        connection_->uber_received_packet_manager_.GetEarliestAckTimeout();
     if (ack_timeout.IsInitialized()) {
       if (ack_timeout <= connection_->clock_->ApproximateNow() &&
           !connection_->CanWrite(NO_RETRANSMITTABLE_DATA)) {
@@ -3404,10 +3319,7 @@
 }
 
 bool QuicConnection::ack_frame_updated() const {
-  if (use_uber_received_packet_manager_) {
-    return uber_received_packet_manager_.IsAckFrameUpdated();
-  }
-  return received_packet_manager_.ack_frame_updated();
+  return uber_received_packet_manager_.IsAckFrameUpdated();
 }
 
 QuicStringPiece QuicConnection::GetCurrentPacket() {
@@ -3552,14 +3464,9 @@
 void QuicConnection::PostProcessAfterAckFrame(bool send_stop_waiting,
                                               bool acked_new_packet) {
   if (no_stop_waiting_frames_) {
-    if (use_uber_received_packet_manager_) {
-      uber_received_packet_manager_.DontWaitForPacketsBefore(
-          last_decrypted_packet_level_,
-          sent_packet_manager_.largest_packet_peer_knows_is_acked());
-    } else {
-      received_packet_manager_.DontWaitForPacketsBefore(
-          sent_packet_manager_.largest_packet_peer_knows_is_acked());
-    }
+    uber_received_packet_manager_.DontWaitForPacketsBefore(
+        last_decrypted_packet_level_,
+        sent_packet_manager_.largest_packet_peer_knows_is_acked());
   }
   // Always reset the retransmission alarm when an ack comes in, since we now
   // have a better estimate of the current rtt than when it was set.
@@ -3620,11 +3527,7 @@
 void QuicConnection::ResetAckStates() {
   ack_alarm_->Cancel();
   stop_waiting_count_ = 0;
-  if (use_uber_received_packet_manager_) {
-    uber_received_packet_manager_.ResetAckStates(encryption_level_);
-  } else {
-    received_packet_manager_.ResetAckStates();
-  }
+  uber_received_packet_manager_.ResetAckStates(encryption_level_);
 }
 
 MessageStatus QuicConnection::SendMessage(QuicMessageId message_id,
@@ -3748,7 +3651,6 @@
 void QuicConnection::MaybeEnableMultiplePacketNumberSpacesSupport() {
   const bool enable_multiple_packet_number_spaces =
       version().handshake_protocol == PROTOCOL_TLS1_3 &&
-      use_uber_received_packet_manager_ &&
       sent_packet_manager_.use_uber_loss_algorithm();
   if (!enable_multiple_packet_number_spaces) {
     return;
@@ -3799,44 +3701,27 @@
 }
 
 QuicPacketNumber QuicConnection::GetLargestReceivedPacket() const {
-  if (use_uber_received_packet_manager_) {
-    return uber_received_packet_manager_.GetLargestObserved(
-        last_decrypted_packet_level_);
-  }
-  return received_packet_manager_.GetLargestObserved();
+  return uber_received_packet_manager_.GetLargestObserved(
+      last_decrypted_packet_level_);
 }
 
 size_t QuicConnection::min_received_before_ack_decimation() const {
-  if (use_uber_received_packet_manager_) {
-    return uber_received_packet_manager_.min_received_before_ack_decimation();
-  }
-  return received_packet_manager_.min_received_before_ack_decimation();
+  return uber_received_packet_manager_.min_received_before_ack_decimation();
 }
 
 void QuicConnection::set_min_received_before_ack_decimation(size_t new_value) {
-  if (use_uber_received_packet_manager_) {
-    uber_received_packet_manager_.set_min_received_before_ack_decimation(
-        new_value);
-  } else {
-    received_packet_manager_.set_min_received_before_ack_decimation(new_value);
-  }
+  uber_received_packet_manager_.set_min_received_before_ack_decimation(
+      new_value);
 }
 
 size_t QuicConnection::ack_frequency_before_ack_decimation() const {
-  if (use_uber_received_packet_manager_) {
-    return uber_received_packet_manager_.ack_frequency_before_ack_decimation();
-  }
-  return received_packet_manager_.ack_frequency_before_ack_decimation();
+  return uber_received_packet_manager_.ack_frequency_before_ack_decimation();
 }
 
 void QuicConnection::set_ack_frequency_before_ack_decimation(size_t new_value) {
   DCHECK_GT(new_value, 0u);
-  if (use_uber_received_packet_manager_) {
-    uber_received_packet_manager_.set_ack_frequency_before_ack_decimation(
-        new_value);
-  } else {
-    received_packet_manager_.set_ack_frequency_before_ack_decimation(new_value);
-  }
+  uber_received_packet_manager_.set_ack_frequency_before_ack_decimation(
+      new_value);
 }
 
 const QuicAckFrame& QuicConnection::ack_frame() const {
@@ -3844,10 +3729,7 @@
     return uber_received_packet_manager_.GetAckFrame(
         QuicUtils::GetPacketNumberSpace(last_decrypted_packet_level_));
   }
-  if (use_uber_received_packet_manager_) {
-    return uber_received_packet_manager_.ack_frame();
-  }
-  return received_packet_manager_.ack_frame();
+  return uber_received_packet_manager_.ack_frame();
 }
 
 void QuicConnection::set_client_connection_id(