diff --git a/quic/core/http/end_to_end_test.cc b/quic/core/http/end_to_end_test.cc
index 753b951..e537c73 100644
--- a/quic/core/http/end_to_end_test.cc
+++ b/quic/core/http/end_to_end_test.cc
@@ -3780,8 +3780,7 @@
   client_->SendMessage(headers, "", /*fin=*/false);
   // Stream should be open
   ASSERT_NE(nullptr, client_->latest_created_stream());
-  EXPECT_FALSE(
-      QuicStreamPeer::write_side_closed(client_->latest_created_stream()));
+  EXPECT_FALSE(client_->latest_created_stream()->write_side_closed());
   EXPECT_FALSE(
       QuicStreamPeer::read_side_closed(client_->latest_created_stream()));
 
diff --git a/quic/core/http/quic_spdy_stream_test.cc b/quic/core/http/quic_spdy_stream_test.cc
index 7cff575..1451533 100644
--- a/quic/core/http/quic_spdy_stream_test.cc
+++ b/quic/core/http/quic_spdy_stream_test.cc
@@ -618,8 +618,7 @@
             QuicFlowControllerPeer::SendWindowSize(stream_->flow_controller()));
 
   // And we should have queued the overflowed data.
-  EXPECT_EQ(kOverflow + kHeaderLength,
-            QuicStreamPeer::SizeOfQueuedData(stream_));
+  EXPECT_EQ(kOverflow + kHeaderLength, stream_->BufferedDataBytes());
 }
 
 TEST_P(QuicSpdyStreamTest, StreamFlowControlNoWindowUpdateIfNotConsumed) {
diff --git a/quic/core/quic_session_test.cc b/quic/core/quic_session_test.cc
index eb76c95..8020de5 100644
--- a/quic/core/quic_session_test.cc
+++ b/quic/core/quic_session_test.cc
@@ -2329,7 +2329,7 @@
   TestStream* stream = session_.CreateOutgoingBidirectionalStream();
 
   // Ensure that the stream starts out open in both directions.
-  EXPECT_FALSE(QuicStreamPeer::write_side_closed(stream));
+  EXPECT_FALSE(stream->write_side_closed());
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream));
 
   QuicStreamId stream_id = stream->id();
@@ -2344,7 +2344,7 @@
   // When the STOP_SENDING is received, the node generates a RST_STREAM,
   // which closes the stream in the write direction. Ensure this.
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream));
-  EXPECT_TRUE(QuicStreamPeer::write_side_closed(stream));
+  EXPECT_TRUE(stream->write_side_closed());
 }
 
 }  // namespace
diff --git a/quic/core/quic_stream_test.cc b/quic/core/quic_stream_test.cc
index e154482..d1b442e 100644
--- a/quic/core/quic_stream_test.cc
+++ b/quic/core/quic_stream_test.cc
@@ -100,8 +100,8 @@
         QuicSessionPeer::GetWriteBlockedStreams(session_.get());
   }
 
-  bool fin_sent() { return QuicStreamPeer::FinSent(stream_); }
-  bool rst_sent() { return QuicStreamPeer::RstSent(stream_); }
+  bool fin_sent() { return stream_->fin_sent(); }
+  bool rst_sent() { return stream_->rst_sent(); }
 
   void set_initial_flow_control_window_bytes(uint32_t val) {
     initial_flow_control_window_bytes_ = val;
@@ -1464,7 +1464,7 @@
   Initialize();
   const int kStopSendingCode = 123;
   // These must start as false.
-  EXPECT_FALSE(QuicStreamPeer::write_side_closed(stream_));
+  EXPECT_FALSE(stream_->write_side_closed());
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
   // Expect to actually see a stop sending if and only if we are in version 99.
   if (connection_->transport_version() == QUIC_VERSION_99) {
@@ -1477,7 +1477,7 @@
   // Sending a STOP_SENDING does not actually close the local stream.
   // Our implementation waits for the responding RESET_STREAM to effect the
   // closes. Therefore, read- and write-side closes should both be false.
-  EXPECT_FALSE(QuicStreamPeer::write_side_closed(stream_));
+  EXPECT_FALSE(stream_->write_side_closed());
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
 }
 
@@ -1485,7 +1485,7 @@
 // (read and write) if not version 99.
 TEST_P(QuicStreamTest, OnStreamResetReadOrReadWrite) {
   Initialize();
-  EXPECT_FALSE(QuicStreamPeer::write_side_closed(stream_));
+  EXPECT_FALSE(stream_->write_side_closed());
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
 
   QuicRstStreamFrame rst_frame(kInvalidControlFrameId, stream_->id(),
@@ -1494,10 +1494,10 @@
   if (connection_->transport_version() == QUIC_VERSION_99) {
     // Version 99/IETF QUIC should close just the read side.
     EXPECT_TRUE(QuicStreamPeer::read_side_closed(stream_));
-    EXPECT_FALSE(QuicStreamPeer::write_side_closed(stream_));
+    EXPECT_FALSE(stream_->write_side_closed());
   } else {
     // Google QUIC should close both sides of the stream.
-    EXPECT_TRUE(QuicStreamPeer::write_side_closed(stream_));
+    EXPECT_TRUE(stream_->write_side_closed());
     EXPECT_TRUE(QuicStreamPeer::read_side_closed(stream_));
   }
 }
@@ -1510,7 +1510,7 @@
     return;
   }
 
-  EXPECT_FALSE(QuicStreamPeer::write_side_closed(stream_));
+  EXPECT_FALSE(stream_->write_side_closed());
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
 
   // Simulate receipt of a STOP_SENDING.
@@ -1518,7 +1518,7 @@
 
   // Should close just the read side.
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
-  EXPECT_TRUE(QuicStreamPeer::write_side_closed(stream_));
+  EXPECT_TRUE(stream_->write_side_closed());
 }
 
 // SendOnlyRstStream must only send a RESET_STREAM (no bundled STOP_SENDING).
