Add QuicStream and friends to QUIC code.

net/quic/reliable_quic_stream.h

Index: net/quic/reliable_quic_stream.h
diff --git a/net/quic/reliable_quic_stream.h b/net/quic/reliable_quic_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea16a97d1a0ce59ecdda91860516866201ea1ff1
--- /dev/null
+++ b/net/quic/reliable_quic_stream.h
@@ -0,0 +1,81 @@
+// 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.
+//
+// The base class for client/server reliable streams.
+
+#ifndef NET_QUIC_RELIABLE_QUIC_STREAM_H_
+#define NET_QUIC_RELIABLE_QUIC_STREAM_H_
+
+#include "net/quic/quic_stream_sequencer.h"
+
+namespace net {
+
+class QuicSession;
+
+// All this does right now is send data to subclasses via the sequencer.
+class ReliableQuicStream {
+ public:
+  ReliableQuicStream(QuicStreamId id,
+                     QuicSession* session);
+
+  virtual ~ReliableQuicStream();
+
+  bool WillAcceptStreamFrame(const QuicStreamFrame& frame) const;
+  bool OnStreamFrame(const QuicStreamFrame& frame);
+
+  // Called when we get a stream reset from the client.
+  // The rst will be passed through the sequencer, which will call
+  // TerminateFromPeer when 'offset' bytes have been processed.
+  void OnStreamReset(QuicErrorCode error, QuicStreamOffset ofset);
+
+  // Called when we get or send a connection close, and should immediately
+  // close the stream.  This is not passed through the sequencer,
+  // but is handled immediately.
+  virtual void ConnectionClose(QuicErrorCode error, bool from_peer);
+
+  // Called by the sequencer, when we should process a stream termination or
+  // stream close from the peer.
+  virtual void TerminateFromPeer(bool half_close);
+
+  virtual uint32 ProcessData(const char* data, uint32 data_len) = 0;
+
+  // Called to close the stream from this end.
+  virtual void Close(QuicErrorCode error);
+
+  // This block of functions wraps the sequencer's functions of the same
+  // name.
+  virtual int Readv(const struct iovec* iov, int iov_len);
+  virtual bool IsHalfClosed();
+  virtual bool HasBytesToRead();

[jar (doing other things), 2012/11/01 22:21:10]

nit: both above are probably const methods.

[Ryan Hamilton, 2012/11/01 22:52:20]

Fixed upstream.

+
+  QuicStreamId id() { return id_; }
+
+  QuicErrorCode error() { return error_; }
+
+ protected:
+  virtual ssize_t WriteData(base::StringPiece data, bool fin);
+  // Close the read side of the socket.  Further frames will not be accepted.
+  virtual void CloseReadSide();
+  // Close the write side of the socket.  Further writes will fail.
+  void CloseWriteSide();
+
+  QuicSession* session() { return session_; }

[jar (doing other things), 2012/11/01 22:21:10]

nit: const method

[Ryan Hamilton, 2012/11/01 22:52:20]

It's gauche to return mutable pointers to members in a const method.  IIRC,
there was a recent thread about this on chromium-dev.

+
+ private:
+  friend class ReliableQuicStreamPeer;
+
+  QuicStreamSequencer sequencer_;
+  QuicStreamId id_;
+  QuicStreamOffset offset_;
+  QuicSession* session_;
+  QuicErrorCode error_;
+  // True if the read side is closed and further frames should be rejected.
+  bool read_side_closed_;
+  // True if the write side is closed, and further writes should fail.
+  bool write_side_closed_;
+};
+
+}  // namespace net
+
+#endif  // NET_QUIC_RELIABLE_QUIC_STREAM_H_