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