diff --git a/quic/core/quic_connection.cc b/quic/core/quic_connection.cc
index e987da9..03f5800 100644
--- a/quic/core/quic_connection.cc
+++ b/quic/core/quic_connection.cc
@@ -941,11 +941,11 @@
     return true;
   }
 
-  if (!GetLargestSentPacket().IsInitialized() ||
-      largest_acked > GetLargestSentPacket()) {
+  if (!sent_packet_manager_.GetLargestSentPacket().IsInitialized() ||
+      largest_acked > sent_packet_manager_.GetLargestSentPacket()) {
     QUIC_DLOG(WARNING) << ENDPOINT
                        << "Peer's observed unsent packet:" << largest_acked
-                       << " vs " << GetLargestSentPacket()
+                       << " vs " << sent_packet_manager_.GetLargestSentPacket()
                        << ". SupportsMultiplePacketNumberSpaces():"
                        << SupportsMultiplePacketNumberSpaces()
                        << ", last_decrypted_packet_level_:"
@@ -3965,14 +3965,6 @@
   return largest_seen_packet_with_ack_;
 }
 
-QuicPacketNumber QuicConnection::GetLargestSentPacket() const {
-  if (SupportsMultiplePacketNumberSpaces()) {
-    return sent_packet_manager_.GetLargestSentPacket(
-        last_decrypted_packet_level_);
-  }
-  return sent_packet_manager_.GetLargestSentPacket();
-}
-
 QuicPacketNumber QuicConnection::GetLargestAckedPacket() const {
   if (SupportsMultiplePacketNumberSpaces()) {
     return sent_packet_manager_.GetLargestAckedPacket(
diff --git a/quic/core/quic_framer.cc b/quic/core/quic_framer.cc
index ab99f05..080aa01 100644
--- a/quic/core/quic_framer.cc
+++ b/quic/core/quic_framer.cc
@@ -3586,7 +3586,13 @@
   }
 
   // Done processing the ACK frame.
-  return visitor_->OnAckFrameEnd(QuicPacketNumber(first_received));
+  if (!visitor_->OnAckFrameEnd(QuicPacketNumber(first_received))) {
+    set_detailed_error(
+        "Error occurs when visitor finishes processing the ACK frame.");
+    return false;
+  }
+
+  return true;
 }
 
 bool QuicFramer::ProcessTimestampsInAckFrame(uint8_t num_received_packets,
@@ -3817,7 +3823,13 @@
     ack_block_count--;
   }
 
-  return visitor_->OnAckFrameEnd(QuicPacketNumber(block_low));
+  if (!visitor_->OnAckFrameEnd(QuicPacketNumber(block_low))) {
+    set_detailed_error(
+        "Error occurs when visitor finishes processing the ACK frame.");
+    return false;
+  }
+
+  return true;
 }
 
 bool QuicFramer::ProcessStopWaitingFrame(QuicDataReader* reader,
diff --git a/quic/core/quic_sent_packet_manager.cc b/quic/core/quic_sent_packet_manager.cc
index 0137fde..767566c 100644
--- a/quic/core/quic_sent_packet_manager.cc
+++ b/quic/core/quic_sent_packet_manager.cc
@@ -1277,13 +1277,6 @@
       QuicUtils::GetPacketNumberSpace(decrypted_packet_level));
 }
 
-QuicPacketNumber QuicSentPacketManager::GetLargestSentPacket(
-    EncryptionLevel decrypted_packet_level) const {
-  DCHECK(supports_multiple_packet_number_spaces());
-  return unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-      decrypted_packet_level);
-}
-
 QuicPacketNumber QuicSentPacketManager::GetLargestPacketPeerKnowsIsAcked(
     EncryptionLevel decrypted_packet_level) const {
   DCHECK(supports_multiple_packet_number_spaces());
diff --git a/quic/core/quic_sent_packet_manager.h b/quic/core/quic_sent_packet_manager.h
index 686639a..ab53066 100644
--- a/quic/core/quic_sent_packet_manager.h
+++ b/quic/core/quic_sent_packet_manager.h
@@ -303,9 +303,6 @@
     return unacked_packets_.largest_sent_packet();
   }
 
