Add an async method to QuicChromiumClientSession::Handle for

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 14 matching lines @@
 #include "net/base/load_timing_info.h"
 #include "net/base/net_error_details.h"
 #include "net/base/net_export.h"
 #include "net/cert/ct_verify_result.h"
 #include "net/log/net_log_with_source.h"
 #include "net/proxy/proxy_server.h"
 #include "net/quic/chromium/quic_chromium_client_stream.h"
 #include "net/quic/chromium/quic_chromium_packet_reader.h"
 #include "net/quic/chromium/quic_chromium_packet_writer.h"
 #include "net/quic/chromium/quic_connection_logger.h"
+#include "net/quic/core/quic_client_push_promise_index.h"
 #include "net/quic/core/quic_client_session_base.h"
 #include "net/quic/core/quic_crypto_client_stream.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_server_id.h"
 #include "net/quic/core/quic_time.h"
 #include "net/socket/socket_performance_watcher.h"
 #include "net/spdy/chromium/multiplexed_session.h"
 #include "net/spdy/chromium/server_push_delegate.h"
 
 namespace net {
@@ skipping 19 matching lines @@
     : public QuicClientSessionBase,
       public MultiplexedSession,
       public QuicChromiumPacketReader::Visitor,
       public QuicChromiumPacketWriter::Delegate {
  public:
   class StreamRequest;
 
   // Wrapper for interacting with the session in a restricted fashion which
   // hides the details of the underlying session's lifetime. All methods of
   // the Handle are safe to use even after the underlying session is destroyed.
-  class NET_EXPORT_PRIVATE Handle : public MultiplexedSessionHandle {
+  class NET_EXPORT_PRIVATE Handle
+      : public MultiplexedSessionHandle,
+        public QuicClientPushPromiseIndex::Delegate {
    public:
     explicit Handle(const base::WeakPtr<QuicChromiumClientSession>& session);
     Handle(const Handle& other) = delete;
     ~Handle() override;
 
     // Returns true if the session is still connected.
     bool IsConnected() const;
 
     // Returns true if the handshake has been confirmed.
     bool IsCryptoHandshakeConfirmed() const;
 
+    // Starts a request to rendezvous with a promised a stream.  If OK is
+    // returned, then |push_stream_| will be updated with the promised
+    // stream.  If ERR_IO_PENDING is returned, then when the rendezvous is
+    // eventually completed |callback| will be called.
+    int RendezvousWithPromised(const SpdyHeaderBlock& headers,
+                               const CompletionCallback& callback);
+
     // Starts a request to create a stream.  If OK is returned, then
     // |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 RequestStream(bool requires_confirmation,
                       const CompletionCallback& callback);
 
     // Releases |stream_| to the caller.
     std::unique_ptr<QuicChromiumClientStream::Handle> ReleaseStream();
 
+    // Releases |push_stream_| to the caller.
+    std::unique_ptr<QuicChromiumClientStream::Handle> ReleasePromisedStream();
+
     // Sends Rst for the stream, and makes sure that future calls to
     // IsClosedStream(id) return true, which ensures that any subsequent
     // frames related to this stream will be ignored (modulo flow
     // control accounting).
     void ResetPromised(QuicStreamId id, QuicRstStreamErrorCode error_code);
 
     // Returns a new packet bundler while will cause writes to be batched up
     // until a packet is full, or the last bundler is destroyed.
     std::unique_ptr<QuicConnection::ScopedPacketBundler> CreatePacketBundler(
         QuicConnection::AckBundling bundling_mode);
@@ skipping 22 matching lines @@
 
     // Returns the push promise index associated with the session.
     QuicClientPushPromiseIndex* GetPushPromiseIndex();
 
     // Returns the session's server ID.
     QuicServerId server_id() const { return server_id_; }
 
     // Returns the session's net log.
     const NetLogWithSource& net_log() const { return net_log_; }
 
+    // QuicClientPushPromiseIndex::Delegate implementation
+    bool CheckVary(const SpdyHeaderBlock& client_request,
+                   const SpdyHeaderBlock& promise_request,
+                   const SpdyHeaderBlock& promise_response) override;
+    void OnRendezvousResult(QuicSpdyStream* stream) override;
+
    private:
     friend class QuicChromiumClientSession;
     friend class QuicChromiumClientSession::StreamRequest;
 
     // Waits for the handshake to be confirmed and invokes |callback| when
     // that happens. If the handshake has already been confirmed, returns OK.
     // If the connection has already been closed, returns a net error. If the
     // connection closes before the handshake is confirmed, |callback| will
     // be invoked with an error.
     int WaitForHandshakeConfirmation(const CompletionCallback& callback);
@@ skipping 22 matching lines @@
     // Information saved from the session which can be used even after the
     // session is destroyed.
     NetLogWithSource net_log_;
     bool was_handshake_confirmed_;
     int error_;
     bool port_migration_detected_;
     QuicServerId server_id_;
     QuicVersion quic_version_;
     LoadTimingInfo::ConnectTiming connect_timing_;
     QuicClientPushPromiseIndex* push_promise_index_;
+
+    // |QuicClientPromisedInfo| owns this. It will be set when |Try()|
+    // is asynchronous, i.e. it returned QUIC_PENDING, and remains valid
+    // until |OnRendezvouResult()| fires or |push_handle_->Cancel()| is
+    // invoked.
+    QuicClientPushPromiseIndex::TryHandle* push_handle_;
+    CompletionCallback push_callback_;
+    std::unique_ptr<QuicChromiumClientStream::Handle> push_stream_;
   };
 
   // A helper class used to manage a request to create a stream.
   class NET_EXPORT_PRIVATE StreamRequest {
    public:
     // 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
@@ skipping 343 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_