Index: net/quic/quic_stream_sequencer.h |
diff --git a/net/quic/quic_stream_sequencer.h b/net/quic/quic_stream_sequencer.h |
new file mode 100644 |
index 0000000000000000000000000000000000000000..971aaec9e3260a25b703a8da5beef1ac861ab134 |
--- /dev/null |
+++ b/net/quic/quic_stream_sequencer.h |
@@ -0,0 +1,90 @@ |
+// Copyright (c) 2012 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#ifndef NET_QUIC_QUIC_STREAM_SEQUENCER_H_ |
+#define NET_QUIC_QUIC_STREAM_SEQUENCER_H_ |
+ |
+#include <map> |
+ |
+#include "base/basictypes.h" |
+#include "base/memory/scoped_ptr.h" |
+#include "net/quic/quic_protocol.h" |
+ |
+using std::map; |
+using std::string; |
+ |
+namespace net { |
+ |
+class QuicSession; |
+class ReliableQuicStream; |
+ |
+// Buffers frames until we have something which can be passed |
+// up to the next layer. |
+// TOOD(alyssar) add some checks for overflow attempts [1, 256,] [2, 256] |
+class NET_EXPORT_PRIVATE QuicStreamSequencer { |
+ public: |
+ static size_t kMaxUdpPacketSize; |
+ |
+ explicit QuicStreamSequencer(ReliableQuicStream* quic_stream); |
+ QuicStreamSequencer(size_t max_frame_memory, |
+ ReliableQuicStream* quic_stream); |
+ |
+ virtual ~QuicStreamSequencer(); |
+ |
+ // Returns the expected value of OnStreamFrame for this frame. |
+ bool WillAcceptStreamFrame(const QuicStreamFrame& frame) const; |
+ |
+ // If the frame is the next one we need in order to process in-order data, |
+ // ProcessData will be immediately called on the stream until all buffered |
+ // data is processed or the stream fails to consume data. Any unconsumed |
+ // data will be buffered. |
+ // |
+ // If the frame is not the next in line, it will either be buffered, and |
+ // this will return true, or it will be rejected and this will return false. |
+ bool OnStreamFrame(const QuicStreamFrame& frame); |
+ |
+ // Wait until we've seen 'offset' bytes, and then terminate the stream. |
+ void CloseStreamAtOffset(QuicStreamOffset offset, bool half_close); |
+ |
+ // Once data is buffered, it's up to the stream to read it when the stream |
+ // can handle more data. The following three functions make that possible. |
+ |
+ // Advances the readable pointer num_bytes bytes, releasing any buffered data |
+ // which is no longer in uses |
+ void AdvanceReadablePtr(size_t num_bytes); |
+ |
+ // Returns true if the sequncer has bytes available for reading. |
+ bool HasBytesToRead(); |
+ |
+ // Returns true if the sequencer has delivered a half close. |
+ bool IsHalfClosed(); |
+ |
+ // Returns true if the sequencer has delivered a full close. |
+ bool IsClosed(); |
+ |
+ private: |
+ bool MaybeCloseStream(); |
+ |
+ friend class QuicStreamSequencerPeer; |
+ // TODO(alyssar) use something better than strings. |
+ typedef map<QuicStreamOffset, string> FrameMap; |
+ |
+ void FlushBufferedFrames(); |
+ |
+ ReliableQuicStream* stream_; // The stream which owns this sequencer. |
+ QuicStreamOffset num_bytes_consumed_; // The last data consumed by the stream |
+ FrameMap frames_; // sequence number -> frame |
+ size_t max_frame_memory_; // the maximum memory the sequencer can buffer. |
+ // The offset, if any, we got a stream cancelation for. When this many bytes |
+ // have been processed, the stream will be half or full closed depending on |
+ // the half_close_ bool. |
+ QuicStreamOffset close_offset_; |
+ // Only valid if close_offset_ is set. Indicates if it's a half or a full |
+ // close. |
+ bool half_close_; |
+}; |
+ |
+} // namespace net |
+ |
+#endif // NET_QUIC_QUIC_STREAM_SEQUENCER_H_ |