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

net/tools/quic/quic_client_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/tools/quic/quic_client_session.h"
 
 #include <vector>
 
 #include "net/quic/core/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/core/spdy_utils.h"
@@ skipping 36 matching lines @@
                           connection,
                           server_id,
                           crypto_config,
                           push_promise_index) {}
 
   std::unique_ptr<QuicSpdyClientStream> CreateClientStream() override {
     return QuicMakeUnique<MockQuicSpdyClientStream>(GetNextOutgoingStreamId(),
                                                     this);
   }
 
+  std::unique_ptr<QuicStream> CreateStream(QuicStreamId id) override {
+    return QuicMakeUnique<MockQuicSpdyClientStream>(id, this);
+  }
+
   MockQuicSpdyClientStream* CreateIncomingDynamicStream(
       QuicStreamId id) override {
     MockQuicSpdyClientStream* stream = new MockQuicSpdyClientStream(id, this);
     ActivateStream(QuicWrapUnique(stream));
     return stream;
   }
+
+  QuicSpdyClientStream* CreateOutgoingDynamicStream(
+      SpdyPriority priority) override {
+    return FLAGS_quic_reloadable_flag_quic_refactor_stream_creation
+               ? MaybeCreateOutgoingDynamicStream(priority)
+               : QuicClientSession::CreateOutgoingDynamicStream(priority);
+  }
 };
 
 class QuicClientSessionTest : public QuicTestWithParam<QuicVersion> {
  protected:
   QuicClientSessionTest()
       : crypto_config_(crypto_test_utils::ProofVerifierForTesting()),
         promised_stream_id_(kInvalidStreamId),
         associated_stream_id_(kInvalidStreamId) {
     Initialize();
     // Advance the time, because timers do not like uninitialized times.
@@ skipping 83 matching lines @@
   // at NONE.
   CryptoHandshakeMessage rej;
   crypto_test_utils::FillInDummyReject(&rej, /* stateless */ false);
   EXPECT_TRUE(session_->IsEncryptionEstablished());
   session_->GetMutableCryptoStream()->OnHandshakeMessage(rej);
   EXPECT_FALSE(session_->IsEncryptionEstablished());
   EXPECT_EQ(ENCRYPTION_NONE,
             QuicPacketCreatorPeer::GetEncryptionLevel(
                 QuicConnectionPeer::GetPacketCreator(connection_)));
   // Verify that no new streams may be created.
-  EXPECT_TRUE(session_->CreateOutgoingDynamicStream(kDefaultPriority) ==
-              nullptr);
+  if (FLAGS_quic_reloadable_flag_quic_refactor_stream_creation) {
+    EXPECT_EQ(nullptr, session_->CreateOutgoingDynamicStream(kDefaultPriority));
+  } else {
+    EXPECT_TRUE(session_->CreateOutgoingDynamicStream(kDefaultPriority) ==
+                nullptr);
+  }
   // Verify that no data may be send on existing streams.
   char data[] = "hello world";
   struct iovec iov = {data, arraysize(data)};
   QuicIOVector iovector(&iov, 1, iov.iov_len);
   QuicConsumedData consumed =
       session_->WritevData(stream, stream->id(), iovector, 0, NO_FIN, nullptr);
   EXPECT_FALSE(consumed.fin_consumed);
   EXPECT_EQ(0u, consumed.bytes_consumed);
 }
 
@@ skipping 384 matching lines @@
   QuicClientPromisedInfo* promised =
       session_->GetPromisedById(promised_stream_id_);
   EXPECT_NE(promised, nullptr);
   EXPECT_NE(session_->GetPromisedByUrl(promise_url_), nullptr);
   EXPECT_EQ(session_->GetPromisedStream(promised_stream_id_), nullptr);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net