Rename QuicSpdyServerStream to QuicSimpleServerStream. No behavior change.

net/tools/quic/quic_simple_server_stream_test.cc

Index: net/tools/quic/quic_simple_server_stream_test.cc
diff --git a/net/tools/quic/quic_spdy_server_stream_test.cc b/net/tools/quic/quic_simple_server_stream_test.cc
similarity index 78%
rename from net/tools/quic/quic_spdy_server_stream_test.cc
rename to net/tools/quic/quic_simple_server_stream_test.cc
index 98c31ab9a5a2a11e59cfb40784df5e222c2a4102..fce9ec135d7dc3445364a0c7c342f1625de56ad4 100644
--- a/net/tools/quic/quic_spdy_server_stream_test.cc
+++ b/net/tools/quic/quic_simple_server_stream_test.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "net/tools/quic/quic_spdy_server_stream.h"
+#include "net/tools/quic/quic_simple_server_stream.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
@@ -42,44 +42,43 @@ namespace net {
 namespace tools {
 namespace test {
 
-class QuicSpdyServerStreamPeer : public QuicSpdyServerStream {
+class QuicSimpleServerStreamPeer : public QuicSimpleServerStream {
  public:
-  QuicSpdyServerStreamPeer(QuicStreamId stream_id, QuicSpdySession* session)
-      : QuicSpdyServerStream(stream_id, session) {}
+  QuicSimpleServerStreamPeer(QuicStreamId stream_id, QuicSpdySession* session)
+      : QuicSimpleServerStream(stream_id, session) {}
 
-  using QuicSpdyServerStream::SendResponse;
-  using QuicSpdyServerStream::SendErrorResponse;
+  using QuicSimpleServerStream::SendResponse;
+  using QuicSimpleServerStream::SendErrorResponse;
 
-  SpdyHeaderBlock* mutable_headers() {
-    return &request_headers_;
-  }
+  SpdyHeaderBlock* mutable_headers() { return &request_headers_; }
 
-  static void SendResponse(QuicSpdyServerStream* stream) {
+  static void SendResponse(QuicSimpleServerStream* stream) {
     stream->SendResponse();
   }
 
-  static void SendErrorResponse(QuicSpdyServerStream* stream) {
+  static void SendErrorResponse(QuicSimpleServerStream* stream) {
     stream->SendErrorResponse();
   }
 
-  static const string& body(QuicSpdyServerStream* stream) {
+  static const string& body(QuicSimpleServerStream* stream) {
     return stream->body_;
   }
 
-  static const int content_length(QuicSpdyServerStream* stream) {
+  static const int content_length(QuicSimpleServerStream* stream) {
     return stream->content_length_;
   }
 
-  static const SpdyHeaderBlock& headers(QuicSpdyServerStream* stream) {
+  static const SpdyHeaderBlock& headers(QuicSimpleServerStream* stream) {
     return stream->request_headers_;
   }
 };
 
 namespace {
 
-class QuicSpdyServerStreamTest : public ::testing::TestWithParam<QuicVersion> {
+class QuicSimpleServerStreamTest
+    : public ::testing::TestWithParam<QuicVersion> {
  public:
-  QuicSpdyServerStreamTest()
+  QuicSimpleServerStreamTest()
       : connection_(
             new StrictMock<MockConnection>(&helper_,
                                            Perspective::IS_SERVER,
@@ -103,19 +102,21 @@ class QuicSpdyServerStreamTest : public ::testing::TestWithParam<QuicVersion> {
         kInitialStreamFlowControlWindowForTest);
     session_.config()->SetInitialSessionFlowControlWindowToSend(
         kInitialSessionFlowControlWindowForTest);
-    stream_ = new QuicSpdyServerStreamPeer(::net::test::kClientDataStreamId1,
-                                           &session_);
+    stream_ = new QuicSimpleServerStreamPeer(::net::test::kClientDataStreamId1,
+                                             &session_);
     // Register stream_ in dynamic_stream_map_ and pass ownership to session_.
     session_.ActivateStream(stream_);
 
     QuicInMemoryCachePeer::ResetForTests();
   }
 
-  ~QuicSpdyServerStreamTest() override {
+  ~QuicSimpleServerStreamTest() override {
     QuicInMemoryCachePeer::ResetForTests();
   }
 
-  const string& StreamBody() { return QuicSpdyServerStreamPeer::body(stream_); }
+  const string& StreamBody() {
+    return QuicSimpleServerStreamPeer::body(stream_);
+  }
 
   StringPiece StreamHeadersValue(const string& key) {
     return (*stream_->mutable_headers())[key];
@@ -125,16 +126,16 @@ class QuicSpdyServerStreamTest : public ::testing::TestWithParam<QuicVersion> {
   MockConnectionHelper helper_;
   StrictMock<MockConnection>* connection_;
   StrictMock<MockQuicSpdySession> session_;
-  QuicSpdyServerStreamPeer* stream_;  // Owned by session_.
+  QuicSimpleServerStreamPeer* stream_;  // Owned by session_.
   string headers_string_;
   string body_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests,
-                        QuicSpdyServerStreamTest,
+                        QuicSimpleServerStreamTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
-TEST_P(QuicSpdyServerStreamTest, TestFraming) {
+TEST_P(QuicSimpleServerStreamTest, TestFraming) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
@@ -148,7 +149,7 @@ TEST_P(QuicSpdyServerStreamTest, TestFraming) {
   EXPECT_EQ(body_, StreamBody());
 }
 
-TEST_P(QuicSpdyServerStreamTest, TestFramingOnePacket) {
+TEST_P(QuicSimpleServerStreamTest, TestFramingOnePacket) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
@@ -163,7 +164,7 @@ TEST_P(QuicSpdyServerStreamTest, TestFramingOnePacket) {
   EXPECT_EQ(body_, StreamBody());
 }
 
-TEST_P(QuicSpdyServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
+TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(AnyNumber())
       .WillRepeatedly(Invoke(MockQuicSpdySession::ConsumeAllData));
@@ -182,7 +183,7 @@ TEST_P(QuicSpdyServerStreamTest, SendQuicRstStreamNoErrorInStopReading) {
   stream_->StopReading();
 }
 
-TEST_P(QuicSpdyServerStreamTest, TestFramingExtraData) {
+TEST_P(QuicSimpleServerStreamTest, TestFramingExtraData) {
   string large_body = "hello world!!!!!!";
 
   // We'll automatically write out an error (headers + body)
@@ -204,7 +205,7 @@ TEST_P(QuicSpdyServerStreamTest, TestFramingExtraData) {
   EXPECT_EQ("POST", StreamHeadersValue(":method"));
 }
 
-TEST_P(QuicSpdyServerStreamTest, SendResponseWithIllegalResponseStatus) {
+TEST_P(QuicSimpleServerStreamTest, SendResponseWithIllegalResponseStatus) {
   // Send a illegal response with response status not supported by HTTP/2.
   SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
@@ -227,18 +228,18 @@ TEST_P(QuicSpdyServerStreamTest, SendResponseWithIllegalResponseStatus) {
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(
-          strlen(QuicSpdyServerStream::kErrorResponseBody), true)));
+          strlen(QuicSimpleServerStream::kErrorResponseBody), true)));
 
-  QuicSpdyServerStreamPeer::SendResponse(stream_);
+  QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, SendPushResponseWith404Response) {
+TEST_P(QuicSimpleServerStreamTest, SendPushResponseWith404Response) {
   // Create a new promised stream with even id().
-  QuicSpdyServerStreamPeer* promised_stream =
-      new QuicSpdyServerStreamPeer(2, &session_);
+  QuicSimpleServerStreamPeer* promised_stream =
+      new QuicSimpleServerStreamPeer(2, &session_);
   session_.ActivateStream(promised_stream);
 
   // Send a push response with response status 404, which will be regarded as
@@ -260,10 +261,10 @@ TEST_P(QuicSpdyServerStreamTest, SendPushResponseWith404Response) {
   EXPECT_CALL(session_,
               SendRstStream(promised_stream->id(), QUIC_STREAM_CANCELLED, 0));
 
-  QuicSpdyServerStreamPeer::SendResponse(promised_stream);
+  QuicSimpleServerStreamPeer::SendResponse(promised_stream);
 }
 
-TEST_P(QuicSpdyServerStreamTest, SendResponseWithValidHeaders) {
+TEST_P(QuicSimpleServerStreamTest, SendResponseWithValidHeaders) {
   // Add a request and response with valid headers.
   SpdyHeaderBlock* request_headers = stream_->mutable_headers();
   (*request_headers)[":path"] = "/bar";
@@ -285,13 +286,13 @@ TEST_P(QuicSpdyServerStreamTest, SendResponseWithValidHeaders) {
       .Times(1)
       .WillOnce(Return(QuicConsumedData(body.length(), true)));
 
-  QuicSpdyServerStreamPeer::SendResponse(stream_);
+  QuicSimpleServerStreamPeer::SendResponse(stream_);
   EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, TestSendErrorResponse) {
+TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   response_headers_[":version"] = "HTTP/1.1";
@@ -301,16 +302,17 @@ TEST_P(QuicSpdyServerStreamTest, TestSendErrorResponse) {
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeaders(_, _, _, _, _));
-  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _)).Times(1).
-      WillOnce(Return(QuicConsumedData(3, true)));
+  EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
+      .Times(1)
+      .WillOnce(Return(QuicConsumedData(3, true)));
 
-  QuicSpdyServerStreamPeer::SendErrorResponse(stream_);
+  QuicSimpleServerStreamPeer::SendErrorResponse(stream_);
   EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, InvalidMultipleContentLength) {
+TEST_P(QuicSimpleServerStreamTest, InvalidMultipleContentLength) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   SpdyHeaderBlock request_headers;
@@ -331,7 +333,7 @@ TEST_P(QuicSpdyServerStreamTest, InvalidMultipleContentLength) {
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, InvalidLeadingNullContentLength) {
+TEST_P(QuicSimpleServerStreamTest, InvalidLeadingNullContentLength) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   SpdyHeaderBlock request_headers;
@@ -352,7 +354,7 @@ TEST_P(QuicSpdyServerStreamTest, InvalidLeadingNullContentLength) {
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, ValidMultipleContentLength) {
+TEST_P(QuicSimpleServerStreamTest, ValidMultipleContentLength) {
   SpdyHeaderBlock request_headers;
   // \000 is a way to write the null byte when followed by a literal digit.
   request_headers["content-length"] = StringPiece("11\00011", 5);
@@ -362,13 +364,13 @@ TEST_P(QuicSpdyServerStreamTest, ValidMultipleContentLength) {
   stream_->OnStreamHeaders(headers_string_);
   stream_->OnStreamHeadersComplete(false, headers_string_.size());
 
-  EXPECT_EQ(11, QuicSpdyServerStreamPeer::content_length(stream_));
+  EXPECT_EQ(11, QuicSimpleServerStreamPeer::content_length(stream_));
   EXPECT_FALSE(ReliableQuicStreamPeer::read_side_closed(stream_));
   EXPECT_FALSE(stream_->reading_stopped());
   EXPECT_FALSE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) {
+TEST_P(QuicSimpleServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) {
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "500 Server Error";
   response_headers_["content-length"] = "3";
@@ -384,12 +386,13 @@ TEST_P(QuicSpdyServerStreamTest, SendQuicRstStreamNoErrorWithEarlyResponse) {
     EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
   }
   EXPECT_FALSE(stream_->fin_received());
-  QuicSpdyServerStreamPeer::SendErrorResponse(stream_);
+  QuicSimpleServerStreamPeer::SendErrorResponse(stream_);
   EXPECT_TRUE(stream_->reading_stopped());
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, DoNotSendQuicRstStreamNoErrorWithRstReceived) {
+TEST_P(QuicSimpleServerStreamTest,
+       DoNotSendQuicRstStreamNoErrorWithRstReceived) {
   response_headers_[":version"] = "HTTP/1.1";
   response_headers_[":status"] = "500 Server Error";
   response_headers_["content-length"] = "3";
@@ -406,29 +409,29 @@ TEST_P(QuicSpdyServerStreamTest, DoNotSendQuicRstStreamNoErrorWithRstReceived) {
   EXPECT_TRUE(stream_->write_side_closed());
 }
 
-TEST_P(QuicSpdyServerStreamTest, InvalidHeadersWithFin) {
+TEST_P(QuicSimpleServerStreamTest, InvalidHeadersWithFin) {
   char arr[] = {
-    0x3a, 0x68, 0x6f, 0x73,  // :hos
-    0x74, 0x00, 0x00, 0x00,  // t...
-    0x00, 0x00, 0x00, 0x00,  // ....
-    0x07, 0x3a, 0x6d, 0x65,  // .:me
-    0x74, 0x68, 0x6f, 0x64,  // thod
-    0x00, 0x00, 0x00, 0x03,  // ....
-    0x47, 0x45, 0x54, 0x00,  // GET.
-    0x00, 0x00, 0x05, 0x3a,  // ...:
-    0x70, 0x61, 0x74, 0x68,  // path
-    0x00, 0x00, 0x00, 0x04,  // ....
-    0x2f, 0x66, 0x6f, 0x6f,  // /foo
-    0x00, 0x00, 0x00, 0x07,  // ....
-    0x3a, 0x73, 0x63, 0x68,  // :sch
-    0x65, 0x6d, 0x65, 0x00,  // eme.
-    0x00, 0x00, 0x00, 0x00,  // ....
-    0x00, 0x00, 0x08, 0x3a,  // ...:
-    0x76, 0x65, 0x72, 0x73,  // vers
-    '\x96', 0x6f, 0x6e, 0x00,  // <i(69)>on.
-    0x00, 0x00, 0x08, 0x48,  // ...H
-    0x54, 0x54, 0x50, 0x2f,  // TTP/
-    0x31, 0x2e, 0x31,        // 1.1
+      0x3a,   0x68, 0x6f, 0x73,  // :hos
+      0x74,   0x00, 0x00, 0x00,  // t...
+      0x00,   0x00, 0x00, 0x00,  // ....
+      0x07,   0x3a, 0x6d, 0x65,  // .:me
+      0x74,   0x68, 0x6f, 0x64,  // thod
+      0x00,   0x00, 0x00, 0x03,  // ....
+      0x47,   0x45, 0x54, 0x00,  // GET.
+      0x00,   0x00, 0x05, 0x3a,  // ...:
+      0x70,   0x61, 0x74, 0x68,  // path
+      0x00,   0x00, 0x00, 0x04,  // ....
+      0x2f,   0x66, 0x6f, 0x6f,  // /foo
+      0x00,   0x00, 0x00, 0x07,  // ....
+      0x3a,   0x73, 0x63, 0x68,  // :sch
+      0x65,   0x6d, 0x65, 0x00,  // eme.
+      0x00,   0x00, 0x00, 0x00,  // ....
+      0x00,   0x00, 0x08, 0x3a,  // ...:
+      0x76,   0x65, 0x72, 0x73,  // vers
+      '\x96', 0x6f, 0x6e, 0x00,  // <i(69)>on.
+      0x00,   0x00, 0x08, 0x48,  // ...H
+      0x54,   0x54, 0x50, 0x2f,  // TTP/
+      0x31,   0x2e, 0x31,        // 1.1
   };
   StringPiece data(arr, arraysize(arr));
   QuicStreamFrame frame(stream_->id(), true, 0, data);