1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef NET_QUIC_QUIC_HTTP_STREAM_H_ 6 #define NET_QUIC_QUIC_HTTP_STREAM_H_ 7 8 #include <list> 9 10 #include "base/memory/weak_ptr.h" 11 #include "net/base/io_buffer.h" 12 #include "net/http/http_stream.h" 13 #include "net/quic/quic_client_session.h" 14 #include "net/quic/quic_reliable_client_stream.h" 15 16 namespace net { 17 18 namespace test { 19 class QuicHttpStreamPeer; 20 } // namespace test 21 22 // The QuicHttpStream is a QUIC-specific HttpStream subclass. It holds a 23 // non-owning pointer to a QuicReliableClientStream which it uses to 24 // send and receive data. 25 class NET_EXPORT_PRIVATE QuicHttpStream : 26 public QuicClientSession::Observer, 27 public QuicReliableClientStream::Delegate, 28 public HttpStream { 29 public: 30 explicit QuicHttpStream(const base::WeakPtr<QuicClientSession>& session); 31 32 virtual ~QuicHttpStream(); 33 34 // HttpStream implementation. 35 virtual int InitializeStream(const HttpRequestInfo* request_info, 36 RequestPriority priority, 37 const BoundNetLog& net_log, 38 const CompletionCallback& callback) OVERRIDE; 39 virtual int SendRequest(const HttpRequestHeaders& request_headers, 40 HttpResponseInfo* response, 41 const CompletionCallback& callback) OVERRIDE; 42 virtual UploadProgress GetUploadProgress() const OVERRIDE; 43 virtual int ReadResponseHeaders(const CompletionCallback& callback) OVERRIDE; 44 virtual int ReadResponseBody(IOBuffer* buf, 45 int buf_len, 46 const CompletionCallback& callback) OVERRIDE; 47 virtual void Close(bool not_reusable) OVERRIDE; 48 virtual HttpStream* RenewStreamForAuth() OVERRIDE; 49 virtual bool IsResponseBodyComplete() const OVERRIDE; 50 virtual bool CanFindEndOfResponse() const OVERRIDE; 51 virtual bool IsConnectionReused() const OVERRIDE; 52 virtual void SetConnectionReused() OVERRIDE; 53 virtual bool IsConnectionReusable() const OVERRIDE; 54 virtual int64 GetTotalReceivedBytes() const OVERRIDE; 55 virtual bool GetLoadTimingInfo( 56 LoadTimingInfo* load_timing_info) const OVERRIDE; 57 virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE; 58 virtual void GetSSLCertRequestInfo( 59 SSLCertRequestInfo* cert_request_info) OVERRIDE; 60 virtual bool IsSpdyHttpStream() const OVERRIDE; 61 virtual void Drain(HttpNetworkSession* session) OVERRIDE; 62 virtual void SetPriority(RequestPriority priority) OVERRIDE; 63 64 // QuicReliableClientStream::Delegate implementation 65 virtual int OnDataReceived(const char* data, int length) OVERRIDE; 66 virtual void OnClose(QuicErrorCode error) OVERRIDE; 67 virtual void OnError(int error) OVERRIDE; 68 virtual bool HasSendHeadersComplete() OVERRIDE; 69 70 // QuicClientSession::Observer implementation 71 virtual void OnCryptoHandshakeConfirmed() OVERRIDE; 72 virtual void OnSessionClosed(int error) OVERRIDE; 73 74 private: 75 friend class test::QuicHttpStreamPeer; 76 77 enum State { 78 STATE_NONE, 79 STATE_SEND_HEADERS, 80 STATE_SEND_HEADERS_COMPLETE, 81 STATE_READ_REQUEST_BODY, 82 STATE_READ_REQUEST_BODY_COMPLETE, 83 STATE_SEND_BODY, 84 STATE_SEND_BODY_COMPLETE, 85 STATE_OPEN, 86 }; 87 88 void OnStreamReady(int rv); 89 void OnIOComplete(int rv); 90 void DoCallback(int rv); 91 92 int DoLoop(int); 93 int DoSendHeaders(); 94 int DoSendHeadersComplete(int rv); 95 int DoReadRequestBody(); 96 int DoReadRequestBodyComplete(int rv); 97 int DoSendBody(); 98 int DoSendBodyComplete(int rv); 99 int DoReadResponseHeaders(); 100 int DoReadResponseHeadersComplete(int rv); 101 102 int ParseResponseHeaders(); 103 104 void BufferResponseBody(const char* data, int length); 105 106 State next_state_; 107 108 base::WeakPtr<QuicClientSession> session_; 109 int session_error_; // Error code from the connection shutdown. 110 bool was_handshake_confirmed_; // True if the crypto handshake succeeded. 111 QuicClientSession::StreamRequest stream_request_; 112 QuicReliableClientStream* stream_; // Non-owning. 113 114 // The following three fields are all owned by the caller and must 115 // outlive this object, according to the HttpStream contract. 116 117 // The request to send. 118 const HttpRequestInfo* request_info_; 119 // The request body to send, if any, owned by the caller. 120 UploadDataStream* request_body_stream_; 121 // Time the request was issued. 122 base::Time request_time_; 123 // The priority of the request. 124 RequestPriority priority_; 125 // |response_info_| is the HTTP response data object which is filled in 126 // when a the response headers are read. It is not owned by this stream. 127 HttpResponseInfo* response_info_; 128 // Because response data is buffered, also buffer the response status if the 129 // stream is explicitly closed via OnError or OnClose with an error. 130 // Once all buffered data has been returned, this will be used as the final 131 // response. 132 int response_status_; 133 134 // Serialized request headers. 135 SpdyHeaderBlock request_headers_; 136 137 bool response_headers_received_; 138 139 // Serialized HTTP request. 140 std::string request_; 141 142 // Buffer into which response header data is read. 143 scoped_refptr<GrowableIOBuffer> read_buf_; 144 145 // We buffer the response body as it arrives asynchronously from the stream. 146 // TODO(rch): This is infinite buffering, which is bad. 147 std::list<scoped_refptr<IOBufferWithSize> > response_body_; 148 149 // Number of bytes received when the stream was closed. 150 int64 closed_stream_received_bytes_; 151 152 // The caller's callback to be used for asynchronous operations. 153 CompletionCallback callback_; 154 155 // Caller provided buffer for the ReadResponseBody() response. 156 scoped_refptr<IOBuffer> user_buffer_; 157 int user_buffer_len_; 158 159 // Temporary buffer used to read the request body from UploadDataStream. 160 scoped_refptr<IOBufferWithSize> raw_request_body_buf_; 161 // Wraps raw_request_body_buf_ to read the remaining data progressively. 162 scoped_refptr<DrainableIOBuffer> request_body_buf_; 163 164 BoundNetLog stream_net_log_; 165 166 base::WeakPtrFactory<QuicHttpStream> weak_factory_; 167 168 DISALLOW_COPY_AND_ASSIGN(QuicHttpStream); 169 }; 170 171 } // namespace net 172 173 #endif // NET_QUIC_QUIC_HTTP_STREAM_H_ 174