Add an async method to QuicChromiumClientSession::Handle for

net/quic/chromium/quic_http_stream.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.
 
 #ifndef NET_QUIC_CHROMIUM_QUIC_HTTP_STREAM_H_
 #define NET_QUIC_CHROMIUM_QUIC_HTTP_STREAM_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 17 matching lines @@
 
 namespace net {
 
 namespace test {
 class QuicHttpStreamPeer;
 }  // namespace test
 
 // The QuicHttpStream is a QUIC-specific HttpStream subclass.  It holds a
 // non-owning pointer to a QuicChromiumClientStream which it uses to
 // send and receive data.
-class NET_EXPORT_PRIVATE QuicHttpStream
-    : public QuicClientPushPromiseIndex::Delegate,
-      public MultiplexedHttpStream {
+class NET_EXPORT_PRIVATE QuicHttpStream : public MultiplexedHttpStream {
  public:
   explicit QuicHttpStream(
       std::unique_ptr<QuicChromiumClientSession::Handle> session);
 
   ~QuicHttpStream() override;
 
   // HttpStream implementation.
   int InitializeStream(const HttpRequestInfo* request_info,
                        RequestPriority priority,
                        const NetLogWithSource& net_log,
                        const CompletionCallback& callback) override;
   int SendRequest(const HttpRequestHeaders& request_headers,
                   HttpResponseInfo* response,
                   const CompletionCallback& callback) override;
   int ReadResponseHeaders(const CompletionCallback& callback) override;
   int ReadResponseBody(IOBuffer* buf,
                        int buf_len,
                        const CompletionCallback& callback) override;
   void Close(bool not_reusable) override;
   bool IsResponseBodyComplete() const override;
   bool IsConnectionReused() const override;
   int64_t GetTotalReceivedBytes() const override;
   int64_t GetTotalSentBytes() const override;
   bool GetLoadTimingInfo(LoadTimingInfo* load_timing_info) const override;
   bool GetAlternativeService(
       AlternativeService* alternative_service) const override;
   void PopulateNetErrorDetails(NetErrorDetails* details) override;
   void SetPriority(RequestPriority priority) override;
 
-  // QuicClientPushPromiseIndex::Delegate implementation
-  bool CheckVary(const SpdyHeaderBlock& client_request,
-                 const SpdyHeaderBlock& promise_request,
-                 const SpdyHeaderBlock& promise_response) override;
-  // TODO(rch): QuicClientPushPromiseIndex::Delegate is part of shared code.
-  // Figure out how to make the QuicHttpStream receive a Handle in this
-  // case instead of a QuicSpdyStream.
-  void OnRendezvousResult(QuicSpdyStream* stream) override;
-
   static HttpResponseInfo::ConnectionInfo ConnectionInfoFromQuicVersion(
       QuicVersion quic_version);
 
  private:
   friend class test::QuicHttpStreamPeer;
 
   enum State {
     STATE_NONE,
     STATE_HANDLE_PROMISE,
     STATE_HANDLE_PROMISE_COMPLETE,
@@ skipping 121 matching lines @@
   // Temporary buffer used to read the request body from UploadDataStream.
   scoped_refptr<IOBufferWithSize> raw_request_body_buf_;
   // Wraps raw_request_body_buf_ to read the remaining data progressively.
   scoped_refptr<DrainableIOBuffer> request_body_buf_;
 
   NetLogWithSource stream_net_log_;
 
   int session_error_;  // Error code from the connection shutdown.
 
   bool found_promise_;
-  // |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_;
 
   // Set to true when DoLoop() is being executed, false otherwise.
   bool in_loop_;
 
   // Session connect timing info.
   LoadTimingInfo::ConnectTiming connect_timing_;
 
   base::WeakPtrFactory<QuicHttpStream> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicHttpStream);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_CHROMIUM_QUIC_HTTP_STREAM_H_