net/quic/quic_data_stream.h

   1 // Copyright 2013 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 // The base class for streams which deliver data to/from an application.
   6 // In each direction, the data on such a stream first contains compressed
   7 // headers then body data.
   8
   9 #ifndef NET_QUIC_QUIC_DATA_STREAM_H_
  10 #define NET_QUIC_QUIC_DATA_STREAM_H_
  11
  12 #include <sys/types.h>
  13
  14 #include <list>
  15 #include <string>
  16
  17 #include "base/basictypes.h"
  18 #include "base/strings/string_piece.h"
  19 #include "net/base/iovec.h"
  20 #include "net/base/ip_endpoint.h"
  21 #include "net/base/net_export.h"
  22 #include "net/quic/quic_ack_notifier.h"
  23 #include "net/quic/quic_protocol.h"
  24 #include "net/quic/quic_stream_sequencer.h"
  25 #include "net/quic/reliable_quic_stream.h"
  26 #include "net/spdy/spdy_framer.h"
  27
  28 namespace net {
  29
  30 namespace test {
  31 class QuicDataStreamPeer;
  32 class ReliableQuicStreamPeer;
  33 }  // namespace test
  34
  35 class QuicSpdySession;
  36
  37 // A QUIC data stream that can also send and receive headers.
  38 class NET_EXPORT_PRIVATE QuicDataStream : public ReliableQuicStream {
  39  public:
  40   // Visitor receives callbacks from the stream.
  41   class NET_EXPORT_PRIVATE Visitor {
  42    public:
  43     Visitor() {}
  44
  45     // Called when the stream is closed.
  46     virtual void OnClose(QuicDataStream* stream) = 0;
  47
  48    protected:
  49     virtual ~Visitor() {}
  50
  51    private:
  52     DISALLOW_COPY_AND_ASSIGN(Visitor);
  53   };
  54
  55   QuicDataStream(QuicStreamId id, QuicSpdySession* spdy_session);
  56   ~QuicDataStream() override;
  57
  58   // ReliableQuicStream implementation
  59   void OnClose() override;
  60   uint32 ProcessRawData(const char* data, uint32 data_len) override;
  61
  62   // By default, this is the same as priority(), however it allows streams
  63   // to temporarily alter effective priority.   For example if a SPDY stream has
  64   // compressed but not written headers it can write the headers with a higher
  65   // priority.
  66   QuicPriority EffectivePriority() const override;
  67
  68   // Overridden by subclasses to process data.  The headers will be delivered
  69   // via OnStreamHeaders, so only data will be delivered through this method.
  70   virtual uint32 ProcessData(const char* data, uint32 data_len) = 0;
  71
  72   // Called by the session when decompressed headers data is received
  73   // for this stream.
  74   // May be called multiple times, with each call providing additional headers
  75   // data until OnStreamHeadersComplete is called.
  76   virtual void OnStreamHeaders(base::StringPiece headers_data);
  77
  78   // Called by the session when headers with a priority have been received
  79   // for this stream.  This method will only be called for server streams.
  80   virtual void OnStreamHeadersPriority(QuicPriority priority);
  81
  82   // Called by the session when decompressed headers have been completely
  83   // delilvered to this stream.  If |fin| is true, then this stream
  84   // should be closed; no more data will be sent by the peer.
  85   virtual void OnStreamHeadersComplete(bool fin, size_t frame_len);
  86
  87   // Writes the headers contained in |header_block| to the dedicated
  88   // headers stream.
  89   virtual size_t WriteHeaders(
  90       const SpdyHeaderBlock& header_block,
  91       bool fin,
  92       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
  93
  94   // Marks |bytes_consumed| of the headers data as consumed.
  95   void MarkHeadersConsumed(size_t bytes_consumed);
  96
  97   // This block of functions wraps the sequencer's functions of the same
  98   // name.  These methods return uncompressed data until that has
  99   // been fully processed.  Then they simply delegate to the sequencer.
 100   virtual size_t Readv(const struct iovec* iov, size_t iov_len);
 101   virtual int GetReadableRegions(iovec* iov, size_t iov_len) const;
 102   void MarkConsumed(size_t num_bytes);
 103
 104   // Returns true when all data has been read from the peer, including the fin.
 105   bool IsDoneReading() const;
 106   bool HasBytesToRead() const;
 107
 108   void set_visitor(Visitor* visitor) { visitor_ = visitor; }
 109
 110   bool headers_decompressed() const { return headers_decompressed_; }
 111
 112   const std::string& decompressed_headers() const {
 113     return decompressed_headers_;
 114   }
 115
 116  protected:
 117   // Sets priority_ to priority.  This should only be called before bytes are
 118   // written to the server.
 119   void set_priority(QuicPriority priority);
 120   // This is protected because external classes should use EffectivePriority
 121   // instead.
 122   QuicPriority priority() const { return priority_; }
 123
 124   bool FinishedReadingHeaders() const;
 125
 126  private:
 127   friend class test::QuicDataStreamPeer;
 128   friend class test::ReliableQuicStreamPeer;
 129   friend class QuicStreamUtils;
 130
 131   QuicSpdySession* spdy_session_;
 132
 133   Visitor* visitor_;
 134   // True if the headers have been completely decompressed.
 135   bool headers_decompressed_;
 136   // The priority of the stream, once parsed.
 137   QuicPriority priority_;
 138   // Contains a copy of the decompressed headers until they are consumed
 139   // via ProcessData or Readv.
 140   std::string decompressed_headers_;
 141
 142   DISALLOW_COPY_AND_ASSIGN(QuicDataStream);
 143 };
 144
 145 }  // namespace net
 146
 147 #endif  // NET_QUIC_QUIC_DATA_STREAM_H_