@@ -1541,7 +1541,7 @@
 
   // ResetStreamOnly should just close the write side.
   EXPECT_FALSE(QuicStreamPeer::read_side_closed(stream_));
-  EXPECT_TRUE(QuicStreamPeer::write_side_closed(stream_));
+  EXPECT_TRUE(stream_->write_side_closed());
 }
 
 }  // namespace
diff --git a/quic/test_tools/quic_stream_peer.cc b/quic/test_tools/quic_stream_peer.cc
index 7607523..d501deb 100644
--- a/quic/test_tools/quic_stream_peer.cc
+++ b/quic/test_tools/quic_stream_peer.cc
@@ -33,46 +33,17 @@
 }
 
 // static
-bool QuicStreamPeer::write_side_closed(QuicStream* stream) {
-  return stream->write_side_closed();
-}
-
-// static
 void QuicStreamPeer::CloseReadSide(QuicStream* stream) {
   stream->CloseReadSide();
 }
 
 // static
-bool QuicStreamPeer::FinSent(QuicStream* stream) {
-  return stream->fin_sent_;
-}
-
-// static
-bool QuicStreamPeer::RstSent(QuicStream* stream) {
-  return stream->rst_sent_;
-}
-
-// static
-uint32_t QuicStreamPeer::SizeOfQueuedData(QuicStream* stream) {
-  return stream->BufferedDataBytes();
-}
-
-// static
 bool QuicStreamPeer::StreamContributesToConnectionFlowControl(
     QuicStream* stream) {
   return stream->stream_contributes_to_connection_flow_control_;
 }
 
 // static
-void QuicStreamPeer::WriteOrBufferData(
-    QuicStream* stream,
-    QuicStringPiece data,
-    bool fin,
-    QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener) {
-  stream->WriteOrBufferData(data, fin, std::move(ack_listener));
-}
-
-// static
 QuicStreamSequencer* QuicStreamPeer::sequencer(QuicStream* stream) {
   return &(stream->sequencer_);
 }
diff --git a/quic/test_tools/quic_stream_peer.h b/quic/test_tools/quic_stream_peer.h
index e545f5d..9142348 100644
--- a/quic/test_tools/quic_stream_peer.h
+++ b/quic/test_tools/quic_stream_peer.h
@@ -26,23 +26,11 @@
   static void SetWriteSideClosed(bool value, QuicStream* stream);
   static void SetStreamBytesWritten(QuicStreamOffset stream_bytes_written,
                                     QuicStream* stream);
-  static bool write_side_closed(QuicStream* stream);
   static bool read_side_closed(QuicStream* stream);
   static void CloseReadSide(QuicStream* stream);
 
-  static bool FinSent(QuicStream* stream);
-  static bool RstSent(QuicStream* stream);
-
-  static uint32_t SizeOfQueuedData(QuicStream* stream);
-
   static bool StreamContributesToConnectionFlowControl(QuicStream* stream);
 
-  static void WriteOrBufferData(
-      QuicStream* stream,
-      QuicStringPiece data,
-      bool fin,
-      QuicReferenceCountedPointer<QuicAckListenerInterface> ack_listener);
-
   static QuicStreamSequencer* sequencer(QuicStream* stream);
   static QuicSession* session(QuicStream* stream);