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 const HttpResponseInfo* GetResponseInfo() const OVERRIDE; 45 virtual int ReadResponseBody(IOBuffer* buf, 46 int buf_len, 47 const CompletionCallback& callback) OVERRIDE; 48 virtual void Close(bool not_reusable) OVERRIDE; 49 virtual HttpStream* RenewStreamForAuth() OVERRIDE; 50 virtual bool IsResponseBodyComplete() const OVERRIDE; 51 virtual bool CanFindEndOfResponse() const OVERRIDE; 52 virtual bool IsConnectionReused() const OVERRIDE; 53 virtual void SetConnectionReused() OVERRIDE; 54 virtual bool IsConnectionReusable() const OVERRIDE; 55 virtual int64 GetTotalReceivedBytes() const OVERRIDE; 56 virtual bool GetLoadTimingInfo( 57 LoadTimingInfo* load_timing_info) const OVERRIDE; 58 virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE; 59 virtual void GetSSLCertRequestInfo( 60 SSLCertRequestInfo* cert_request_info) OVERRIDE; 61 virtual bool IsSpdyHttpStream() const OVERRIDE; 62 virtual void Drain(HttpNetworkSession* session) OVERRIDE; 63 virtual void SetPriority(RequestPriority priority) OVERRIDE; 64 65 // QuicReliableClientStream::Delegate implementation 66 virtual int OnDataReceived(const char* data, int length) OVERRIDE; 67 virtual void OnClose(QuicErrorCode error) OVERRIDE; 68 virtual void OnError(int error) OVERRIDE; 69 virtual bool HasSendHeadersComplete() OVERRIDE; 70 71 // QuicClientSession::Observer implementation 72 virtual void OnCryptoHandshakeConfirmed() OVERRIDE; 73 virtual void OnSessionClosed(int error) OVERRIDE; 74 75 private: 76 friend class test::QuicHttpStreamPeer; 77 78 enum State { 79 STATE_NONE, 80 STATE_SEND_HEADERS, 81 STATE_SEND_HEADERS_COMPLETE, 82 STATE_READ_REQUEST_BODY, 83 STATE_READ_REQUEST_BODY_COMPLETE, 84 STATE_SEND_BODY, 85 STATE_SEND_BODY_COMPLETE, 86 STATE_OPEN, 87 }; 88 89 void OnStreamReady(int rv); 90 void OnIOComplete(int rv); 91 void DoCallback(int rv); 92 93 int DoLoop(int); 94 int DoSendHeaders(); 95 int DoSendHeadersComplete(int rv); 96 int DoReadRequestBody(); 97 int DoReadRequestBodyComplete(int rv); 98 int DoSendBody(); 99 int DoSendBodyComplete(int rv); 100 int DoReadResponseHeaders(); 101 int DoReadResponseHeadersComplete(int rv); 102 103 int ParseResponseHeaders(); 104 105 void BufferResponseBody(const char* data, int length); 106 107 State next_state_; 108 109 base::WeakPtr<QuicClientSession> session_; 110 int session_error_; // Error code from the connection shutdown. 111 bool was_handshake_confirmed_; // True if the crypto handshake succeeded. 112 QuicClientSession::StreamRequest stream_request_; 113 QuicReliableClientStream* stream_; // Non-owning. 114 115 // The following three fields are all owned by the caller and must 116 // outlive this object, according to the HttpStream contract. 117 118 // The request to send. 119 const HttpRequestInfo* request_info_; 120 // The request body to send, if any, owned by the caller. 121 UploadDataStream* request_body_stream_; 122 // The priority of the request. 123 RequestPriority priority_; 124 // |response_info_| is the HTTP response data object which is filled in 125 // when a the response headers are read. It is not owned by this stream. 126 HttpResponseInfo* response_info_; 127 // Because response data is buffered, also buffer the response status if the 128 // stream is explicitly closed via OnError or OnClose with an error. 129 // Once all buffered data has been returned, this will be used as the final 130 // response. 131 int response_status_; 132 133 // Serialized request headers. 134 SpdyHeaderBlock request_headers_; 135 136 bool response_headers_received_; 137 138 // Serialized HTTP request. 139 std::string request_; 140 141 // Buffer into which response header data is read. 142 scoped_refptr<GrowableIOBuffer> read_buf_; 143 144 // We buffer the response body as it arrives asynchronously from the stream. 145 // TODO(rch): This is infinite buffering, which is bad. 146 std::list<scoped_refptr<IOBufferWithSize> > response_body_; 147 148 // The caller's callback to be used for asynchronous operations. 149 CompletionCallback callback_; 150 151 // Caller provided buffer for the ReadResponseBody() response. 152 scoped_refptr<IOBuffer> user_buffer_; 153 int user_buffer_len_; 154 155 // Temporary buffer used to read the request body from UploadDataStream. 156 scoped_refptr<IOBufferWithSize> raw_request_body_buf_; 157 // Wraps raw_request_body_buf_ to read the remaining data progressively. 158 scoped_refptr<DrainableIOBuffer> request_body_buf_; 159 160 BoundNetLog stream_net_log_; 161 162 base::WeakPtrFactory<QuicHttpStream> weak_factory_; 163 }; 164 165 } // namespace net 166 167 #endif // NET_QUIC_QUIC_HTTP_STREAM_H_ 168