diff --git a/quic/core/quic_connection_test.cc b/quic/core/quic_connection_test.cc
index 56b0453..5d35353 100644
--- a/quic/core/quic_connection_test.cc
+++ b/quic/core/quic_connection_test.cc
@@ -806,8 +806,7 @@
   }
 
   QuicByteCount GetBytesInFlight() {
-    return QuicSentPacketManagerPeer::GetBytesInFlight(
-        QuicConnectionPeer::GetSentPacketManager(this));
+    return QuicConnectionPeer::GetSentPacketManager(this)->GetBytesInFlight();
   }
 
   void set_notifier(SimpleSessionNotifier* notifier) { notifier_ = notifier; }
@@ -3375,12 +3374,12 @@
 
   // Ensure that the data is still in flight, but the retransmission alarm is no
   // longer set.
-  EXPECT_GT(QuicSentPacketManagerPeer::GetBytesInFlight(manager_), 0u);
+  EXPECT_GT(manager_->GetBytesInFlight(), 0u);
   if (GetQuicReloadableFlag(quic_optimize_inflight_check)) {
     EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
     // Firing the alarm should remove all bytes_in_flight.
     connection_.GetRetransmissionAlarm()->Fire();
-    EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager_));
+    EXPECT_EQ(0u, manager_->GetBytesInFlight());
   }
   EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
 }
@@ -3654,7 +3653,7 @@
     EXPECT_TRUE(connection_.GetRetransmissionAlarm()->IsSet());
     // Firing the alarm should remove all bytes_in_flight.
     connection_.GetRetransmissionAlarm()->Fire();
-    EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(manager_));
+    EXPECT_EQ(0u, manager_->GetBytesInFlight());
   }
   EXPECT_FALSE(connection_.GetRetransmissionAlarm()->IsSet());
   EXPECT_FALSE(QuicConnectionPeer::HasRetransmittableFrames(&connection_, 2));
diff --git a/quic/core/quic_sent_packet_manager_test.cc b/quic/core/quic_sent_packet_manager_test.cc
index c750551..6448419 100644
--- a/quic/core/quic_sent_packet_manager_test.cc
+++ b/quic/core/quic_sent_packet_manager_test.cc
@@ -115,9 +115,7 @@
 
   ~QuicSentPacketManagerTest() override {}
 
