Create a QuicChromiumClientStream::Handle class for allowing a stream

net/quic/chromium/quic_chromium_client_session.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/chromium/quic_chromium_client_session.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/location.h"
@@ skipping 283 matching lines @@
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
   // base::MakeUnique does not work because the StreamRequest constructor
   // is private.
   stream_request_ = std::unique_ptr<StreamRequest>(
       new StreamRequest(this, requires_confirmation));
   return stream_request_->StartRequest(callback);
 }
 
-QuicChromiumClientStream* QuicChromiumClientSession::Handle::ReleaseStream(
+std::unique_ptr<QuicChromiumClientStream::Handle>
+QuicChromiumClientSession::Handle::ReleaseStream(
     QuicChromiumClientStream::Delegate* delegate) {
   DCHECK(stream_request_);
 
-  auto* stream = stream_request_->ReleaseStream(delegate);
+  auto handle = stream_request_->ReleaseStream(delegate);
   stream_request_.reset();
-  return stream;
+  return handle;
 }
 
 int QuicChromiumClientSession::Handle::WaitForHandshakeConfirmation(
     const CompletionCallback& callback) {
   if (!session_)
     return ERR_CONNECTION_CLOSED;
 
   return session_->WaitForHandshakeConfirmation(callback);
 }
 
@@ skipping 48 matching lines @@
     return ERR_CONNECTION_CLOSED;
 
   next_state_ = STATE_WAIT_FOR_CONFIRMATION;
   int rv = DoLoop(OK);
   if (rv == ERR_IO_PENDING)
     callback_ = callback;
 
   return rv;
 }
 
-QuicChromiumClientStream*
+std::unique_ptr<QuicChromiumClientStream::Handle>
 QuicChromiumClientSession::StreamRequest::ReleaseStream(
     QuicChromiumClientStream::Delegate* delegate) {
   DCHECK(stream_);
   QuicChromiumClientStream* stream = stream_;
   stream_ = nullptr;
-  stream->SetDelegate(delegate);
-  return stream;
+  return stream->CreateHandle(delegate);
 }
 
 void QuicChromiumClientSession::StreamRequest::OnRequestCompleteSuccess(
     QuicChromiumClientStream* stream) {
   DCHECK_EQ(STATE_REQUEST_STREAM_COMPLETE, next_state_);
 
   stream_ = stream;
   // This method is called even when the request completes synchronously.
   if (callback_)
     DoCallback(OK);
@@ skipping 1360 matching lines @@
 }
 
 size_t QuicChromiumClientSession::EstimateMemoryUsage() const {
   // TODO(xunjieli): Estimate |crypto_stream_|, QuicSpdySession's
   // QuicHeaderList, QuicSession's QuiCWriteBlockedList, open streams and
   // unacked packet map.
   return base::trace_event::EstimateMemoryUsage(packet_readers_);
 }
 
 }  // namespace net