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
16namespace net {
17
18namespace test {
19class 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.
25class 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