QUIC - refactor in preparation for two streams per HTTP transaction.

net/tools/quic/quic_simple_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_simple_server_stream.h"
 
 #include <list>
 #include <memory>
 #include <utility>
 
@@ skipping 61 matching lines @@
 
   static int content_length(QuicSimpleServerStream* stream) {
     return stream->content_length_;
   }
 
   static SpdyHeaderBlock& headers(QuicSimpleServerStream* stream) {
     return stream->request_headers_;
   }
 };
 
+namespace {
+
 class MockQuicSimpleServerSession : public QuicSimpleServerSession {
  public:
   const size_t kMaxStreamsForTest = 100;
 
   explicit MockQuicSimpleServerSession(
       QuicConnection* connection,
       MockQuicSessionVisitor* owner,
       MockQuicCryptoServerStreamHelper* helper,
       QuicCryptoServerConfig* crypto_config,
       QuicCompressedCertsCache* compressed_certs_cache,
@@ skipping 73 matching lines @@
                     const SpdyHeaderBlock&));
 
   using QuicSession::ActivateStream;
 
   SpdyHeaderBlock original_request_headers_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockQuicSimpleServerSession);
 };
 
-namespace {
-
 class QuicSimpleServerStreamTest
     : public ::testing::TestWithParam<QuicVersion> {
  public:
   QuicSimpleServerStreamTest()
       : connection_(
             new StrictMock<MockQuicConnection>(&helper_,
                                                &alarm_factory_,
                                                Perspective::IS_SERVER,
                                                SupportedVersions(GetParam()))),
         crypto_config_(new QuicCryptoServerConfig(
@@ skipping 310 matching lines @@
 
   // Call PushResponse() should trigger stream to fetch response from cache
   // and send it back.
   EXPECT_CALL(session_,
               WriteHeadersMock(kServerInitiatedStreamId, _, false,
                                server_initiated_stream->priority(), _));
   EXPECT_CALL(session_, WritevData(_, kServerInitiatedStreamId, _, _, _, _))
       .Times(1)
       .WillOnce(Return(QuicConsumedData(kBody.size(), true)));
   server_initiated_stream->PushResponse(std::move(headers));
-  EXPECT_EQ(kPath, QuicSimpleServerStreamPeer::headers(
-                       server_initiated_stream)[":path"]
-                       .as_string());
-  EXPECT_EQ("GET", QuicSimpleServerStreamPeer::headers(
-                       server_initiated_stream)[":method"]
-                       .as_string());
+  EXPECT_EQ(
+      kPath,
+      QuicSimpleServerStreamPeer::headers(server_initiated_stream)[":path"]
+          .as_string());
+  EXPECT_EQ(
+      "GET",
+      QuicSimpleServerStreamPeer::headers(server_initiated_stream)[":method"]
+          .as_string());
 }
 
 TEST_P(QuicSimpleServerStreamTest, TestSendErrorResponse) {
   EXPECT_CALL(session_, SendRstStream(_, QUIC_STREAM_NO_ERROR, _)).Times(0);
 
   stream_->set_fin_received(true);
 
   InSequence s;
   EXPECT_CALL(session_, WriteHeadersMock(_, _, _, _, _));
   EXPECT_CALL(session_, WritevData(_, _, _, _, _, _))
@@ skipping 114 matching lines @@
   };
   StringPiece data(arr, arraysize(arr));
   QuicStreamFrame frame(stream_->id(), true, 0, data);
   // Verify that we don't crash when we get a invalid headers in stream frame.
   stream_->OnStreamFrame(frame);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net