1 files changed, 102 insertions, 0 deletions
diff --git a/chromium/net/quic/quic_stream_sequencer.h b/chromium/net/quic/quic_stream_sequencer.h
new file mode 100644
index 00000000000..fe9fba56830
--- /dev/null
+++ b/chromium/net/quic/quic_stream_sequencer.h
@@ -0,0 +1,102 @@
+// 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/base/iovec.h"
+#include "net/quic/quic_protocol.h"
+
+using std::map;
+using std::string;
+
+namespace net {
+
+namespace test {
+class QuicStreamSequencerPeer;
+}  // namespace test
+
+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);
+
+  // 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.
+
+  // Fills in up to iov_len iovecs with the next readable regions.  Returns the
+  // number of iovs used.  Non-destructive of the underlying data.
+  int GetReadableRegions(iovec* iov, size_t iov_len);
+
+  // Copies the data into the iov_len buffers provided.  Returns the number of
+  // bytes read.  Any buffered data no longer in use will be released.
+  int Readv(const struct iovec* iov, size_t iov_len);
+
+  // Consumes |num_bytes| data.  Used in conjunction with |GetReadableRegions|
+  // to do zero-copy reads.
+  void MarkConsumed(size_t num_bytes);
+
+  // Returns true if the sequncer has bytes available for reading.
+  bool HasBytesToRead() const;
+
+  // Returns true if the sequencer has delivered a half close.
+  bool IsHalfClosed() const;
+
+  // Returns true if the sequencer has received this frame before.
+  bool IsDuplicate(const QuicStreamFrame& frame) const;
+
+  // Calls |ProcessRawData| on |stream_| for each buffered frame that may
+  // be processed.
+  void FlushBufferedFrames();
+
+ private:
+  friend class test::QuicStreamSequencerPeer;
+
+  // TODO(alyssar) use something better than strings.
+  typedef map<QuicStreamOffset, string> FrameMap;
+
+  // Wait until we've seen 'offset' bytes, and then terminate the stream.
+  void CloseStreamAtOffset(QuicStreamOffset offset);
+
+  bool MaybeCloseStream();
+
+  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 termination for.  When this many bytes
+  // have been processed, the stream will be half closed.
+  QuicStreamOffset close_offset_;
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_QUIC_STREAM_SEQUENCER_H_