diff --git a/quic/core/congestion_control/general_loss_algorithm.cc b/quic/core/congestion_control/general_loss_algorithm.cc
index cf4bc35..d42896c 100644
--- a/quic/core/congestion_control/general_loss_algorithm.cc
+++ b/quic/core/congestion_control/general_loss_algorithm.cc
@@ -107,14 +107,12 @@
   }
   // Clear least_in_flight_.
   least_in_flight_.Clear();
-  DCHECK(!unacked_packets.use_uber_loss_algorithm() ||
-         packet_number_space_ ==
-             unacked_packets.GetPacketNumberSpace(largest_newly_acked));
+  DCHECK_EQ(packet_number_space_,
+            unacked_packets.GetPacketNumberSpace(largest_newly_acked));
   for (; it != unacked_packets.end() && packet_number <= largest_newly_acked;
        ++it, ++packet_number) {
-    if (unacked_packets.use_uber_loss_algorithm() &&
-        unacked_packets.GetPacketNumberSpace(it->encryption_level) !=
-            packet_number_space_) {
+    if (unacked_packets.GetPacketNumberSpace(it->encryption_level) !=
+        packet_number_space_) {
       // Skip packets of different packet number space.
       continue;
     }
@@ -146,16 +144,11 @@
     // there are retransmittable packets in flight.
     // This also implements a timer-protected variant of FACK.
     QuicPacketNumber largest_sent_retransmittable_packet;
-    if (unacked_packets.use_uber_loss_algorithm()) {
-      // Use largest_sent_retransmittable_packet of corresponding packet number
-      // space for timer based loss detection.
-      largest_sent_retransmittable_packet =
-          unacked_packets.GetLargestSentRetransmittableOfPacketNumberSpace(
-              packet_number_space_);
-    } else {
-      largest_sent_retransmittable_packet =
-          unacked_packets.largest_sent_retransmittable_packet();
-    }
+    // Use largest_sent_retransmittable_packet of corresponding packet number
+    // space for timer based loss detection.
+    largest_sent_retransmittable_packet =
+        unacked_packets.GetLargestSentRetransmittableOfPacketNumberSpace(
+            packet_number_space_);
     if (largest_sent_retransmittable_packet <= largest_newly_acked ||
         loss_type_ == kTime || loss_type_ == kAdaptiveTime) {
       QuicTime when_lost = it->sent_time + loss_delay;
diff --git a/quic/core/congestion_control/general_loss_algorithm.h b/quic/core/congestion_control/general_loss_algorithm.h
index 319203a..1dd5b2a 100644
--- a/quic/core/congestion_control/general_loss_algorithm.h
+++ b/quic/core/congestion_control/general_loss_algorithm.h
@@ -75,7 +75,6 @@
   // The least in flight packet. Loss detection should start from this. Please
   // note, least_in_flight_ could be largest packet ever sent + 1.
   QuicPacketNumber least_in_flight_;
-  // This is only used when quic_use_uber_loss_algorithm is true.
   PacketNumberSpace packet_number_space_;
 };
 
diff --git a/quic/core/congestion_control/general_loss_algorithm_test.cc b/quic/core/congestion_control/general_loss_algorithm_test.cc
index a249679..f2ebbb2 100644
--- a/quic/core/congestion_control/general_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/general_loss_algorithm_test.cc
@@ -27,9 +27,7 @@
     rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
                          QuicTime::Delta::Zero(), clock_.Now());
     EXPECT_LT(0, rtt_stats_.smoothed_rtt().ToMicroseconds());
-    if (unacked_packets_.use_uber_loss_algorithm()) {
-      loss_algorithm_.SetPacketNumberSpace(HANDSHAKE_DATA);
-    }
+    loss_algorithm_.SetPacketNumberSpace(HANDSHAKE_DATA);
   }
 
   ~GeneralLossAlgorithmTest() override {}