-  QuicPacketNumber GetLargestSentPacket(
-      EncryptionLevel decrypted_packet_level) const;
-
   QuicPacketNumber GetLargestPacketPeerKnowsIsAcked(
       EncryptionLevel decrypted_packet_level) const;
 
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index f007562..49d0b1d 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -2457,16 +2457,23 @@
 
 TEST_F(QuicSentPacketManagerTest, MultiplePacketNumberSpaces) {
   manager_.EnableMultiplePacketNumberSpacesSupport();
+  const QuicUnackedPacketMap* unacked_packets =
+      QuicSentPacketManagerPeer::GetUnackedPacketMap(&manager_);
   EXPECT_FALSE(
-      manager_.GetLargestSentPacket(ENCRYPTION_INITIAL).IsInitialized());
+      unacked_packets
+          ->GetLargestSentRetransmittableOfPacketNumberSpace(INITIAL_DATA)
+          .IsInitialized());
   EXPECT_FALSE(
       manager_.GetLargestAckedPacket(ENCRYPTION_INITIAL).IsInitialized());
   // Send packet 1.
   SendDataPacket(1, ENCRYPTION_INITIAL);
   EXPECT_EQ(QuicPacketNumber(1),
-            manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_FALSE(
-      manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE).IsInitialized());
+      unacked_packets
+          ->GetLargestSentRetransmittableOfPacketNumberSpace(HANDSHAKE_DATA)
+          .IsInitialized());
   // Ack packet 1.
   ExpectAck(1);
   manager_.OnAckFrameStart(QuicPacketNumber(1), QuicTime::Delta::Infinite(),
@@ -2483,11 +2490,15 @@
   SendDataPacket(2, ENCRYPTION_HANDSHAKE);
   SendDataPacket(3, ENCRYPTION_HANDSHAKE);
   EXPECT_EQ(QuicPacketNumber(1),
-            manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_EQ(QuicPacketNumber(3),
-            manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                HANDSHAKE_DATA));
   EXPECT_FALSE(
-      manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT).IsInitialized());
+      unacked_packets
+          ->GetLargestSentRetransmittableOfPacketNumberSpace(APPLICATION_DATA)
+          .IsInitialized());
   // Ack packet 2.
   ExpectAck(2);
   manager_.OnAckFrameStart(QuicPacketNumber(2), QuicTime::Delta::Infinite(),
@@ -2516,13 +2527,14 @@
   SendDataPacket(4, ENCRYPTION_ZERO_RTT);
   SendDataPacket(5, ENCRYPTION_ZERO_RTT);
   EXPECT_EQ(QuicPacketNumber(1),
-            manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_EQ(QuicPacketNumber(3),
-            manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                HANDSHAKE_DATA));
   EXPECT_EQ(QuicPacketNumber(5),
-            manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT));
-  EXPECT_EQ(QuicPacketNumber(5),
-            manager_.GetLargestSentPacket(ENCRYPTION_FORWARD_SECURE));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                APPLICATION_DATA));
   // Ack packet 5.
   ExpectAck(5);
   manager_.OnAckFrameStart(QuicPacketNumber(5), QuicTime::Delta::Infinite(),
@@ -2543,13 +2555,14 @@
   SendDataPacket(7, ENCRYPTION_FORWARD_SECURE);
   SendDataPacket(8, ENCRYPTION_FORWARD_SECURE);
   EXPECT_EQ(QuicPacketNumber(1),
-            manager_.GetLargestSentPacket(ENCRYPTION_INITIAL));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_EQ(QuicPacketNumber(3),
-            manager_.GetLargestSentPacket(ENCRYPTION_HANDSHAKE));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                HANDSHAKE_DATA));
   EXPECT_EQ(QuicPacketNumber(8),
-            manager_.GetLargestSentPacket(ENCRYPTION_ZERO_RTT));
-  EXPECT_EQ(QuicPacketNumber(8),
-            manager_.GetLargestSentPacket(ENCRYPTION_FORWARD_SECURE));
+            unacked_packets->GetLargestSentRetransmittableOfPacketNumberSpace(
+                APPLICATION_DATA));
   // Ack all packets.
   uint64_t acked[] = {4, 6, 7, 8};
   ExpectAcksAndLosses(true, acked, QUICHE_ARRAYSIZE(acked), nullptr, 0);
diff --git a/quic/core/quic_unacked_packet_map.cc b/quic/core/quic_unacked_packet_map.cc
index 2db0f86..50f5c85 100644
--- a/quic/core/quic_unacked_packet_map.cc
+++ b/quic/core/quic_unacked_packet_map.cc
@@ -65,10 +65,6 @@
   largest_sent_largest_acked_.UpdateMax(packet->largest_acked);
 
   largest_sent_packet_ = packet_number;
-  if (supports_multiple_packet_number_spaces_) {
-    largest_sent_packets_[GetPacketNumberSpace(packet->encryption_level)] =
-        packet_number;
-  }
   if (set_in_flight) {
     bytes_in_flight_ += bytes_sent;
     ++packets_in_flight_;
@@ -456,10 +452,4 @@
   supports_multiple_packet_number_spaces_ = true;
 }
 
-QuicPacketNumber QuicUnackedPacketMap::GetLargestSentPacketOfPacketNumberSpace(
-    EncryptionLevel encryption_level) const {
-  DCHECK(supports_multiple_packet_number_spaces_);
-  return largest_sent_packets_[GetPacketNumberSpace(encryption_level)];
-}
-
 }  // namespace quic