-  QuicByteCount BytesInFlight() {
-    return QuicSentPacketManagerPeer::GetBytesInFlight(&manager_);
-  }
+  QuicByteCount BytesInFlight() { return manager_.GetBytesInFlight(); }
   void VerifyUnackedPackets(uint64_t* packets, size_t num_packets) {
     if (num_packets == 0) {
       EXPECT_TRUE(manager_.unacked_packets().empty());
@@ -991,13 +989,11 @@
   EXPECT_EQ(1u, stats_.rto_count);
   if (manager_.session_decides_what_to_write()) {
     // There are 2 RTO retransmissions.
-    EXPECT_EQ(104 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(104 * kDefaultLength, manager_.GetBytesInFlight());
   }
   if (!manager_.session_decides_what_to_write()) {
     // Send and Ack the RTO and ensure OnRetransmissionTimeout is called.
-    EXPECT_EQ(102 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(102 * kDefaultLength, manager_.GetBytesInFlight());
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
     RetransmitNextPacket(103);
   }
@@ -1023,9 +1019,9 @@
   // All packets before 103 should be lost.
   if (manager_.session_decides_what_to_write()) {
     // Packet 104 is still in flight.
-    EXPECT_EQ(1000u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(1000u, manager_.GetBytesInFlight());
   } else {
-    EXPECT_EQ(0u, QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(0u, manager_.GetBytesInFlight());
   }
 }
 
@@ -1353,12 +1349,10 @@
   }
   manager_.OnRetransmissionTimeout();
   if (manager_.session_decides_what_to_write()) {
-    EXPECT_EQ(102 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(102 * kDefaultLength, manager_.GetBytesInFlight());
   } else {
     ASSERT_TRUE(manager_.HasPendingRetransmissions());
-    EXPECT_EQ(100 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(100 * kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(101);
     ASSERT_TRUE(manager_.HasPendingRetransmissions());
     RetransmitNextPacket(102);
@@ -1428,12 +1422,10 @@
   }
   manager_.OnRetransmissionTimeout();
   if (manager_.session_decides_what_to_write()) {
-    EXPECT_EQ(101 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(101 * kDefaultLength, manager_.GetBytesInFlight());
   } else {
     ASSERT_TRUE(manager_.HasPendingRetransmissions());
-    EXPECT_EQ(100 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(100 * kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(101);
     EXPECT_FALSE(manager_.HasPendingRetransmissions());
   }
@@ -1474,12 +1466,10 @@
   }
   manager_.OnRetransmissionTimeout();
   if (manager_.session_decides_what_to_write()) {
-    EXPECT_EQ(102 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(102 * kDefaultLength, manager_.GetBytesInFlight());
   } else {
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
-    EXPECT_EQ(100 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(100 * kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(101);
     RetransmitNextPacket(102);
     EXPECT_FALSE(manager_.HasPendingRetransmissions());
@@ -1517,12 +1507,10 @@
   }
   manager_.OnRetransmissionTimeout();
   if (manager_.session_decides_what_to_write()) {
-    EXPECT_EQ(2 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(2 * kDefaultLength, manager_.GetBytesInFlight());
   } else {
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
-    EXPECT_EQ(kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(2);
     EXPECT_FALSE(manager_.HasPendingRetransmissions());
   }
@@ -1535,12 +1523,10 @@
   }
   manager_.OnRetransmissionTimeout();
   if (manager_.session_decides_what_to_write()) {
-    EXPECT_EQ(3 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(3 * kDefaultLength, manager_.GetBytesInFlight());
   } else {
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
-    EXPECT_EQ(2 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(2 * kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(3);
     EXPECT_FALSE(manager_.HasPendingRetransmissions());
   }
@@ -1555,8 +1541,7 @@
             manager_.OnAckFrameEnd(clock_.Now(), ENCRYPTION_INITIAL));
 
   // The original packet and newest should be outstanding.
-  EXPECT_EQ(2 * kDefaultLength,
-            QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+  EXPECT_EQ(2 * kDefaultLength, manager_.GetBytesInFlight());
 }
 
 TEST_P(QuicSentPacketManagerTest, TwoRetransmissionTimeoutsAckFirst) {
@@ -1570,12 +1555,10 @@
   }
   manager_.OnRetransmissionTimeout();
   if (manager_.session_decides_what_to_write()) {
-    EXPECT_EQ(2 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(2 * kDefaultLength, manager_.GetBytesInFlight());
   } else {
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
-    EXPECT_EQ(kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(2);
     EXPECT_FALSE(manager_.HasPendingRetransmissions());
   }
@@ -1588,12 +1571,10 @@
   }
   manager_.OnRetransmissionTimeout();
   if (manager_.session_decides_what_to_write()) {
-    EXPECT_EQ(3 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(3 * kDefaultLength, manager_.GetBytesInFlight());
   } else {
     EXPECT_TRUE(manager_.HasPendingRetransmissions());
-    EXPECT_EQ(2 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(2 * kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(3);
     EXPECT_FALSE(manager_.HasPendingRetransmissions());
   }
@@ -1608,8 +1589,7 @@
             manager_.OnAckFrameEnd(clock_.Now(), ENCRYPTION_INITIAL));
 
   // The first two packets should still be outstanding.
-  EXPECT_EQ(2 * kDefaultLength,
-            QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+  EXPECT_EQ(2 * kDefaultLength, manager_.GetBytesInFlight());
 }
 
 TEST_P(QuicSentPacketManagerTest, GetTransmissionTime) {
@@ -1785,14 +1765,12 @@
   manager_.OnRetransmissionTimeout();
   if (!manager_.session_decides_what_to_write()) {
     // All packets are still considered inflight.
-    EXPECT_EQ(4 * kDefaultLength,
-              QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+    EXPECT_EQ(4 * kDefaultLength, manager_.GetBytesInFlight());
     RetransmitNextPacket(5);
     RetransmitNextPacket(6);
   }
   // All previous packets are inflight, plus two rto retransmissions.
-  EXPECT_EQ(6 * kDefaultLength,
-            QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+  EXPECT_EQ(6 * kDefaultLength, manager_.GetBytesInFlight());
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
 
   // The delay should double the second time.
@@ -1810,8 +1788,7 @@
   EXPECT_EQ(PACKETS_NEWLY_ACKED,
             manager_.OnAckFrameEnd(clock_.Now(), ENCRYPTION_INITIAL));
   EXPECT_FALSE(manager_.HasPendingRetransmissions());
-  EXPECT_EQ(5 * kDefaultLength,
-            QuicSentPacketManagerPeer::GetBytesInFlight(&manager_));
+  EXPECT_EQ(5 * kDefaultLength, manager_.GetBytesInFlight());
 
   // Wait 2RTTs from now for the RTO, since it's the max of the RTO time
   // and the TLP time.  In production, there would always be two TLP's first.
diff --git a/quic/test_tools/quic_sent_packet_manager_peer.cc b/quic/test_tools/quic_sent_packet_manager_peer.cc
index 71c0459..c48c090 100644
--- a/quic/test_tools/quic_sent_packet_manager_peer.cc
+++ b/quic/test_tools/quic_sent_packet_manager_peer.cc
@@ -149,12 +149,6 @@
 }
 
 // static
-QuicByteCount QuicSentPacketManagerPeer::GetBytesInFlight(
-    const QuicSentPacketManager* sent_packet_manager) {
-  return sent_packet_manager->unacked_packets_.bytes_in_flight();
-}
-
-// static
 void QuicSentPacketManagerPeer::SetConsecutiveRtoCount(
     QuicSentPacketManager* sent_packet_manager,
     size_t count) {
diff --git a/quic/test_tools/quic_sent_packet_manager_peer.h b/quic/test_tools/quic_sent_packet_manager_peer.h
index ddba422..6dcce0c 100644
--- a/quic/test_tools/quic_sent_packet_manager_peer.h
+++ b/quic/test_tools/quic_sent_packet_manager_peer.h
@@ -68,9 +68,6 @@
   static size_t GetNumRetransmittablePackets(
       const QuicSentPacketManager* sent_packet_manager);
 
-  static QuicByteCount GetBytesInFlight(
-      const QuicSentPacketManager* sent_packet_manager);
-
   static void SetConsecutiveRtoCount(QuicSentPacketManager* sent_packet_manager,
                                      size_t count);