Move tests from portable_quic to the new quic/quartc wrapper location.

net/quic/quartc/quartc_session.cc

 // Copyright (c) 2017 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/quartc/quartc_session.h"
 
 #include "net/quic/platform/api/quic_ptr_util.h"
 
 using std::string;
 
@@ skipping 131 matching lines @@
 const QuicCryptoStream* QuartcSession::GetCryptoStream() const {
   return crypto_stream_.get();
 }
 
 QuicCryptoStream* QuartcSession::GetMutableCryptoStream() {
   return crypto_stream_.get();
 }
 
 QuartcStream* QuartcSession::CreateOutgoingDynamicStream(
     SpdyPriority priority) {
-  return CreateDataStream(GetNextOutgoingStreamId(), priority);
+  return ActivateDataStream(
+      CreateDataStream(GetNextOutgoingStreamId(), priority));
 }
 
 void QuartcSession::OnCryptoHandshakeEvent(CryptoHandshakeEvent event) {
   QuicSession::OnCryptoHandshakeEvent(event);
   if (event == HANDSHAKE_CONFIRMED) {
     DCHECK(IsEncryptionEstablished());
     DCHECK(IsCryptoHandshakeConfirmed());
 
     DCHECK(session_delegate_);
     session_delegate_->OnCryptoHandshakeComplete();
@@ skipping 97 matching lines @@
     QuicCryptoClientConfig* client_config) {
   quic_crypto_client_config_.reset(client_config);
 }
 
 void QuartcSession::SetServerCryptoConfig(
     QuicCryptoServerConfig* server_config) {
   quic_crypto_server_config_.reset(server_config);
 }
 
 QuicStream* QuartcSession::CreateIncomingDynamicStream(QuicStreamId id) {
-  QuartcStream* stream = CreateDataStream(id, kDefaultPriority);
+  return ActivateDataStream(CreateDataStream(id, kDefaultPriority));
+}
+
+std::unique_ptr<QuicStream> QuartcSession::CreateStream(QuicStreamId id) {
+  return CreateDataStream(id, kDefaultPriority);
+}
+
+std::unique_ptr<QuartcStream> QuartcSession::CreateDataStream(
+    QuicStreamId id,
+    SpdyPriority priority) {
+  if (crypto_stream_ == nullptr || !crypto_stream_->encryption_established()) {
+    // Encryption not active so no stream created
+    return nullptr;
+  }
+  auto stream = QuicMakeUnique<QuartcStream>(id, this);
   if (stream) {
-    DCHECK(session_delegate_);
-    session_delegate_->OnIncomingStream(stream);
+    // Register the stream to the QuicWriteBlockedList. |priority| is clamped
+    // between 0 and 7, with 0 being the highest priority and 7 the lowest
+    // priority.
+    write_blocked_streams()->RegisterStream(stream->id(), priority);
+
+    // Incoming streams need to be registered with the session_delegate_.
+    if (IsIncomingStream(id)) {
+      DCHECK(session_delegate_);
+      session_delegate_->OnIncomingStream(stream.get());
+    }
   }
   return stream;
 }
 
-std::unique_ptr<QuicStream> QuartcSession::CreateStream(QuicStreamId id) {
-  QuartcStream* stream = CreateDataStream(id, kDefaultPriority);
-  return QuicWrapUnique(stream);
-}
-
-QuartcStream* QuartcSession::CreateDataStream(QuicStreamId id,
-                                              SpdyPriority priority) {
-  if (crypto_stream_ == nullptr || !crypto_stream_->encryption_established()) {
-    // Encryption not active so no stream created
-    return nullptr;
+QuartcStream* QuartcSession::ActivateDataStream(
+    std::unique_ptr<QuartcStream> stream) {
+  // Transfer ownership of the data stream to the session via ActivateStream().
+  QuartcStream* raw = stream.release();
+  if (raw) {
+    // Make QuicSession take ownership of the stream.
+    ActivateStream(std::unique_ptr<QuicStream>(raw));
   }
-  QuartcStream* stream = new QuartcStream(id, this);
-  if (stream) {
-    // Make QuicSession take ownership of the stream.
-    ActivateStream(std::unique_ptr<QuicStream>(stream));
-    // Register the stream to the QuicWriteBlockedList. |priority| is clamped
-    // between 0 and 7, with 0 being the highest priority and 7 the lowest
-    // priority.
-    write_blocked_streams()->RegisterStream(stream->id(), priority);
-  }
-  return stream;
+  return raw;
 }
 
 }  // namespace net