net/quic/quic_headers_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 #ifndef NET_QUIC_QUIC_HEADERS_STREAM_H_
   6 #define NET_QUIC_QUIC_HEADERS_STREAM_H_
   7
   8 #include "base/basictypes.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "net/base/net_export.h"
  11 #include "net/quic/quic_protocol.h"
  12 #include "net/quic/reliable_quic_stream.h"
  13 #include "net/spdy/spdy_framer.h"
  14
  15 namespace net {
  16
  17 // Headers in QUIC are sent as SPDY SYN_STREAM or SYN_REPLY frames
  18 // over a reserved reliable stream with the id 2.  Each endpoint (client
  19 // and server) will allocate an instance of QuicHeadersStream to send
  20 // and receive headers.
  21 class NET_EXPORT_PRIVATE QuicHeadersStream : public ReliableQuicStream {
  22  public:
  23   explicit QuicHeadersStream(QuicSession* session);
  24   ~QuicHeadersStream() override;
  25
  26   // Writes |headers| for |stream_id| in a SYN_STREAM or SYN_REPLY
  27   // frame to the peer.  If |fin| is true, the fin flag will be set on
  28   // the SPDY frame.  Returns the size, in bytes, of the resulting
  29   // SPDY frame.
  30   size_t WriteHeaders(
  31       QuicStreamId stream_id,
  32       const SpdyHeaderBlock& headers,
  33       bool fin,
  34       QuicPriority priority,
  35       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
  36
  37   // ReliableQuicStream implementation
  38   uint32 ProcessRawData(const char* data, uint32 data_len) override;
  39   QuicPriority EffectivePriority() const override;
  40
  41  private:
  42   class SpdyFramerVisitor;
  43
  44   // The following methods are called by the SimpleVisitor.
  45
  46   // Called when a SYN_STREAM frame has been received.
  47   void OnSynStream(SpdyStreamId stream_id,
  48                    SpdyPriority priority,
  49                    bool fin);
  50
  51   // Called when a SYN_REPLY frame been received.
  52   void OnSynReply(SpdyStreamId stream_id, bool fin);
  53
  54   // Called when a chunk of header data is available. This is called
  55   // after OnSynStream, or OnSynReply.
  56   // |stream_id| The stream receiving the header data.
  57   // |header_data| A buffer containing the header data chunk received.
  58   // |len| The length of the header data buffer. A length of zero indicates
  59   //       that the header data block has been completely sent.
  60   void OnControlFrameHeaderData(SpdyStreamId stream_id,
  61                                 const char* header_data,
  62                                 size_t len);
  63
  64   // Called when the size of the compressed frame payload is available.
  65   void OnCompressedFrameSize(size_t frame_len);
  66
  67   // Returns true if the session is still connected.
  68   bool IsConnected();
  69
  70   // Data about the stream whose headers are being processed.
  71   QuicStreamId stream_id_;
  72   bool fin_;
  73   size_t frame_len_;
  74
  75   SpdyFramer spdy_framer_;
  76   scoped_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
  77
  78   DISALLOW_COPY_AND_ASSIGN(QuicHeadersStream);
  79 };
  80
  81 }  // namespace net
  82
  83 #endif  // NET_QUIC_QUIC_HEADERS_STREAM_H_