src/net/quic/quic_http_stream.h

   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   // Number of bytes received when the stream was closed.
 149   int64 closed_stream_received_bytes_;
 150
 151   // The caller's callback to be used for asynchronous operations.
 152   CompletionCallback callback_;
 153
 154   // Caller provided buffer for the ReadResponseBody() response.
 155   scoped_refptr<IOBuffer> user_buffer_;
 156   int user_buffer_len_;
 157
 158   // Temporary buffer used to read the request body from UploadDataStream.
 159   scoped_refptr<IOBufferWithSize> raw_request_body_buf_;
 160   // Wraps raw_request_body_buf_ to read the remaining data progressively.
 161   scoped_refptr<DrainableIOBuffer> request_body_buf_;
 162
 163   BoundNetLog stream_net_log_;
 164
 165   base::WeakPtrFactory<QuicHttpStream> weak_factory_;
 166
 167   DISALLOW_COPY_AND_ASSIGN(QuicHttpStream);
 168 };
 169
 170 }  // namespace net
 171
 172 #endif  // NET_QUIC_QUIC_HTTP_STREAM_H_