Home | History | Annotate | Download | only in spdy 
      1 // Copyright (c) 2011 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_SPDY_SPDY_HTTP_STREAM_H_
      6 #define NET_SPDY_SPDY_HTTP_STREAM_H_
      7 #pragma once
      8 
      9 #include <list>
     10 #include <string>
     11 
     12 #include "base/basictypes.h"
     13 #include "base/memory/ref_counted.h"
     14 #include "base/task.h"
     15 #include "net/base/completion_callback.h"
     16 #include "net/base/net_log.h"
     17 #include "net/http/http_request_info.h"
     18 #include "net/http/http_stream.h"
     19 #include "net/spdy/spdy_protocol.h"
     20 #include "net/spdy/spdy_session.h"
     21 #include "net/spdy/spdy_stream.h"
     22 
     23 namespace net {
     24 
     25 class HttpResponseInfo;
     26 class IOBuffer;
     27 class SpdySession;
     28 class UploadData;
     29 class UploadDataStream;
     30 
     31 // The SpdyHttpStream is a HTTP-specific type of stream known to a SpdySession.
     32 class SpdyHttpStream : public SpdyStream::Delegate, public HttpStream {
     33  public:
     34   SpdyHttpStream(SpdySession* spdy_session, bool direct);
     35   virtual ~SpdyHttpStream();
     36 
     37   // Initializes this SpdyHttpStream by wraping an existing SpdyStream.
     38   void InitializeWithExistingStream(SpdyStream* spdy_stream);
     39 
     40   SpdyStream* stream() { return stream_.get(); }
     41 
     42   // Cancels any callbacks from being invoked and deletes the stream.
     43   void Cancel();
     44 
     45   // HttpStream methods:
     46   virtual int InitializeStream(const HttpRequestInfo* request_info,
     47                                const BoundNetLog& net_log,
     48                                CompletionCallback* callback) OVERRIDE;
     49   virtual int SendRequest(const HttpRequestHeaders& headers,
     50                           UploadDataStream* request_body,
     51                           HttpResponseInfo* response,
     52                           CompletionCallback* callback) OVERRIDE;
     53   virtual uint64 GetUploadProgress() const OVERRIDE;
     54   virtual int ReadResponseHeaders(CompletionCallback* callback) OVERRIDE;
     55   virtual const HttpResponseInfo* GetResponseInfo() const;
     56   virtual int ReadResponseBody(IOBuffer* buf,
     57                                int buf_len,
     58                                CompletionCallback* callback) OVERRIDE;
     59   virtual void Close(bool not_reusable) OVERRIDE;
     60   virtual HttpStream* RenewStreamForAuth() OVERRIDE;
     61   virtual bool IsResponseBodyComplete() const OVERRIDE;
     62   virtual bool CanFindEndOfResponse() const OVERRIDE;
     63   virtual bool IsMoreDataBuffered() const OVERRIDE;
     64   virtual bool IsConnectionReused() const OVERRIDE;
     65   virtual void SetConnectionReused() OVERRIDE;
     66   virtual bool IsConnectionReusable() const OVERRIDE;
     67   virtual void GetSSLInfo(SSLInfo* ssl_info) OVERRIDE;
     68   virtual void GetSSLCertRequestInfo(
     69       SSLCertRequestInfo* cert_request_info) OVERRIDE;
     70   virtual bool IsSpdyHttpStream() const OVERRIDE;
     71 
     72   // SpdyStream::Delegate methods:
     73   virtual bool OnSendHeadersComplete(int status) OVERRIDE;
     74   virtual int OnSendBody() OVERRIDE;
     75   virtual int OnSendBodyComplete(int status, bool* eof) OVERRIDE;
     76   virtual int OnResponseReceived(const spdy::SpdyHeaderBlock& response,
     77                                  base::Time response_time,
     78                                  int status) OVERRIDE;
     79   virtual void OnDataReceived(const char* buffer, int bytes) OVERRIDE;
     80   virtual void OnDataSent(int length) OVERRIDE;
     81   virtual void OnClose(int status) OVERRIDE;
     82   virtual void set_chunk_callback(ChunkCallback* callback) OVERRIDE;
     83 
     84  private:
     85   FRIEND_TEST_ALL_PREFIXES(SpdyNetworkTransactionTest, FlowControlStallResume);
     86 
     87   // Call the user callback.
     88   void DoCallback(int rv);
     89 
     90   void ScheduleBufferedReadCallback();
     91 
     92   // Returns true if the callback is invoked.
     93   bool DoBufferedReadCallback();
     94   bool ShouldWaitForMoreBufferedData() const;
     95 
     96   ScopedRunnableMethodFactory<SpdyHttpStream> read_callback_factory_;
     97   scoped_refptr<SpdyStream> stream_;
     98   scoped_refptr<SpdySession> spdy_session_;
     99 
    100   // The request to send.
    101   const HttpRequestInfo* request_info_;
    102 
    103   scoped_ptr<UploadDataStream> request_body_stream_;
    104 
    105   // |response_info_| is the HTTP response data object which is filled in
    106   // when a SYN_REPLY comes in for the stream.
    107   // It is not owned by this stream object, or point to |push_response_info_|.
    108   HttpResponseInfo* response_info_;
    109 
    110   scoped_ptr<HttpResponseInfo> push_response_info_;
    111 
    112   bool download_finished_;
    113   bool response_headers_received_;  // Indicates waiting for more HEADERS.
    114 
    115   // We buffer the response body as it arrives asynchronously from the stream.
    116   // TODO(mbelshe):  is this infinite buffering?
    117   std::list<scoped_refptr<IOBufferWithSize> > response_body_;
    118 
    119   CompletionCallback* user_callback_;
    120 
    121   // User provided buffer for the ReadResponseBody() response.
    122   scoped_refptr<IOBuffer> user_buffer_;
    123   int user_buffer_len_;
    124 
    125   // Is there a scheduled read callback pending.
    126   bool buffered_read_callback_pending_;
    127   // Has more data been received from the network during the wait for the
    128   // scheduled read callback.
    129   bool more_read_data_pending_;
    130 
    131   // Is this spdy stream direct to the origin server (or to a proxy).
    132   bool direct_;
    133 
    134   bool send_last_chunk_;
    135 
    136   DISALLOW_COPY_AND_ASSIGN(SpdyHttpStream);
    137 };
    138 
    139 }  // namespace net
    140 
    141 #endif  // NET_SPDY_SPDY_HTTP_STREAM_H_
    142