Remove QuicChromiumClientStream::Delegate in favor of async methods.

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 18 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 QuicChromiumClientStream::Delegate,
-      public QuicClientPushPromiseIndex::Delegate,
+    : public QuicClientPushPromiseIndex::Delegate,
       public MultiplexedHttpStream {
  public:
   explicit QuicHttpStream(
       std::unique_ptr<QuicChromiumClientSession::Handle> session);
 
   ~QuicHttpStream() override;
 
   // HttpStream implementation.
   int InitializeStream(const HttpRequestInfo* request_info,
                        RequestPriority priority,
@@ skipping 10 matching lines @@
   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;
 
-  // QuicChromiumClientStream::Delegate implementation
-  void OnClose() override;
-  void OnError(int error) 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(
@@ skipping 39 matching lines @@
   void ReadTrailingHeaders();
   void OnReadTrailingHeadersComplete(int rv);
 
   void OnReadBodyComplete(int rv);
   int HandleReadComplete(int rv);
 
   void EnterStateSendHeaders();
 
   void ResetStream();
 
+  // Returns ERR_QUIC_HANDSHAKE_FAILED, if |rv| is ERR_QUIC_PROTOCOL_ERROR and
+  // the handshake was never confirmed. Otherwise, returns |rv|.
+  int MapStreamError(int rv);
+
   // If |has_response_status_| is false, sets |response_status| to the result
   // of ComputeResponseStatus(). Returns |response_status_|.
   int GetResponseStatus();
   // Sets the result of |ComputeResponseStatus()| as the |response_status_|.
   void SaveResponseStatus();
   // Sets |response_status_| to |response_status| and sets
   // |has_response_status_| to true.
   void SetResponseStatus(int response_status);
   // Computes the correct response status based on the status of the handshake,
   // |session_error|, |connection_error| and |stream_error|.
@@ skipping 65 matching lines @@
   int user_buffer_len_;
 
   // 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.
-  QuicErrorCode quic_connection_error_;       // Cached connection error code.
-  QuicRstStreamErrorCode quic_stream_error_;  // Cached stream error code.
 
   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_