1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
|
// 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 <sys/types.h>
#include <list>
#include "net/quic/quic_stream_sequencer.h"
namespace net {
namespace test {
class ReliableQuicStreamPeer;
} // namespace test
class IPEndPoint;
class QuicSession;
// All this does right now is send data to subclasses via the sequencer.
class NET_EXPORT_PRIVATE ReliableQuicStream {
public:
// Visitor receives callbacks from the stream.
class Visitor {
public:
Visitor() {}
// Called when the stream is closed.
virtual void OnClose(ReliableQuicStream* stream) = 0;
protected:
virtual ~Visitor() {}
private:
DISALLOW_COPY_AND_ASSIGN(Visitor);
};
ReliableQuicStream(QuicStreamId id,
QuicSession* session);
virtual ~ReliableQuicStream();
bool WillAcceptStreamFrame(const QuicStreamFrame& frame) const;
virtual bool OnStreamFrame(const QuicStreamFrame& frame);
virtual void OnCanWrite();
// Called by the session just before the stream is deleted.
virtual void OnClose();
// Called when we get a stream reset from the client.
void OnStreamReset(QuicErrorCode error);
// 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 bool IsHalfClosed() const;
virtual bool HasBytesToRead() const;
QuicStreamId id() const { return id_; }
QuicErrorCode error() const { return error_; }
bool read_side_closed() const { return read_side_closed_; }
bool write_side_closed() const { return write_side_closed_; }
const IPEndPoint& GetPeerAddress() const;
Visitor* visitor() { return visitor_; }
void set_visitor(Visitor* visitor) { visitor_ = visitor; }
protected:
// Returns a pair with the number of bytes consumed from data, and a boolean
// indicating if the fin bit was consumed. This does not indicate the data
// has been sent on the wire: it may have been turned into a packet and queued
// if the socket was unexpectedly blocked.
//
// The default implementation always consumed all bytes and any fin, but
// this behavior is not guaranteed for subclasses so callers should check the
// return value.
virtual QuicConsumedData 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_; }
// Sends as much of 'data' to the connection as the connection will consume,
// and then buffers any remaining data in queued_data_.
// Returns (data.size(), true) as it always consumed all data: it returns for
// convenience to have the same return type as WriteDataInternal.
QuicConsumedData WriteOrBuffer(base::StringPiece data, bool fin);
// Sends as much of 'data' to the connection as the connection will consume.
// Returns the number of bytes consumed by the connection.
QuicConsumedData WriteDataInternal(base::StringPiece data, bool fin);
private:
friend class test::ReliableQuicStreamPeer;
friend class QuicStreamUtils;
std::list<string> queued_data_;
QuicStreamSequencer sequencer_;
QuicStreamId id_;
QuicSession* session_;
// Optional visitor of this stream to be notified when the stream is closed.
Visitor* visitor_;
// Bytes read and written refer to payload bytes only: they do not include
// framing, encryption overhead etc.
uint64 stream_bytes_read_;
uint64 stream_bytes_written_;
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_;
bool fin_buffered_;
bool fin_sent_;
};
} // namespace net
#endif // NET_QUIC_RELIABLE_QUIC_STREAM_H_
|
