QuicChromiumClientSession::StreamRequest to be created by the session

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 168 matching lines @@
 
   const GURL& GetURL() const override { return request_url_; }
 
  private:
   base::WeakPtr<QuicChromiumClientSession> session_;
   const GURL request_url_;
 };
 
 }  // namespace
 
-QuicChromiumClientSession::StreamRequest::StreamRequest() : stream_(nullptr) {}
+QuicChromiumClientSession::StreamRequest::StreamRequest(
+    const base::WeakPtr<QuicChromiumClientSession>& session)
+    : session_(session), stream_(nullptr) {}
 
 QuicChromiumClientSession::StreamRequest::~StreamRequest() {
-  CancelRequest();
+  if (stream_)
+    stream_->Reset(QUIC_STREAM_CANCELLED);
+
+  if (session_)
+    session_->CancelRequest(this);
 }
 
 int QuicChromiumClientSession::StreamRequest::StartRequest(
-    const base::WeakPtr<QuicChromiumClientSession>& session,
-    QuicChromiumClientStream** stream,
     const CompletionCallback& callback) {
-  session_ = session;
-  stream_ = stream;
-  int rv = session_->TryCreateStream(this, stream_);
+  DCHECK(session_);
+  int rv = session_->TryCreateStream(this);
   if (rv == ERR_IO_PENDING) {
     callback_ = callback;
+  } else {
+    session_.reset();
   }
 
   return rv;
 }
 
-void QuicChromiumClientSession::StreamRequest::CancelRequest() {
-  if (session_)
-    session_->CancelRequest(this);
-  session_.reset();
-  callback_.Reset();
+QuicChromiumClientStream*
+QuicChromiumClientSession::StreamRequest::ReleaseStream() {
+  DCHECK(stream_);
+  QuicChromiumClientStream* stream = stream_;
+  stream_ = nullptr;
+  return stream;
 }
 
 void QuicChromiumClientSession::StreamRequest::OnRequestCompleteSuccess(
     QuicChromiumClientStream* stream) {
   session_.reset();
-  *stream_ = stream;
+  stream_ = stream;
   base::ResetAndReturn(&callback_).Run(OK);
 }
 
 void QuicChromiumClientSession::StreamRequest::OnRequestCompleteFailure(
     int rv) {
   session_.reset();
   base::ResetAndReturn(&callback_).Run(rv);
 }
 
 QuicChromiumClientSession::QuicChromiumClientSession(
@@ skipping 219 matching lines @@
 
   DCHECK(!base::ContainsKey(observers_, observer));
   observers_.insert(observer);
 }
 
 void QuicChromiumClientSession::RemoveObserver(Observer* observer) {
   DCHECK(base::ContainsKey(observers_, observer));
   observers_.erase(observer);
 }
 
-int QuicChromiumClientSession::TryCreateStream(
-    StreamRequest* request,
-    QuicChromiumClientStream** stream) {
+std::unique_ptr<QuicChromiumClientSession::StreamRequest>
+QuicChromiumClientSession::CreateStreamRequest() {
+  // base::MakeUnique does not work because the StreamRequest constructor
+  // is private.
+  return std::unique_ptr<StreamRequest>(
+      new StreamRequest(weak_factory_.GetWeakPtr()));
+}
+
+int QuicChromiumClientSession::TryCreateStream(StreamRequest* request) {
   if (goaway_received()) {
     DVLOG(1) << "Going away.";
     return ERR_CONNECTION_CLOSED;
   }
 
   if (!connection()->connected()) {
     DVLOG(1) << "Already closed.";
     return ERR_CONNECTION_CLOSED;
   }
 
   if (going_away_) {
     RecordUnexpectedOpenStreams(TRY_CREATE_STREAM);
     return ERR_CONNECTION_CLOSED;
   }
 
   if (GetNumOpenOutgoingStreams() < max_open_outgoing_streams()) {
-    *stream = CreateOutgoingReliableStreamImpl();
+    request->stream_ = CreateOutgoingReliableStreamImpl();
     return OK;
   }
 
   request->pending_start_time_ = base::TimeTicks::Now();
   stream_requests_.push_back(request);
   UMA_HISTOGRAM_COUNTS_1000("Net.QuicSession.NumPendingStreamRequests",
                             stream_requests_.size());
   return ERR_IO_PENDING;
 }
 
@@ skipping 992 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