Add convenience version() method to QuicSessionTest.

net/quic/quic_session_test.cc

 // Copyright (c) 2012 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/quic/quic_session.h"
 
 #include <set>
 #include <vector>
 
 #include "base/basictypes.h"
@@ skipping 157 matching lines @@
         EXPECT_TRUE(session_.IsClosedStream(i)) << " stream id: " << i;
       }
     }
   }
 
   void CloseStream(QuicStreamId id) {
     session_.CloseStream(id);
     closed_streams_.insert(id);
   }
 
+  QuicVersion version() const { return connection_->version(); }
+
   MockConnection* connection_;
   TestSession session_;
   set<QuicStreamId> closed_streams_;
   SpdyHeaderBlock headers_;
 };
 
 INSTANTIATE_TEST_CASE_P(Tests, QuicSessionTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicSessionTest, PeerAddress) {
@@ skipping 21 matching lines @@
   EXPECT_FALSE(session_.IsClosedStream(5));
   ASSERT_TRUE(session_.GetIncomingDataStream(5) != NULL);
   ASSERT_TRUE(session_.GetIncomingDataStream(3) != NULL);
 }
 
 TEST_P(QuicSessionTest, IsClosedStreamLocallyCreated) {
   TestStream* stream2 = session_.CreateOutgoingDataStream();
   EXPECT_EQ(2u, stream2->id());
   TestStream* stream4 = session_.CreateOutgoingDataStream();
   EXPECT_EQ(4u, stream4->id());
-  if (GetParam() <= QUIC_VERSION_12) {
+  if (version() <= QUIC_VERSION_12) {
     QuicDataStreamPeer::SetHeadersDecompressed(stream2, true);
     QuicDataStreamPeer::SetHeadersDecompressed(stream4, true);
   }
 
   CheckClosedStreams();
   CloseStream(4);
   CheckClosedStreams();
   CloseStream(2);
   CheckClosedStreams();
 }
 
 TEST_P(QuicSessionTest, IsClosedStreamPeerCreated) {
-  QuicStreamId stream_id1 = GetParam() > QUIC_VERSION_12 ? 5 : 3;
+  QuicStreamId stream_id1 = version() > QUIC_VERSION_12 ? 5 : 3;
   QuicStreamId stream_id2 = stream_id1 + 2;
   QuicDataStream* stream1 = session_.GetIncomingDataStream(stream_id1);
   QuicDataStreamPeer::SetHeadersDecompressed(stream1, true);
   QuicDataStream* stream2 = session_.GetIncomingDataStream(stream_id2);
   QuicDataStreamPeer::SetHeadersDecompressed(stream2, true);
 
   CheckClosedStreams();
   CloseStream(stream_id1);
   CheckClosedStreams();
   CloseStream(stream_id2);
   // Create a stream explicitly, and another implicitly.
   QuicDataStream* stream3 = session_.GetIncomingDataStream(stream_id2 + 4);
   QuicDataStreamPeer::SetHeadersDecompressed(stream3, true);
   CheckClosedStreams();
   // Close one, but make sure the other is still not closed
   CloseStream(stream3->id());
   CheckClosedStreams();
 }
 
 TEST_P(QuicSessionTest, StreamIdTooLarge) {
-  QuicStreamId stream_id = GetParam() > QUIC_VERSION_12 ? 5 : 3;
+  QuicStreamId stream_id = version() > QUIC_VERSION_12 ? 5 : 3;
   session_.GetIncomingDataStream(stream_id);
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   session_.GetIncomingDataStream(stream_id + 102);
 }
 
 TEST_P(QuicSessionTest, DecompressionError) {
-  if (GetParam() > QUIC_VERSION_12) {
+  if (version() > QUIC_VERSION_12) {
     QuicHeadersStream* stream = QuicSessionPeer::GetHeadersStream(&session_);
     const unsigned char data[] = {
         0x80, 0x03, 0x00, 0x01,  // SPDY/3 SYN_STREAM frame
         0x00, 0x00, 0x00, 0x25,  // flags/length
         0x00, 0x00, 0x00, 0x05,  // stream id
         0x00, 0x00, 0x00, 0x00,  // associated stream id
         0x00, 0x00,
         'a',  'b',  'c',  'd'    // invalid compressed data
     };
     EXPECT_CALL(*connection_,
@@ skipping 215 matching lines @@
 TEST_P(QuicSessionTest, IncreasedTimeoutAfterCryptoHandshake) {
   EXPECT_EQ(kDefaultInitialTimeoutSecs,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
   CryptoHandshakeMessage msg;
   session_.crypto_stream_.OnHandshakeMessage(msg);
   EXPECT_EQ(kDefaultTimeoutSecs,
             QuicConnectionPeer::GetNetworkTimeout(connection_).ToSeconds());
 }
 
 TEST_P(QuicSessionTest, ZombieStream) {
-  QuicStreamId stream_id1 = GetParam() > QUIC_VERSION_12 ? 5 : 3;
+  QuicStreamId stream_id1 = version() > QUIC_VERSION_12 ? 5 : 3;
   QuicStreamId stream_id2 = stream_id1 + 2;
   StrictMock<MockConnection>* connection =
-      new StrictMock<MockConnection>(false, SupportedVersions(GetParam()));
+      new StrictMock<MockConnection>(false, SupportedVersions(version()));
   TestSession session(connection);
 
   TestStream* stream1 = session.CreateOutgoingDataStream();
   EXPECT_EQ(stream_id1, stream1->id());
   TestStream* stream2 = session.CreateOutgoingDataStream();
   EXPECT_EQ(stream_id2, stream2->id());
   EXPECT_EQ(2u, session.GetNumOpenStreams());
 
   // Reset the stream, but since the headers have not been decompressed
   // it will become a zombie and will continue to process data
@@ skipping 18 matching lines @@
   frames.push_back(frame1);
   EXPECT_FALSE(stream1->headers_decompressed());
 
   session.OnStreamFrames(frames);
   EXPECT_EQ(1u, session.GetNumOpenStreams());
 
   EXPECT_TRUE(connection->connected());
 }
 
 TEST_P(QuicSessionTest, ZombieStreamConnectionClose) {
-  QuicStreamId stream_id1 = GetParam() > QUIC_VERSION_12 ? 5 : 3;
+  QuicStreamId stream_id1 = version() > QUIC_VERSION_12 ? 5 : 3;
   QuicStreamId stream_id2 = stream_id1 + 2;
   StrictMock<MockConnection>* connection =
-      new StrictMock<MockConnection>(false, SupportedVersions(GetParam()));
+      new StrictMock<MockConnection>(false, SupportedVersions(version()));
   TestSession session(connection);
 
   TestStream* stream1 = session.CreateOutgoingDataStream();
   EXPECT_EQ(stream_id1, stream1->id());
   TestStream* stream2 = session.CreateOutgoingDataStream();
   EXPECT_EQ(stream_id2, stream2->id());
   EXPECT_EQ(2u, session.GetNumOpenStreams());
 
   stream1->CloseWriteSide();
   // Reset the stream, but since the headers have not been decompressed
   // it will become a zombie and will continue to process data
   // until the headers are decompressed.
   EXPECT_CALL(*connection, SendRstStream(stream_id1, QUIC_STREAM_CANCELLED, 0));
   session.SendRstStream(stream_id1, QUIC_STREAM_CANCELLED, 0);
 
   EXPECT_EQ(1u, session.GetNumOpenStreams());
 
   connection->CloseConnection(QUIC_CONNECTION_TIMED_OUT, false);
 
   EXPECT_EQ(0u, session.GetNumOpenStreams());
 }
 
 TEST_P(QuicSessionTest, RstStreamBeforeHeadersDecompressed) {
-  QuicStreamId stream_id1 = GetParam() > QUIC_VERSION_12 ? 5 : 3;
+  QuicStreamId stream_id1 = version() > QUIC_VERSION_12 ? 5 : 3;
   // Send two bytes of payload.
   QuicStreamFrame data1(stream_id1, false, 0, MakeIOVector("HT"));
   vector<QuicStreamFrame> frames;
   frames.push_back(data1);
   EXPECT_TRUE(session_.OnStreamFrames(frames));
   EXPECT_EQ(1u, session_.GetNumOpenStreams());
 
-  if (GetParam() <= QUIC_VERSION_12) {
+  if (version() <= QUIC_VERSION_12) {
     // Send a reset before the headers have been decompressed.  This causes
     // an unrecoverable compression context state.
     EXPECT_CALL(*connection_, SendConnectionClose(
         QUIC_STREAM_RST_BEFORE_HEADERS_DECOMPRESSED));
   }
 
   QuicRstStreamFrame rst1(stream_id1, QUIC_STREAM_NO_ERROR, 0);
   session_.OnRstStream(rst1);
   EXPECT_EQ(0u, session_.GetNumOpenStreams());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net