QuicChromiumClientSession::StreamRequest to be created by the session

net/quic/chromium/quic_chromium_client_session.h

 // 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.
 //
 // A client specific QuicSession subclass.  This class owns the underlying
 // QuicConnection and QuicConnectionHelper objects.  The connection stores
 // a non-owning pointer to the helper so this session needs to ensure that
 // the helper outlives the connection.
 
 #ifndef NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_SESSION_H_
@@ skipping 60 matching lines @@
    public:
     virtual ~Observer() {}
     virtual void OnCryptoHandshakeConfirmed() = 0;
     virtual void OnSuccessfulVersionNegotiation(const QuicVersion& version) = 0;
     virtual void OnSessionClosed(int error, bool port_migration_detected) = 0;
   };
 
   // A helper class used to manage a request to create a stream.
   class NET_EXPORT_PRIVATE StreamRequest {
    public:
-    StreamRequest();
+    // Cancels any pending stream creation request and resets |stream_| if
+    // it has not yet been released.
     ~StreamRequest();
 
     // Starts a request to create a stream.  If OK is returned, then
-    // |stream| will be updated with the newly created stream.  If
+    // |stream_| will be updated with the newly created stream.  If
     // ERR_IO_PENDING is returned, then when the request is eventuallly
     // complete |callback| will be called.
-    int StartRequest(const base::WeakPtr<QuicChromiumClientSession>& session,
-                     QuicChromiumClientStream** stream,
-                     const CompletionCallback& callback);
+    int StartRequest(const CompletionCallback& callback);
 
-    // Cancels any pending stream creation request. May be called
-    // repeatedly.
-    void CancelRequest();
+    // Releases |stream_| to the caller
+    QuicChromiumClientStream* ReleaseStream();
 
    private:
     friend class QuicChromiumClientSession;
 
+    StreamRequest(const base::WeakPtr<QuicChromiumClientSession>& session);
+
     // Called by |session_| for an asynchronous request when the stream
     // request has finished successfully.
     void OnRequestCompleteSuccess(QuicChromiumClientStream* stream);
 
     // Called by |session_| for an asynchronous request when the stream
     // request has finished with an error. Also called with ERR_ABORTED
     // if |session_| is destroyed while the stream request is still pending.
     void OnRequestCompleteFailure(int rv);
 
     base::WeakPtr<QuicChromiumClientSession> session_;
     CompletionCallback callback_;
-    QuicChromiumClientStream** stream_;
+    QuicChromiumClientStream* stream_;
     // For tracking how much time pending stream requests wait.
     base::TimeTicks pending_start_time_;
 
     DISALLOW_COPY_AND_ASSIGN(StreamRequest);
   };
 
   // Constructs a new session which will own |connection|, but not
   // |stream_factory|, which must outlive this session.
   // TODO(rch): decouple the factory from the session via a Delegate interface.
   QuicChromiumClientSession(
@@ skipping 19 matching lines @@
       base::TaskRunner* task_runner,
       std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
       NetLog* net_log);
   ~QuicChromiumClientSession() override;
 
   void Initialize() override;
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
+  std::unique_ptr<StreamRequest> CreateStreamRequest();
+
   // Attempts to create a new stream.  If the stream can be
   // created immediately, returns OK.  If the open stream limit
   // has been reached, returns ERR_IO_PENDING, and |request|
   // will be added to the stream requets queue and will
   // be completed asynchronously.
   // TODO(rch): remove |stream| from this and use setter on |request|
   // and fix in spdy too.
-  int TryCreateStream(StreamRequest* request,
-                      QuicChromiumClientStream** stream);
+  int TryCreateStream(StreamRequest* request);
 
   // Cancels the pending stream creation request.
   void CancelRequest(StreamRequest* request);
 
   // QuicChromiumPacketWriter::Delegate override.
   int HandleWriteError(int error_code,
                        scoped_refptr<StringIOBuffer> last_packet) override;
   void OnWriteError(int error_code) override;
   void OnWriteUnblocked() override;
 
@@ skipping 237 matching lines @@
   // the current sockets_.size() == the passed in value.
   bool migration_pending_;  // True while migration is underway.
   base::WeakPtrFactory<QuicChromiumClientSession> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicChromiumClientSession);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_CHROMIUM_CLIENT_SESSION_H_