QUIC - refactor stream creation. Guarded by --quic_reloadable_flag_quic_refactor_stream_creation.

net/tools/quic/quic_simple_server_session_test.cc

Index: net/tools/quic/quic_simple_server_session_test.cc
diff --git a/net/tools/quic/quic_simple_server_session_test.cc b/net/tools/quic/quic_simple_server_session_test.cc
index 3a44ab908289dd100b1b399533e48aebe4b02810..85e80ad30b54ef675b1b257f89c42c020fa9e80f 100644
--- a/net/tools/quic/quic_simple_server_session_test.cc
+++ b/net/tools/quic/quic_simple_server_session_test.cc
@@ -56,13 +56,18 @@ class QuicSimpleServerSessionPeer {
 
   static QuicSpdyStream* CreateIncomingDynamicStream(QuicSimpleServerSession* s,
                                                      QuicStreamId id) {
-    return s->CreateIncomingDynamicStream(id);
+    return FLAGS_quic_reloadable_flag_quic_refactor_stream_creation
+               ? s->MaybeCreateIncomingDynamicStream(id)
+               : s->CreateIncomingDynamicStream(id);
   }
 
   static QuicSimpleServerStream* CreateOutgoingDynamicStream(
       QuicSimpleServerSession* s,
       SpdyPriority priority) {
-    return s->CreateOutgoingDynamicStream(priority);
+    return FLAGS_quic_reloadable_flag_quic_refactor_stream_creation
+               ? static_cast<QuicSimpleServerStream*>(
+                     s->MaybeCreateOutgoingDynamicStream(priority))
+               : s->CreateOutgoingDynamicStream(priority);
   }
 
   static std::deque<PromisedStreamInfo>* promised_streams(
@@ -314,13 +319,24 @@ TEST_P(QuicSimpleServerSessionTest, CreateIncomingDynamicStreamDisconnected) {
   // Tests that incoming stream creation fails when connection is not connected.
   size_t initial_num_open_stream = session_->GetNumOpenIncomingStreams();
   QuicConnectionPeer::TearDownLocalConnectionState(connection_);
-  EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateIncomingDynamicStream(
-                      session_.get(), GetNthClientInitiatedId(0)),
-                  "ShouldCreateIncomingDynamicStream called when disconnected");
+  if (FLAGS_quic_reloadable_flag_quic_refactor_stream_creation) {
+    EXPECT_EQ(nullptr, QuicSimpleServerSessionPeer::CreateIncomingDynamicStream(
+                           session_.get(), GetNthClientInitiatedId(0)));
+  } else {
+    EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateIncomingDynamicStream(
+                        session_.get(), GetNthClientInitiatedId(0)),
+                    "ShouldCreateIncomingDynamicStream called when "
+                    "disconnected");
+  }
   EXPECT_EQ(initial_num_open_stream, session_->GetNumOpenIncomingStreams());
 }
 
 TEST_P(QuicSimpleServerSessionTest, CreateEvenIncomingDynamicStream) {
+  if (FLAGS_quic_reloadable_flag_quic_refactor_stream_creation) {
+    EXPECT_EQ(nullptr, QuicSimpleServerSessionPeer::CreateIncomingDynamicStream(
+                           session_.get(), 2));
+    return;
+  }
   // Tests that incoming stream creation fails when given stream id is even.
   size_t initial_num_open_stream = session_->GetNumOpenIncomingStreams();
   EXPECT_CALL(*connection_,
@@ -342,9 +358,15 @@ TEST_P(QuicSimpleServerSessionTest, CreateOutgoingDynamicStreamDisconnected) {
   // Tests that outgoing stream creation fails when connection is not connected.
   size_t initial_num_open_stream = session_->GetNumOpenOutgoingStreams();
   QuicConnectionPeer::TearDownLocalConnectionState(connection_);
-  EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateOutgoingDynamicStream(
-                      session_.get(), kDefaultPriority),
-                  "ShouldCreateOutgoingDynamicStream called when disconnected");
+  if (FLAGS_quic_reloadable_flag_quic_refactor_stream_creation) {
+    EXPECT_EQ(nullptr, QuicSimpleServerSessionPeer::CreateOutgoingDynamicStream(
+                           session_.get(), kDefaultPriority));
+  } else {
+    EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateOutgoingDynamicStream(
+                        session_.get(), kDefaultPriority),
+                    "ShouldCreateOutgoingDynamicStream called when "
+                    "disconnected");
+  }
 
   EXPECT_EQ(initial_num_open_stream, session_->GetNumOpenOutgoingStreams());
 }
@@ -353,9 +375,15 @@ TEST_P(QuicSimpleServerSessionTest, CreateOutgoingDynamicStreamUnencrypted) {
   // Tests that outgoing stream creation fails when encryption has not yet been
   // established.
   size_t initial_num_open_stream = session_->GetNumOpenOutgoingStreams();
-  EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateOutgoingDynamicStream(
-                      session_.get(), kDefaultPriority),
-                  "Encryption not established so no outgoing stream created.");
+  if (FLAGS_quic_reloadable_flag_quic_refactor_stream_creation) {
+    EXPECT_EQ(nullptr, QuicSimpleServerSessionPeer::CreateOutgoingDynamicStream(
+                           session_.get(), kDefaultPriority));
+  } else {
+    EXPECT_QUIC_BUG(QuicSimpleServerSessionPeer::CreateOutgoingDynamicStream(
+                        session_.get(), kDefaultPriority),
+                    "Encryption not established so no outgoing stream "
+                    "created.");
+  }
   EXPECT_EQ(initial_num_open_stream, session_->GetNumOpenOutgoingStreams());
 }