Home | History | Annotate | Download | only in quic 
      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