Rename ReliableQuicStream to QuicStream. No behavior change, not protected.

net/tools/quic/end_to_end_test.cc

Index: net/tools/quic/end_to_end_test.cc
diff --git a/net/tools/quic/end_to_end_test.cc b/net/tools/quic/end_to_end_test.cc
index 5fa993152138e73dc3f4b5a67b34d5abd5a90de5..b9031a1d3bdb9a7f35cc9aa2a28c46c3ad97e7fd 100644
--- a/net/tools/quic/end_to_end_test.cc
+++ b/net/tools/quic/end_to_end_test.cc
@@ -37,9 +37,9 @@
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/quic_spdy_session_peer.h"
+#include "net/quic/test_tools/quic_stream_peer.h"
 #include "net/quic/test_tools/quic_stream_sequencer_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
-#include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/test/gtest_util.h"
 #include "net/tools/epoll_server/epoll_server.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
@@ -596,8 +596,7 @@ TEST_P(EndToEndTest, HandshakeSuccessful) {
   client_->client()->WaitForCryptoHandshakeConfirmed();
   QuicCryptoStream* crypto_stream =
       QuicSessionPeer::GetCryptoStream(client_->client()->session());
-  QuicStreamSequencer* sequencer =
-      ReliableQuicStreamPeer::sequencer(crypto_stream);
+  QuicStreamSequencer* sequencer = QuicStreamPeer::sequencer(crypto_stream);
   EXPECT_NE(FLAGS_quic_release_crypto_stream_buffer,
             QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
   server_thread_->Pause();
@@ -605,7 +604,7 @@ TEST_P(EndToEndTest, HandshakeSuccessful) {
       QuicServerPeer::GetDispatcher(server_thread_->server());
   QuicSession* server_session = dispatcher->session_map().begin()->second.get();
   crypto_stream = QuicSessionPeer::GetCryptoStream(server_session);
-  sequencer = ReliableQuicStreamPeer::sequencer(crypto_stream);
+  sequencer = QuicStreamPeer::sequencer(crypto_stream);
   EXPECT_NE(FLAGS_quic_release_crypto_stream_buffer,
             QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
 }
@@ -1237,15 +1236,14 @@ TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
   // and the second write is picked up as writing on a closed stream.
   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
   ASSERT_TRUE(stream != nullptr);
-  ReliableQuicStreamPeer::SetStreamBytesWritten(3, stream);
+  QuicStreamPeer::SetStreamBytesWritten(3, stream);
 
   client_->SendData("bar", true);
   client_->WaitForWriteToFlush();
 
   // By default the stream protects itself from writes after terminte is set.
   // Override this to test the server handling buggy clients.
-  ReliableQuicStreamPeer::SetWriteSideClosed(false,
-                                             client_->GetOrCreateStream());
+  QuicStreamPeer::SetWriteSideClosed(false, client_->GetOrCreateStream());
 
   EXPECT_QUIC_BUG(client_->SendData("eep", true), "Fin already buffered");
 }
@@ -2203,7 +2201,7 @@ class ServerStreamWithErrorResponseBody : public QuicSimpleServerStream {
     headers["content-length"] = base::UintToString(response_body_.size());
     // This method must call CloseReadSide to cause the test case, StopReading
     // is not sufficient.
-    ReliableQuicStreamPeer::CloseReadSide(this);
+    QuicStreamPeer::CloseReadSide(this);
     SendHeadersAndBody(std::move(headers), response_body_);
   }
 
@@ -2503,7 +2501,7 @@ TEST_P(EndToEndTest, LargePostEarlyResponse) {
   EXPECT_EQ("500", client_->response_headers()->find(":status")->second);
 
   // Receive the reset stream from server on early response.
-  ReliableQuicStream* stream =
+  QuicStream* stream =
       client_->client()->session()->GetOrCreateStream(kClientDataStreamId1);
   // The stream is reset by server's reset stream.
   EXPECT_EQ(stream, nullptr);
@@ -2620,8 +2618,7 @@ TEST_P(EndToEndTestServerPush, ServerPush) {
                        "https://example.com/push_example"));
   QuicHeadersStream* headers_stream =
       QuicSpdySessionPeer::GetHeadersStream(client_->client()->session());
-  QuicStreamSequencer* sequencer =
-      ReliableQuicStreamPeer::sequencer(headers_stream);
+  QuicStreamSequencer* sequencer = QuicStreamPeer::sequencer(headers_stream);
   // Headers stream's sequencer buffer shouldn't be released because server push
   // hasn't finished yet.
   EXPECT_TRUE(QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
@@ -2936,8 +2933,7 @@ TEST_P(EndToEndTest, ReleaseHeadersStreamBufferWhenIdle) {
   client_->SendSynchronousRequest("/foo");
   QuicHeadersStream* headers_stream =
       QuicSpdySessionPeer::GetHeadersStream(client_->client()->session());
-  QuicStreamSequencer* sequencer =
-      ReliableQuicStreamPeer::sequencer(headers_stream);
+  QuicStreamSequencer* sequencer = QuicStreamPeer::sequencer(headers_stream);
   EXPECT_NE(FLAGS_quic_headers_stream_release_sequencer_buffer,
             QuicStreamSequencerPeer::IsUnderlyingBufferAllocated(sequencer));
 }