Minor cleanup of QuicSpdyServerStream and QuicSpdyClientStream.

net/tools/quic/quic_spdy_server_stream_test.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // 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 "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_protocol.h"
@@ skipping 19 matching lines @@
 using testing::InSequence;
 using testing::Return;
 using testing::StrEq;
 using testing::StrictMock;
 using testing::WithArgs;
 
 namespace net {
 namespace tools {
 namespace test {
 
-class QuicSpdyServerStreamPeer {
+class QuicSpdyServerStreamPeer : public QuicSpdyServerStream {
  public:
-  static BalsaHeaders* GetMutableHeaders(
-      QuicSpdyServerStream* stream) {
-    return &(stream->headers_);
+  QuicSpdyServerStreamPeer(QuicStreamId stream_id, QuicSession* session)
+      : QuicSpdyServerStream(stream_id, session) {
+  }
+
+  using QuicSpdyServerStream::SendResponse;
+  using QuicSpdyServerStream::SendErrorResponse;
+
+  const string& body() {
+    return body_;
+  }
+
+  const BalsaHeaders& headers() {
+    return headers_;
+  }
+
+  BalsaHeaders* mutable_headers() {
+    return &headers_;
   }
 };
 
 namespace {
 
 class QuicSpdyServerStreamTest : public ::testing::Test {
  public:
   QuicSpdyServerStreamTest()
       : session_(new MockConnection(1, IPEndPoint(), true), true),
         body_("hello world") {
     BalsaHeaders request_headers;
     request_headers.SetRequestFirstlineFromStringPieces(
         "POST", "https://www.google.com/", "HTTP/1.1");
     request_headers.ReplaceOrAppendHeader("content-length", "11");
 
     headers_string_ = SpdyUtils::SerializeRequestHeaders(request_headers);
-    stream_.reset(new QuicSpdyServerStream(3, &session_));
+    stream_.reset(new QuicSpdyServerStreamPeer(3, &session_));
   }
 
   QuicConsumedData ValidateHeaders(const struct iovec* iov) {
     StringPiece headers =
         StringPiece(static_cast<const char*>(iov[0].iov_base), iov[0].iov_len);
     headers_string_ = SpdyUtils::SerializeResponseHeaders(
         response_headers_);
     QuicSpdyDecompressor decompressor;
     TestDecompressorVisitor visitor;
 
@@ skipping 40 matching lines @@
       CHECK_EQ(cached_response->body(), body);
       return;
     }
 
     cache->AddResponse(request_headers, response_headers, body);
   }
 
   BalsaHeaders response_headers_;
   EpollServer eps_;
   StrictMock<MockSession> session_;
-  scoped_ptr<QuicSpdyServerStream> stream_;
+  scoped_ptr<QuicSpdyServerStreamPeer> stream_;
   string headers_string_;
   string body_;
 };
 
 QuicConsumedData ConsumeAllData(
     QuicStreamId id,
     const struct iovec* iov,
     int iov_count,
     QuicStreamOffset offset,
     bool fin,
@@ skipping 44 matching lines @@
       headers_string_.c_str(), headers_string_.size()));
   // Content length is still 11.  This will register as an error and we won't
   // accept the bytes.
   stream_->ProcessData(large_body.c_str(), large_body.size());
   EXPECT_EQ(11u, stream_->headers().content_length());
   EXPECT_EQ("https://www.google.com/", stream_->headers().request_uri());
   EXPECT_EQ("POST", stream_->headers().request_method());
 }
 
 TEST_F(QuicSpdyServerStreamTest, TestSendResponse) {
-  BalsaHeaders* request_headers =
-      QuicSpdyServerStreamPeer::GetMutableHeaders(stream_.get());
+  BalsaHeaders* request_headers = stream_->mutable_headers();
   request_headers->SetRequestFirstlineFromStringPieces(
       "GET",
       "https://www.google.com/foo",
       "HTTP/1.1");
 
   response_headers_.SetResponseFirstlineFromStringPieces(
       "HTTP/1.1", "200", "OK");
   response_headers_.ReplaceOrAppendHeader("content-length", "3");
 
   InSequence s;
@@ skipping 56 matching lines @@
   QuicStreamFrame frame(
       stream_->id(), true, 0, MakeIOVector(StringPiece(arr, arraysize(arr))));
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net