1 // Copyright (c) 2012 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.
5 #ifndef NET_QUIC_QUIC_STREAM_SEQUENCER_H_
6 #define NET_QUIC_QUIC_STREAM_SEQUENCER_H_
10 #include "base/basictypes.h"
11 #include "net/base/iovec.h"
12 #include "net/quic/quic_protocol.h"
20 class QuicStreamSequencerPeer;
24 class ReliableQuicStream;
26 // Buffers frames until we have something which can be passed
27 // up to the next layer.
28 // TOOD(alyssar) add some checks for overflow attempts [1, 256,] [2, 256]
29 class NET_EXPORT_PRIVATE QuicStreamSequencer {
31 explicit QuicStreamSequencer(ReliableQuicStream* quic_stream);
32 virtual ~QuicStreamSequencer();
34 // If the frame is the next one we need in order to process in-order data,
35 // ProcessData will be immediately called on the stream until all buffered
36 // data is processed or the stream fails to consume data. Any unconsumed
37 // data will be buffered. If the frame is not the next in line, it will be
39 bool OnStreamFrame(const QuicStreamFrame& frame);
41 // Once data is buffered, it's up to the stream to read it when the stream
42 // can handle more data. The following three functions make that possible.
44 // Fills in up to iov_len iovecs with the next readable regions. Returns the
45 // number of iovs used. Non-destructive of the underlying data.
46 int GetReadableRegions(iovec* iov, size_t iov_len);
48 // Copies the data into the iov_len buffers provided. Returns the number of
49 // bytes read. Any buffered data no longer in use will be released.
50 int Readv(const struct iovec* iov, size_t iov_len);
52 // Returns true if the sequncer has bytes available for reading.
53 bool HasBytesToRead() const;
55 // Returns true if the sequencer has delivered the fin.
56 bool IsClosed() const;
58 // Returns true if the sequencer has received this frame before.
59 bool IsDuplicate(const QuicStreamFrame& frame) const;
61 // Calls |ProcessRawData| on |stream_| for each buffered frame that may
63 void FlushBufferedFrames();
65 // Blocks processing of frames until |FlushBufferedFrames| is called.
66 void SetBlockedUntilFlush();
68 size_t num_bytes_buffered() const { return num_bytes_buffered_; }
69 QuicStreamOffset num_bytes_consumed() const { return num_bytes_consumed_; }
71 int num_frames_received() const { return num_frames_received_; }
73 int num_duplicate_frames_received() const {
74 return num_duplicate_frames_received_;
78 friend class test::QuicStreamSequencerPeer;
80 // Wait until we've seen 'offset' bytes, and then terminate the stream.
81 void CloseStreamAtOffset(QuicStreamOffset offset);
83 // If we've received a FIN and have processed all remaining data, then inform
84 // the stream of FIN, and clear buffers.
85 bool MaybeCloseStream();
87 // Called whenever bytes are consumed by the stream. Updates
88 // num_bytes_consumed_ and num_bytes_buffered_.
89 void RecordBytesConsumed(size_t bytes_consumed);
91 // The stream which owns this sequencer.
92 ReliableQuicStream* stream_;
94 // The last data consumed by the stream.
95 QuicStreamOffset num_bytes_consumed_;
97 // TODO(alyssar) use something better than strings.
98 typedef map<QuicStreamOffset, string> FrameMap;
100 // Stores buffered frames (maps from sequence number -> frame data as string).
103 // The offset, if any, we got a stream termination for. When this many bytes
104 // have been processed, the sequencer will be closed.
105 QuicStreamOffset close_offset_;
107 // If true, the sequencer is blocked from passing data to the stream and will
108 // buffer all new incoming data until FlushBufferedFrames is called.
111 // Tracks how many bytes the sequencer has buffered.
112 size_t num_bytes_buffered_;
114 // Count of the number of frames received.
115 int num_frames_received_;
117 // Count of the number of duplicate frames received.
118 int num_duplicate_frames_received_;
120 DISALLOW_COPY_AND_ASSIGN(QuicStreamSequencer);
125 #endif // NET_QUIC_QUIC_STREAM_SEQUENCER_H_