diff --git a/quic/core/quic_unacked_packet_map.h b/quic/core/quic_unacked_packet_map.h
index c106fd3..61261a5 100644
--- a/quic/core/quic_unacked_packet_map.h
+++ b/quic/core/quic_unacked_packet_map.h
@@ -245,8 +245,6 @@
   const Perspective perspective_;
 
   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 per packet number
   // space.
   QuicPacketNumber
diff --git a/quic/core/quic_unacked_packet_map_test.cc b/quic/core/quic_unacked_packet_map_test.cc
index 7439675..560b8cb 100644
--- a/quic/core/quic_unacked_packet_map_test.cc
+++ b/quic/core/quic_unacked_packet_map_test.cc
@@ -564,20 +564,21 @@
 
 TEST_P(QuicUnackedPacketMapTest, LargestSentPacketMultiplePacketNumberSpaces) {
   unacked_packets_.EnableMultiplePacketNumberSpacesSupport();
-  EXPECT_FALSE(unacked_packets_
-                   .GetLargestSentPacketOfPacketNumberSpace(ENCRYPTION_INITIAL)
-                   .IsInitialized());
+  EXPECT_FALSE(
+      unacked_packets_
+          .GetLargestSentRetransmittableOfPacketNumberSpace(INITIAL_DATA)
+          .IsInitialized());
   // Send packet 1.
   SerializedPacket packet1(CreateRetransmittablePacket(1));
   packet1.encryption_level = ENCRYPTION_INITIAL;
   unacked_packets_.AddSentPacket(&packet1, NOT_RETRANSMISSION, now_, true);
   EXPECT_EQ(QuicPacketNumber(1u), unacked_packets_.largest_sent_packet());
   EXPECT_EQ(QuicPacketNumber(1),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_INITIAL));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_FALSE(
       unacked_packets_
-          .GetLargestSentPacketOfPacketNumberSpace(ENCRYPTION_HANDSHAKE)
+          .GetLargestSentRetransmittableOfPacketNumberSpace(HANDSHAKE_DATA)
           .IsInitialized());
   // Send packet 2.
   SerializedPacket packet2(CreateRetransmittablePacket(2));
@@ -585,33 +586,34 @@
   unacked_packets_.AddSentPacket(&packet2, NOT_RETRANSMISSION, now_, true);
   EXPECT_EQ(QuicPacketNumber(2u), unacked_packets_.largest_sent_packet());
   EXPECT_EQ(QuicPacketNumber(1),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_INITIAL));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_EQ(QuicPacketNumber(2),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_HANDSHAKE));
-  EXPECT_FALSE(unacked_packets_
-                   .GetLargestSentPacketOfPacketNumberSpace(ENCRYPTION_ZERO_RTT)
-                   .IsInitialized());
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                HANDSHAKE_DATA));
+  EXPECT_FALSE(
+      unacked_packets_
+          .GetLargestSentRetransmittableOfPacketNumberSpace(APPLICATION_DATA)
+          .IsInitialized());
   // Send packet 3.
   SerializedPacket packet3(CreateRetransmittablePacket(3));
   packet3.encryption_level = ENCRYPTION_ZERO_RTT;
   unacked_packets_.AddSentPacket(&packet3, NOT_RETRANSMISSION, now_, true);
   EXPECT_EQ(QuicPacketNumber(3u), unacked_packets_.largest_sent_packet());
   EXPECT_EQ(QuicPacketNumber(1),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_INITIAL));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_EQ(QuicPacketNumber(2),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_HANDSHAKE));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                HANDSHAKE_DATA));
   EXPECT_EQ(QuicPacketNumber(3),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_ZERO_RTT));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                APPLICATION_DATA));
   // Verify forward secure belongs to the same packet number space as encryption
   // zero rtt.
   EXPECT_EQ(QuicPacketNumber(3),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_FORWARD_SECURE));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                APPLICATION_DATA));
 
   // Send packet 4.
   SerializedPacket packet4(CreateRetransmittablePacket(4));
@@ -619,19 +621,19 @@
   unacked_packets_.AddSentPacket(&packet4, NOT_RETRANSMISSION, now_, true);
   EXPECT_EQ(QuicPacketNumber(4u), unacked_packets_.largest_sent_packet());
   EXPECT_EQ(QuicPacketNumber(1),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_INITIAL));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                INITIAL_DATA));
   EXPECT_EQ(QuicPacketNumber(2),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_HANDSHAKE));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                HANDSHAKE_DATA));
   EXPECT_EQ(QuicPacketNumber(4),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_ZERO_RTT));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                APPLICATION_DATA));
   // Verify forward secure belongs to the same packet number space as encryption
   // zero rtt.
   EXPECT_EQ(QuicPacketNumber(4),
-            unacked_packets_.GetLargestSentPacketOfPacketNumberSpace(
-                ENCRYPTION_FORWARD_SECURE));
+            unacked_packets_.GetLargestSentRetransmittableOfPacketNumberSpace(
+                APPLICATION_DATA));
 }
 
 }  // namespace