Rename GetIncomingReliableStream to GetIncomingDataStream.

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/containers/hash_tables.h"
@@ skipping 96 matching lines @@
   }
 
   virtual TestStream* CreateIncomingDataStream(QuicStreamId id) OVERRIDE {
     return new TestStream(id, this);
   }
 
   bool IsClosedStream(QuicStreamId id) {
     return QuicSession::IsClosedStream(id);
   }
 
-  QuicDataStream* GetIncomingReliableStream(QuicStreamId stream_id) {
-    return QuicSession::GetIncomingReliableStream(stream_id);
+  QuicDataStream* GetIncomingDataStream(QuicStreamId stream_id) {
+    return QuicSession::GetIncomingDataStream(stream_id);
   }
 
   TestCryptoStream crypto_stream_;
 };
 
 class QuicSessionTest : public ::testing::TestWithParam<QuicVersion> {
  protected:
   QuicSessionTest()
       : connection_(new MockConnection(true, SupportedVersions(GetParam()))),
         session_(connection_) {
@@ skipping 62 matching lines @@
 }
 
 TEST_P(QuicSessionTest, IsClosedStreamDefault) {
   // Ensure that no streams are initially closed.
   for (int i = kCryptoStreamId; i < 100; i++) {
     EXPECT_FALSE(session_.IsClosedStream(i)) << "stream id: " << i;
   }
 }
 
 TEST_P(QuicSessionTest, ImplicitlyCreatedStreams) {
-  ASSERT_TRUE(session_.GetIncomingReliableStream(7) != NULL);
+  ASSERT_TRUE(session_.GetIncomingDataStream(7) != NULL);
   // Both 3 and 5 should be implicitly created.
   EXPECT_FALSE(session_.IsClosedStream(3));
   EXPECT_FALSE(session_.IsClosedStream(5));
-  ASSERT_TRUE(session_.GetIncomingReliableStream(5) != NULL);
-  ASSERT_TRUE(session_.GetIncomingReliableStream(3) != NULL);
+  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) {
     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_id2 = stream_id1 + 2;
-  QuicDataStream* stream1 = session_.GetIncomingReliableStream(stream_id1);
+  QuicDataStream* stream1 = session_.GetIncomingDataStream(stream_id1);
   QuicDataStreamPeer::SetHeadersDecompressed(stream1, true);
-  QuicDataStream* stream2 = session_.GetIncomingReliableStream(stream_id2);
+  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_.GetIncomingReliableStream(stream_id2 + 4);
+  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;
-  session_.GetIncomingReliableStream(stream_id);
+  session_.GetIncomingDataStream(stream_id);
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
-  session_.GetIncomingReliableStream(stream_id + 102);
+  session_.GetIncomingDataStream(stream_id + 102);
 }
 
 TEST_P(QuicSessionTest, DecompressionError) {
   if (GetParam() > 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_,
                 SendConnectionCloseWithDetails(QUIC_INVALID_HEADERS_STREAM_DATA,
                                                "SPDY framing error."));
     stream->ProcessRawData(reinterpret_cast<const char*>(data),
                            arraysize(data));
   } else {
-    ReliableQuicStream* stream = session_.GetIncomingReliableStream(3);
+    ReliableQuicStream* stream = session_.GetIncomingDataStream(3);
     const char data[] =
         "\0\0\0\0"   // priority
         "\1\0\0\0"   // headers id
         "\0\0\0\4"   // length
         "abcd";      // invalid compressed data
     EXPECT_CALL(*connection_, SendConnectionClose(QUIC_DECOMPRESSION_FAILURE));
     stream->ProcessRawData(data, arraysize(data));
   }
 }
 
@@ skipping 117 matching lines @@
 
 TEST_P(QuicSessionTest, SendGoAway) {
   // After sending a GoAway, ensure new incoming streams cannot be created and
   // result in a RST being sent.
   EXPECT_CALL(*connection_,
               SendGoAway(QUIC_PEER_GOING_AWAY, 0u, "Going Away."));
   session_.SendGoAway(QUIC_PEER_GOING_AWAY, "Going Away.");
   EXPECT_TRUE(session_.goaway_sent());
 
   EXPECT_CALL(*connection_, SendRstStream(3u, QUIC_STREAM_PEER_GOING_AWAY));
-  EXPECT_FALSE(session_.GetIncomingReliableStream(3u));
+  EXPECT_FALSE(session_.GetIncomingDataStream(3u));
 }
 
 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());
 }
@@ skipping 84 matching lines @@
   }
 
   QuicRstStreamFrame rst1(stream_id1, QUIC_STREAM_NO_ERROR);
   session_.OnRstStream(rst1);
   EXPECT_EQ(0u, session_.GetNumOpenStreams());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net