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   virtual ~QuicHeadersStream();
  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       QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
  35
  36   // ReliableQuicStream implementation
  37   virtual uint32 ProcessRawData(const char* data, uint32 data_len) OVERRIDE;
  38   virtual QuicPriority EffectivePriority() const OVERRIDE;
  39
  40  private:
  41   class SpdyFramerVisitor;
  42
  43   // The following methods are called by the SimpleVisitor.
  44
  45   // Called when a SYN_STREAM frame has been received.
  46   void OnSynStream(SpdyStreamId stream_id,
  47                    SpdyPriority priority,
  48                    bool fin);
  49
  50   // Called when a SYN_REPLY frame been received.
  51   void OnSynReply(SpdyStreamId stream_id, bool fin);
  52
  53   // Called when a chunk of header data is available. This is called
  54   // after OnSynStream, or OnSynReply.
  55   // |stream_id| The stream receiving the header data.
  56   // |header_data| A buffer containing the header data chunk received.
  57   // |len| The length of the header data buffer. A length of zero indicates
  58   //       that the header data block has been completely sent.
  59   void OnControlFrameHeaderData(SpdyStreamId stream_id,
  60                                 const char* header_data,
  61                                 size_t len);
  62
  63   // Called when the size of the compressed frame payload is available.
  64   void OnCompressedFrameSize(size_t frame_len);
  65
  66   // Returns true if the session is still connected.
  67   bool IsConnected();
  68
  69   // Data about the stream whose headers are being processed.
  70   QuicStreamId stream_id_;
  71   bool fin_;
  72   size_t frame_len_;
  73
  74   SpdyFramer spdy_framer_;
  75   scoped_ptr<SpdyFramerVisitor> spdy_framer_visitor_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(QuicHeadersStream);
  78 };
  79
  80 }  // namespace net
  81
  82 #endif  // NET_QUIC_QUIC_HEADERS_STREAM_H_