@@ -57,15 +55,8 @@
   void VerifyLosses(uint64_t largest_newly_acked,
                     const AckedPacketVector& packets_acked,
                     const std::vector<uint64_t>& losses_expected) {
-    if (unacked_packets_.use_uber_loss_algorithm()) {
-      unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
-          APPLICATION_DATA, QuicPacketNumber(largest_newly_acked));
-    } else if (!unacked_packets_.largest_acked().IsInitialized() ||
-               QuicPacketNumber(largest_newly_acked) >
-                   unacked_packets_.largest_acked()) {
-      unacked_packets_.IncreaseLargestAcked(
-          QuicPacketNumber(largest_newly_acked));
-    }
+    unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
+        APPLICATION_DATA, QuicPacketNumber(largest_newly_acked));
     LostPacketVector lost_packets;
     loss_algorithm_.DetectLosses(unacked_packets_, clock_.Now(), rtt_stats_,
                                  QuicPacketNumber(largest_newly_acked),
@@ -215,12 +206,8 @@
   clock_.AdvanceTime(rtt_stats_.smoothed_rtt());
 
   // Early retransmit when the final packet gets acked and the first is nacked.
-  if (unacked_packets_.use_uber_loss_algorithm()) {
-    unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
-        APPLICATION_DATA, QuicPacketNumber(2));
-  } else {
-    unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
-  }
+  unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
+      APPLICATION_DATA, QuicPacketNumber(2));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
   packets_acked.push_back(AckedPacket(
       QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
@@ -238,12 +225,8 @@
   clock_.AdvanceTime(rtt_stats_.smoothed_rtt());
 
   // Early retransmit when the final packet gets acked and the first is nacked.
-  if (unacked_packets_.use_uber_loss_algorithm()) {
-    unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
-        APPLICATION_DATA, QuicPacketNumber(2));
-  } else {
-    unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
-  }
+  unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
+      APPLICATION_DATA, QuicPacketNumber(2));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
   packets_acked.push_back(AckedPacket(
       QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
@@ -270,12 +253,8 @@
   AckedPacketVector packets_acked;
   // Wait another RTT and ack 2.
   clock_.AdvanceTime(rtt_stats_.smoothed_rtt());
-  if (unacked_packets_.use_uber_loss_algorithm()) {
-    unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
-        APPLICATION_DATA, QuicPacketNumber(2));
-  } else {
-    unacked_packets_.IncreaseLargestAcked(QuicPacketNumber(2));
-  }
+  unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
+      APPLICATION_DATA, QuicPacketNumber(2));
   unacked_packets_.RemoveFromInFlight(QuicPacketNumber(2));
   packets_acked.push_back(AckedPacket(
       QuicPacketNumber(2), kMaxOutgoingPacketSize, QuicTime::Zero()));
