Rename GetIncomingReliableStream to GetIncomingDataStream.

net/tools/quic/quic_server_session_test.cc

 // Copyright 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_server_session.h"
 
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/quic_connection.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
@@ skipping 12 matching lines @@
 using net::test::SupportedVersions;
 using testing::_;
 using testing::StrictMock;
 
 namespace net {
 namespace tools {
 namespace test {
 
 class QuicServerSessionPeer {
  public:
-  static QuicDataStream* GetIncomingReliableStream(
+  static QuicDataStream* GetIncomingDataStream(
       QuicServerSession* s, QuicStreamId id) {
-    return s->GetIncomingReliableStream(id);
+    return s->GetIncomingDataStream(id);
   }
   static QuicDataStream* GetDataStream(QuicServerSession* s, QuicStreamId id) {
     return s->GetDataStream(id);
   }
 };
 
 class CloseOnDataStream : public QuicDataStream {
  public:
   CloseOnDataStream(QuicStreamId id, QuicSession* session)
       : QuicDataStream(id, session) {
@@ skipping 171 matching lines @@
   frames.clear();
   frames.push_back(QuicStreamFrame(stream_id, false, 2, MakeIOVector("TP")));
   frames.push_back(QuicStreamFrame(stream_id + 2, false, 2,
                                    MakeIOVector("TP")));
   EXPECT_TRUE(visitor_->OnStreamFrames(frames));
 }
 
 TEST_P(QuicServerSessionTest, MaxNumConnections) {
   QuicStreamId stream_id = GetParam() == QUIC_VERSION_12 ? 3 : 5;
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingReliableStream(session_.get(),
-                                                               stream_id));
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingReliableStream(session_.get(),
-                                                               stream_id + 2));
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingReliableStream(session_.get(),
-                                                               stream_id + 4));
+  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
+                                                           stream_id));
+  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
+                                                           stream_id + 2));
+  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
+                                                           stream_id + 4));
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
-  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingReliableStream(session_.get(),
-                                                                stream_id + 6));
+  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
+                                                            stream_id + 6));
 }
 
 TEST_P(QuicServerSessionTest, MaxNumConnectionsImplicit) {
   QuicStreamId stream_id = GetParam() == QUIC_VERSION_12 ? 3 : 5;
   EXPECT_EQ(0u, session_->GetNumOpenStreams());
-  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingReliableStream(session_.get(),
-                                                               stream_id));
+  EXPECT_TRUE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
+                                                           stream_id));
   // Implicitly opens two more streams.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_TOO_MANY_OPEN_STREAMS));
-  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingReliableStream(session_.get(),
-                                                                stream_id + 6));
+  EXPECT_FALSE(QuicServerSessionPeer::GetIncomingDataStream(session_.get(),
+                                                            stream_id + 6));
 }
 
 TEST_P(QuicServerSessionTest, GetEvenIncomingError) {
   // Incoming streams on the server session must be odd.
   EXPECT_CALL(*connection_, SendConnectionClose(QUIC_INVALID_STREAM_ID));
   EXPECT_EQ(NULL,
-            QuicServerSessionPeer::GetIncomingReliableStream(
-                session_.get(), 4));
+            QuicServerSessionPeer::GetIncomingDataStream(session_.get(), 4));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net