MacViews: Get c/b/ui/views/tabs to build on Mac
[chromium-blink-merge.git] / net / quic / reliable_quic_stream.h
blob24bc34988320bc3c153cd61213d06347365b6395
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.
4 //
5 // The base class for client/server reliable streams.
7 #ifndef NET_QUIC_RELIABLE_QUIC_STREAM_H_
8 #define NET_QUIC_RELIABLE_QUIC_STREAM_H_
10 #include <sys/types.h>
12 #include <list>
14 #include "base/basictypes.h"
15 #include "base/memory/ref_counted.h"
16 #include "base/strings/string_piece.h"
17 #include "net/base/iovec.h"
18 #include "net/base/net_export.h"
19 #include "net/quic/quic_ack_notifier.h"
20 #include "net/quic/quic_flow_controller.h"
21 #include "net/quic/quic_protocol.h"
22 #include "net/quic/quic_stream_sequencer.h"
23 #include "net/quic/quic_types.h"
25 namespace net {
27 namespace test {
28 class ReliableQuicStreamPeer;
29 } // namespace test
31 class QuicSession;
33 class NET_EXPORT_PRIVATE ReliableQuicStream {
34 public:
35 ReliableQuicStream(QuicStreamId id,
36 QuicSession* session);
38 virtual ~ReliableQuicStream();
40 // Called when a (potentially duplicate) stream frame has been received
41 // for this stream.
42 virtual void OnStreamFrame(const QuicStreamFrame& frame);
44 // Called when the connection becomes writeable to allow the stream
45 // to write any pending data.
46 virtual void OnCanWrite();
48 // Called by the session just before the stream is deleted.
49 virtual void OnClose();
51 // Called when we get a stream reset from the peer.
52 virtual void OnStreamReset(const QuicRstStreamFrame& frame);
54 // Called when we get or send a connection close, and should immediately
55 // close the stream. This is not passed through the sequencer,
56 // but is handled immediately.
57 virtual void OnConnectionClosed(QuicErrorCode error, bool from_peer);
59 // Called when the final data has been read.
60 virtual void OnFinRead();
62 virtual uint32 ProcessRawData(const char* data, uint32 data_len) = 0;
64 // Called to reset the stream from this end.
65 virtual void Reset(QuicRstStreamErrorCode error);
67 // Called to close the entire connection from this end.
68 virtual void CloseConnection(QuicErrorCode error);
69 virtual void CloseConnectionWithDetails(QuicErrorCode error,
70 const string& details);
72 // Returns the effective priority for the stream. This value may change
73 // during the life of the stream.
74 virtual QuicPriority EffectivePriority() const = 0;
76 QuicStreamId id() const { return id_; }
78 QuicRstStreamErrorCode stream_error() const { return stream_error_; }
79 QuicErrorCode connection_error() const { return connection_error_; }
81 bool read_side_closed() const { return read_side_closed_; }
82 bool write_side_closed() const { return write_side_closed_; }
84 uint64 stream_bytes_read() const { return stream_bytes_read_; }
85 uint64 stream_bytes_written() const { return stream_bytes_written_; }
87 QuicVersion version() const;
89 void set_fin_sent(bool fin_sent) { fin_sent_ = fin_sent; }
90 void set_rst_sent(bool rst_sent) { rst_sent_ = rst_sent; }
92 void set_fec_policy(FecPolicy fec_policy) { fec_policy_ = fec_policy; }
93 FecPolicy fec_policy() const { return fec_policy_; }
95 // Adjust our flow control windows according to new offset in |frame|.
96 virtual void OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame);
98 int num_frames_received() const;
100 int num_duplicate_frames_received() const;
102 QuicFlowController* flow_controller() { return &flow_controller_; }
104 // Called when we see a frame which could increase the highest offset.
105 // Returns true if the highest offset did increase.
106 bool MaybeIncreaseHighestReceivedOffset(uint64 new_offset);
107 // Called when bytese are sent to the peer.
108 void AddBytesSent(uint64 bytes);
109 // Called by the stream sequencer as bytes are consumed from the buffer.
110 // If our receive window has dropped below the threshold, then send a
111 // WINDOW_UPDATE frame.
112 void AddBytesConsumed(uint64 bytes);
114 // Updates the flow controller's send window offset and calls OnCanWrite if
115 // it was blocked before.
116 void UpdateSendWindowOffset(uint64 new_offset);
118 // Returns true if the stream is flow control blocked, by the stream flow
119 // control window or the connection flow control window.
120 bool IsFlowControlBlocked();
122 // Returns true if we have received either a RST or a FIN - either of which
123 // gives a definitive number of bytes which the peer has sent. If this is not
124 // true on stream termination the session must keep track of the stream's byte
125 // offset until a definitive final value arrives.
126 bool HasFinalReceivedByteOffset() const {
127 return fin_received_ || rst_received_;
130 // Returns true if the stream has queued data waiting to write.
131 bool HasBufferedData() const;
133 protected:
134 // Sends as much of 'data' to the connection as the connection will consume,
135 // and then buffers any remaining data in queued_data_.
136 void WriteOrBufferData(
137 base::StringPiece data,
138 bool fin,
139 QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
141 // Sends as many bytes in the first |count| buffers of |iov| to the connection
142 // as the connection will consume.
143 // If |ack_notifier_delegate| is provided, then it will be notified once all
144 // the ACKs for this write have been received.
145 // Returns the number of bytes consumed by the connection.
146 QuicConsumedData WritevData(
147 const struct iovec* iov,
148 int iov_count,
149 bool fin,
150 QuicAckNotifier::DelegateInterface* ack_notifier_delegate);
152 // Helper method that returns FecProtection to use for writes to the session.
153 FecProtection GetFecProtection();
155 // Close the read side of the socket. Further frames will not be accepted.
156 virtual void CloseReadSide();
158 // Close the write side of the socket. Further writes will fail.
159 void CloseWriteSide();
161 bool fin_buffered() const { return fin_buffered_; }
163 const QuicSession* session() const { return session_; }
164 QuicSession* session() { return session_; }
166 const QuicStreamSequencer* sequencer() const { return &sequencer_; }
167 QuicStreamSequencer* sequencer() { return &sequencer_; }
169 // TODO(rjshade): Remove this method when removing QUIC_VERSION_19.
170 void DisableFlowControl() {
171 flow_controller_.Disable();
174 void DisableConnectionFlowControlForThisStream() {
175 stream_contributes_to_connection_flow_control_ = false;
178 private:
179 friend class test::ReliableQuicStreamPeer;
180 friend class QuicStreamUtils;
181 class ProxyAckNotifierDelegate;
183 struct PendingData {
184 PendingData(string data_in,
185 scoped_refptr<ProxyAckNotifierDelegate> delegate_in);
186 ~PendingData();
188 string data;
189 // Delegate that should be notified when the pending data is acked.
190 // Can be nullptr.
191 scoped_refptr<ProxyAckNotifierDelegate> delegate;
194 // Calls MaybeSendBlocked on our flow controller, and connection level flow
195 // controller. If we are flow control blocked, marks this stream as write
196 // blocked.
197 void MaybeSendBlocked();
199 std::list<PendingData> queued_data_;
201 QuicStreamSequencer sequencer_;
202 QuicStreamId id_;
203 QuicSession* session_;
204 // Bytes read and written refer to payload bytes only: they do not include
205 // framing, encryption overhead etc.
206 uint64 stream_bytes_read_;
207 uint64 stream_bytes_written_;
209 // Stream error code received from a RstStreamFrame or error code sent by the
210 // visitor or sequencer in the RstStreamFrame.
211 QuicRstStreamErrorCode stream_error_;
212 // Connection error code due to which the stream was closed. |stream_error_|
213 // is set to |QUIC_STREAM_CONNECTION_ERROR| when this happens and consumers
214 // should check |connection_error_|.
215 QuicErrorCode connection_error_;
217 // True if the read side is closed and further frames should be rejected.
218 bool read_side_closed_;
219 // True if the write side is closed, and further writes should fail.
220 bool write_side_closed_;
222 bool fin_buffered_;
223 bool fin_sent_;
225 // True if this stream has received (and the sequencer has accepted) a
226 // StreamFrame with the FIN set.
227 bool fin_received_;
229 // In combination with fin_sent_, used to ensure that a FIN and/or a RST is
230 // always sent before stream termination.
231 bool rst_sent_;
233 // True if this stream has received a RST stream frame.
234 bool rst_received_;
236 // FEC policy to be used for this stream.
237 FecPolicy fec_policy_;
239 // True if the session this stream is running under is a server session.
240 bool is_server_;
242 QuicFlowController flow_controller_;
244 // The connection level flow controller. Not owned.
245 QuicFlowController* connection_flow_controller_;
247 // Special streams, such as the crypto and headers streams, do not respect
248 // connection level flow control limits (but are stream level flow control
249 // limited).
250 bool stream_contributes_to_connection_flow_control_;
252 DISALLOW_COPY_AND_ASSIGN(ReliableQuicStream);
255 } // namespace net
257 #endif // NET_QUIC_RELIABLE_QUIC_STREAM_H_