diff --git a/quic/core/congestion_control/uber_loss_algorithm.cc b/quic/core/congestion_control/uber_loss_algorithm.cc
index 8db151b..e0dff98 100644
--- a/quic/core/congestion_control/uber_loss_algorithm.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm.cc
@@ -37,7 +37,6 @@
     QuicPacketNumber /*largest_newly_acked*/,
     const AckedPacketVector& packets_acked,
     LostPacketVector* packets_lost) {
-  DCHECK(unacked_packets.use_uber_loss_algorithm());
   for (int8_t i = INITIAL_DATA; i < NUM_PACKET_NUMBER_SPACES; ++i) {
     const QuicPacketNumber largest_acked =
         unacked_packets.GetLargestAckedOfPacketNumberSpace(
@@ -76,7 +75,6 @@
     QuicTime time,
     const RttStats& rtt_stats,
     QuicPacketNumber spurious_retransmission) {
-  DCHECK(unacked_packets.use_uber_loss_algorithm());
   general_loss_algorithms_[unacked_packets.GetPacketNumberSpace(
                                spurious_retransmission)]
       .SpuriousRetransmitDetected(unacked_packets, time, rtt_stats,
diff --git a/quic/core/congestion_control/uber_loss_algorithm_test.cc b/quic/core/congestion_control/uber_loss_algorithm_test.cc
index 307d791..0c79ac5 100644
--- a/quic/core/congestion_control/uber_loss_algorithm_test.cc
+++ b/quic/core/congestion_control/uber_loss_algorithm_test.cc
@@ -21,7 +21,6 @@
 class UberLossAlgorithmTest : public QuicTest {
  protected:
   UberLossAlgorithmTest() {
-    SetQuicReloadableFlag(quic_use_uber_loss_algorithm, true);
     unacked_packets_ =
         QuicMakeUnique<QuicUnackedPacketMap>(Perspective::IS_CLIENT);
     rtt_stats_.UpdateRtt(QuicTime::Delta::FromMilliseconds(100),
diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index c99befb..fd1e5e8 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -817,10 +817,8 @@
   if (level == ENCRYPTION_FORWARD_SECURE &&
       perspective_ == Perspective::IS_SERVER) {
     sent_packet_manager_.SetHandshakeConfirmed();
-    if (sent_packet_manager_.unacked_packets().use_uber_loss_algorithm()) {
-      // This may have changed the retransmission timer, so re-arm it.
-      SetRetransmissionAlarm();
-    }
+    // This may have changed the retransmission timer, so re-arm it.
+    SetRetransmissionAlarm();
   }
 }
 
@@ -2443,10 +2441,8 @@
 
 void QuicConnection::OnHandshakeComplete() {
   sent_packet_manager_.SetHandshakeConfirmed();
-  if (sent_packet_manager_.unacked_packets().use_uber_loss_algorithm()) {
-    // This may have changed the retransmission timer, so re-arm it.
-    SetRetransmissionAlarm();
-  }
+  // This may have changed the retransmission timer, so re-arm it.
+  SetRetransmissionAlarm();
   // The client should immediately ack the SHLO to confirm the handshake is
   // complete with the server.
   if (perspective_ == Perspective::IS_CLIENT && ack_frame_updated()) {
@@ -3649,10 +3645,7 @@
 }
 
 void QuicConnection::MaybeEnableMultiplePacketNumberSpacesSupport() {
-  const bool enable_multiple_packet_number_spaces =
-      version().handshake_protocol == PROTOCOL_TLS1_3 &&
-      sent_packet_manager_.use_uber_loss_algorithm();
-  if (!enable_multiple_packet_number_spaces) {
+  if (version().handshake_protocol != PROTOCOL_TLS1_3) {
     return;
   }
   QUIC_DVLOG(1) << ENDPOINT << "connection " << connection_id()
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index d92ee66..71fbdf6 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -92,7 +92,6 @@
       network_change_visitor_(nullptr),
       initial_congestion_window_(kInitialCongestionWindow),
       loss_algorithm_(GetInitialLossAlgorithm()),
-      general_loss_algorithm_(loss_type),
       uber_loss_algorithm_(loss_type),
       consecutive_rto_count_(0),
       consecutive_tlp_count_(0),
@@ -131,10 +130,7 @@
 }
 
 LossDetectionInterface* QuicSentPacketManager::GetInitialLossAlgorithm() {
-  if (unacked_packets_.use_uber_loss_algorithm()) {
-    return &uber_loss_algorithm_;
-  }
-  return &general_loss_algorithm_;
+  return &uber_loss_algorithm_;
 }
 
 QuicSentPacketManager::~QuicSentPacketManager() {}
@@ -227,25 +223,13 @@
   }
   // Configure loss detection.
   if (config.HasClientRequestedIndependentOption(kTIME, perspective)) {
-    if (unacked_packets_.use_uber_loss_algorithm()) {
-      uber_loss_algorithm_.SetLossDetectionType(kTime);
-    } else {
-      general_loss_algorithm_.SetLossDetectionType(kTime);
-    }
+    uber_loss_algorithm_.SetLossDetectionType(kTime);
   }
   if (config.HasClientRequestedIndependentOption(kATIM, perspective)) {
-    if (unacked_packets_.use_uber_loss_algorithm()) {
-      uber_loss_algorithm_.SetLossDetectionType(kAdaptiveTime);
-    } else {
-      general_loss_algorithm_.SetLossDetectionType(kAdaptiveTime);
-    }
+    uber_loss_algorithm_.SetLossDetectionType(kAdaptiveTime);
   }
   if (config.HasClientRequestedIndependentOption(kLFAK, perspective)) {
-    if (unacked_packets_.use_uber_loss_algorithm()) {
-      uber_loss_algorithm_.SetLossDetectionType(kLazyFack);
-    } else {
-      general_loss_algorithm_.SetLossDetectionType(kLazyFack);
-    }
+    uber_loss_algorithm_.SetLossDetectionType(kLazyFack);
   }
   if (config.HasClientSentConnectionOption(kCONH, perspective)) {
     conservative_handshake_retransmits_ = true;
@@ -293,9 +277,7 @@
 
 void QuicSentPacketManager::SetHandshakeConfirmed() {
   handshake_confirmed_ = true;
-  if (unacked_packets_.use_uber_loss_algorithm()) {
-    NeuterHandshakePackets();
-  }
+  NeuterHandshakePackets();
 }
 
 void QuicSentPacketManager::PostProcessNewlyAckedPackets(
@@ -434,7 +416,6 @@
 }
 
 void QuicSentPacketManager::NeuterHandshakePackets() {
-  DCHECK(unacked_packets_.use_uber_loss_algorithm());
   QuicPacketNumber packet_number = unacked_packets_.GetLeastUnacked();
   for (QuicUnackedPacketMap::const_iterator it = unacked_packets_.begin();
        it != unacked_packets_.end(); ++it, ++packet_number) {
@@ -1227,9 +1208,7 @@
                   << QuicUtils::EncryptionLevelToString(ack_decrypted_level)
                   << " ack for packet " << acked_packet.packet_number;
     const PacketNumberSpace packet_number_space =
-        unacked_packets_.use_uber_loss_algorithm()
-            ? unacked_packets_.GetPacketNumberSpace(info->encryption_level)
-            : NUM_PACKET_NUMBER_SPACES;
+        unacked_packets_.GetPacketNumberSpace(info->encryption_level);
     if (supports_multiple_packet_number_spaces() &&
         QuicUtils::GetPacketNumberSpace(ack_decrypted_level) !=
             packet_number_space) {
@@ -1249,10 +1228,8 @@
       // Unackable packets are skipped earlier.
       largest_newly_acked_ = acked_packet.packet_number;
     }
-    if (unacked_packets_.use_uber_loss_algorithm()) {
-      unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
-          packet_number_space, acked_packet.packet_number);
-    }
+    unacked_packets_.MaybeUpdateLargestAckedOfPacketNumberSpace(
+        packet_number_space, acked_packet.packet_number);
     MarkPacketHandled(acked_packet.packet_number, info,
                       last_ack_frame_.ack_delay_time,
                       acked_packet.receive_timestamp);
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index 8d230a2..d6f5400 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -144,8 +144,7 @@
 
   // Removes the retransmittable frames from all unencrypted packets to ensure
   // they don't get retransmitted.
-  // TODO(fayang): Consider remove this function when deprecating
-  // quic_use_uber_loss_algorithm.
+  // TODO(fayang): Consider replace this function with NeuterHandshakePackets.
   void NeuterUnencryptedPackets();
 
   // Returns true if there are pending retransmissions.
@@ -381,10 +380,6 @@
     return unacked_packets_.supports_multiple_packet_number_spaces();
   }
 
-  bool use_uber_loss_algorithm() const {
-    return unacked_packets_.use_uber_loss_algorithm();
-  }
-
   bool ignore_tlpr_if_no_pending_stream_data() const {
     return ignore_tlpr_if_no_pending_stream_data_;
   }
@@ -518,9 +513,8 @@
   // Called when handshake is confirmed to remove the retransmittable frames
   // from all packets of HANDSHAKE_DATA packet number space to ensure they don't
   // get retransmitted and will eventually be removed from unacked packets map.
-  // Only used when quic_use_uber_loss_algorithm is true. Please note, this only
-  // applies to QUIC Crypto and needs to be changed when switches to IETF QUIC
-  // with QUIC TLS.
+  // Please note, this only applies to QUIC Crypto and needs to be changed when
+  // switches to IETF QUIC with QUIC TLS.
   void NeuterHandshakePackets();
 
   // Newly serialized retransmittable packets are added to this map, which
@@ -547,9 +541,6 @@
   std::unique_ptr<SendAlgorithmInterface> send_algorithm_;
   // Not owned. Always points to |general_loss_algorithm_| outside of tests.
   LossDetectionInterface* loss_algorithm_;
-  // TODO(fayang): Remove general_loss_algorithm_ when deprecating
-  // quic_use_uber_loss_algorithm.
-  GeneralLossAlgorithm general_loss_algorithm_;
   UberLossAlgorithm uber_loss_algorithm_;
 
   // Tracks the first RTO packet.  If any packet before that packet gets acked,
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index 2fbd85f..5d65c15 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -2666,9 +2666,6 @@
 }
 
 TEST_P(QuicSentPacketManagerTest, MultiplePacketNumberSpaces) {
-  if (!GetQuicReloadableFlag(quic_use_uber_loss_algorithm)) {
-    return;
-  }
   manager_.EnableMultiplePacketNumberSpacesSupport();
   EXPECT_FALSE(
       manager_.GetLargestSentPacket(ENCRYPTION_INITIAL).IsInitialized());
@@ -2776,9 +2773,6 @@
 }
 
 TEST_P(QuicSentPacketManagerTest, PacketsGetAckedInWrongPacketNumberSpace) {
-  if (!GetQuicReloadableFlag(quic_use_uber_loss_algorithm)) {
-    return;
-  }
   manager_.EnableMultiplePacketNumberSpacesSupport();
   // Send packet 1.
   SendDataPacket(1, ENCRYPTION_INITIAL);
@@ -2795,9 +2789,6 @@
 }
 
 TEST_P(QuicSentPacketManagerTest, PacketsGetAckedInWrongPacketNumberSpace2) {
-  if (!GetQuicReloadableFlag(quic_use_uber_loss_algorithm)) {
-    return;
-  }
   manager_.EnableMultiplePacketNumberSpacesSupport();
   // Send packet 1.
   SendDataPacket(1, ENCRYPTION_INITIAL);
@@ -2815,9 +2806,6 @@
 
 TEST_P(QuicSentPacketManagerTest,
        ToleratePacketsGetAckedInWrongPacketNumberSpace) {
-  if (!GetQuicReloadableFlag(quic_use_uber_loss_algorithm)) {
-    return;
-  }
   manager_.EnableMultiplePacketNumberSpacesSupport();
   // Send packet 1.
   SendDataPacket(1, ENCRYPTION_INITIAL);
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index 513eb36..2923ae1 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -32,13 +32,7 @@
       last_crypto_packet_sent_time_(QuicTime::Zero()),
       session_notifier_(nullptr),
       session_decides_what_to_write_(false),
-      use_uber_loss_algorithm_(
-          GetQuicReloadableFlag(quic_use_uber_loss_algorithm)),
-      supports_multiple_packet_number_spaces_(false) {
-  if (use_uber_loss_algorithm_) {
-    QUIC_RELOADABLE_FLAG_COUNT(quic_use_uber_loss_algorithm);
-  }
-}
+      supports_multiple_packet_number_spaces_(false) {}
 
 QuicUnackedPacketMap::~QuicUnackedPacketMap() {
   for (QuicTransmissionInfo& transmission_info : unacked_packets_) {
@@ -83,12 +77,8 @@
   if (set_in_flight) {
     bytes_in_flight_ += bytes_sent;
     info.in_flight = true;
-    if (use_uber_loss_algorithm_) {
-      largest_sent_retransmittable_packets_[GetPacketNumberSpace(
-          info.encryption_level)] = packet_number;
-    } else {
-      largest_sent_retransmittable_packet_ = packet_number;
-    }
+    largest_sent_retransmittable_packets_[GetPacketNumberSpace(
+        info.encryption_level)] = packet_number;
   }
   unacked_packets_.push_back(info);
   // Swap the retransmittable frames to avoid allocations.
@@ -231,7 +221,6 @@
 void QuicUnackedPacketMap::MaybeUpdateLargestAckedOfPacketNumberSpace(
     PacketNumberSpace packet_number_space,
     QuicPacketNumber packet_number) {
-  DCHECK(use_uber_loss_algorithm_);
   largest_acked_packets_[packet_number_space].UpdateMax(packet_number);
 }
 
@@ -501,14 +490,12 @@
 
 PacketNumberSpace QuicUnackedPacketMap::GetPacketNumberSpace(
     QuicPacketNumber packet_number) const {
-  DCHECK(use_uber_loss_algorithm_);
   return GetPacketNumberSpace(
       GetTransmissionInfo(packet_number).encryption_level);
 }
 
 PacketNumberSpace QuicUnackedPacketMap::GetPacketNumberSpace(
     EncryptionLevel encryption_level) const {
-  DCHECK(use_uber_loss_algorithm_);
   if (supports_multiple_packet_number_spaces_) {
     return QuicUtils::GetPacketNumberSpace(encryption_level);
   }
@@ -522,7 +509,6 @@
 
 QuicPacketNumber QuicUnackedPacketMap::GetLargestAckedOfPacketNumberSpace(
     PacketNumberSpace packet_number_space) const {
-  DCHECK(use_uber_loss_algorithm_);
   if (packet_number_space >= NUM_PACKET_NUMBER_SPACES) {
     QUIC_BUG << "Invalid packet number space: " << packet_number_space;
     return QuicPacketNumber();
@@ -533,7 +519,6 @@
 QuicPacketNumber
 QuicUnackedPacketMap::GetLargestSentRetransmittableOfPacketNumberSpace(
     PacketNumberSpace packet_number_space) const {
-  DCHECK(use_uber_loss_algorithm_);
   if (packet_number_space >= NUM_PACKET_NUMBER_SPACES) {
     QUIC_BUG << "Invalid packet number space: " << packet_number_space;
     return QuicPacketNumber();
diff --git a/quic/core/quic_unacked_packet_map.h b/quic/core/quic_unacked_packet_map.h
index f9f718e..64d1da8 100644
--- a/quic/core/quic_unacked_packet_map.h
+++ b/quic/core/quic_unacked_packet_map.h
@@ -91,12 +91,6 @@
   // Returns the largest packet number that has been sent.
   QuicPacketNumber largest_sent_packet() const { return largest_sent_packet_; }
 
-  // Returns the largest retransmittable packet number that has been sent.
-  QuicPacketNumber largest_sent_retransmittable_packet() const {
-    DCHECK(!use_uber_loss_algorithm_);
-    return largest_sent_retransmittable_packet_;
-  }
-
   QuicPacketNumber largest_sent_largest_acked() const {
     return largest_sent_largest_acked_;
   }
@@ -227,8 +221,6 @@
     return session_decides_what_to_write_;
   }
 
-  bool use_uber_loss_algorithm() const { return use_uber_loss_algorithm_; }
-
   Perspective perspective() const { return perspective_; }
 
   bool supports_multiple_packet_number_spaces() const {
@@ -269,12 +261,8 @@
   QuicPacketNumber largest_sent_packet_;
   // Only used when supports_multiple_packet_number_spaces_ is true.
   QuicPacketNumber largest_sent_packets_[NUM_PACKET_NUMBER_SPACES];
-  // The largest sent packet we expect to receive an ack for.
-  // TODO(fayang): Remove largest_sent_retransmittable_packet_ when deprecating
-  // quic_use_uber_loss_algorithm.
-  QuicPacketNumber largest_sent_retransmittable_packet_;
   // The largest sent packet we expect to receive an ack for per packet number
-  // space. Only used if use_uber_loss_algorithm_ is true.
+  // space.
   QuicPacketNumber
       largest_sent_retransmittable_packets_[NUM_PACKET_NUMBER_SPACES];
   // The largest sent largest_acked in an ACK frame.
@@ -282,7 +270,6 @@
   // The largest received largest_acked from an ACK frame.
   QuicPacketNumber largest_acked_;
   // The largest received largest_acked from ACK frame per packet number space.
-  // Only used if use_uber_loss_algorithm_ is true.
   QuicPacketNumber largest_acked_packets_[NUM_PACKET_NUMBER_SPACES];
 
   // Newly serialized retransmittable packets are added to this map, which
@@ -314,9 +301,6 @@
   // If true, let session decides what to write.
   bool session_decides_what_to_write_;
 
-  // Latched value of quic_use_uber_loss_algorithm.
-  const bool use_uber_loss_algorithm_;
-
   // If true, supports multiple packet number spaces.
   bool supports_multiple_packet_number_spaces_;
 };
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index ff26542..fdec7a6 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -675,9 +675,6 @@
 }
 
 TEST_P(QuicUnackedPacketMapTest, LargestSentPacketMultiplePacketNumberSpaces) {
-  if (!GetQuicReloadableFlag(quic_use_uber_loss_algorithm)) {
-    return;
-  }
   unacked_packets_.EnableMultiplePacketNumberSpacesSupport();
   EXPECT_FALSE(unacked_packets_
                    .GetLargestSentPacketOfPacketNumberSpace(ENCRYPTION_INITIAL)
diff --git a/quic/core/quic_versions.cc b/quic/core/quic_versions.cc
index 906bdab..349b373 100644
--- a/quic/core/quic_versions.cc
+++ b/quic/core/quic_versions.cc
@@ -430,7 +430,6 @@
   // Enable necessary flags.
   SetQuicFlag(FLAGS_quic_supports_tls_handshake, true);
   SetQuicFlag(FLAGS_quic_headers_stream_id_in_v99, 60);
-  SetQuicReloadableFlag(quic_use_uber_loss_algorithm, true);
   SetQuicReloadableFlag(quic_eliminate_static_stream_map_3, true);
   SetQuicReloadableFlag(quic_tolerate_reneging, true);
   SetQuicReloadableFlag(quic_simplify_stop_waiting, true);