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
|
// Copyright 2013 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 streams which deliver data to/from an application.
// In each direction, the data on such a stream first contains compressed
// headers then body data.
#ifndef NET_QUIC_QUIC_SPDY_STREAM_H_
#define NET_QUIC_QUIC_SPDY_STREAM_H_
#include <sys/types.h>
#include <list>
#include <string>
#include "base/basictypes.h"
#include "base/strings/string_piece.h"
#include "net/base/iovec.h"
#include "net/base/ip_endpoint.h"
#include "net/base/net_export.h"
#include "net/quic/quic_protocol.h"
#include "net/quic/quic_stream_sequencer.h"
#include "net/quic/reliable_quic_stream.h"
#include "net/spdy/spdy_framer.h"
namespace net {
namespace test {
class QuicSpdyStreamPeer;
class ReliableQuicStreamPeer;
} // namespace test
class QuicSpdySession;
// A QUIC stream that can send and receive HTTP2 (SPDY) headers.
class NET_EXPORT_PRIVATE QuicSpdyStream : public ReliableQuicStream {
public:
// Visitor receives callbacks from the stream.
class NET_EXPORT_PRIVATE Visitor {
public:
Visitor() {}
// Called when the stream is closed.
virtual void OnClose(QuicSpdyStream* stream) = 0;
protected:
virtual ~Visitor() {}
private:
DISALLOW_COPY_AND_ASSIGN(Visitor);
};
QuicSpdyStream(QuicStreamId id, QuicSpdySession* spdy_session);
~QuicSpdyStream() override;
// ReliableQuicStream implementation
void OnClose() override;
// By default, this is the same as priority(), however it allows streams
// to temporarily alter effective priority. For example if a SPDY stream has
// compressed but not written headers it can write the headers with a higher
// priority.
QuicPriority EffectivePriority() const override;
// Called by the session when decompressed headers data is received
// for this stream.
// May be called multiple times, with each call providing additional headers
// data until OnStreamHeadersComplete is called.
virtual void OnStreamHeaders(base::StringPiece headers_data);
// Called by the session when headers with a priority have been received
// for this stream. This method will only be called for server streams.
virtual void OnStreamHeadersPriority(QuicPriority priority);
// Called by the session when decompressed headers have been completely
// delilvered to this stream. If |fin| is true, then this stream
// should be closed; no more data will be sent by the peer.
virtual void OnStreamHeadersComplete(bool fin, size_t frame_len);
// Writes the headers contained in |header_block| to the dedicated
// headers stream.
virtual size_t WriteHeaders(const SpdyHeaderBlock& header_block,
bool fin,
QuicAckListenerInterface* ack_notifier_delegate);
// Marks |bytes_consumed| of the headers data as consumed.
void MarkHeadersConsumed(size_t bytes_consumed);
// This block of functions wraps the sequencer's functions of the same
// name. These methods return uncompressed data until that has
// been fully processed. Then they simply delegate to the sequencer.
virtual size_t Readv(const struct iovec* iov, size_t iov_len);
virtual int GetReadableRegions(iovec* iov, size_t iov_len) const;
void MarkConsumed(size_t num_bytes);
// Returns true when all data has been read from the peer, including the fin.
bool IsDoneReading() const;
bool HasBytesToRead() const;
void set_visitor(Visitor* visitor) { visitor_ = visitor; }
bool headers_decompressed() const { return headers_decompressed_; }
const std::string& decompressed_headers() const {
return decompressed_headers_;
}
protected:
// Sets priority_ to priority. This should only be called before bytes are
// written to the server.
void set_priority(QuicPriority priority);
// This is protected because external classes should use EffectivePriority
// instead.
QuicPriority priority() const { return priority_; }
bool FinishedReadingHeaders() const;
private:
friend class test::QuicSpdyStreamPeer;
friend class test::ReliableQuicStreamPeer;
friend class QuicStreamUtils;
QuicSpdySession* spdy_session_;
Visitor* visitor_;
// True if the headers have been completely decompressed.
bool headers_decompressed_;
// The priority of the stream, once parsed.
QuicPriority priority_;
// Contains a copy of the decompressed headers until they are consumed
// via ProcessData or Readv.
std::string decompressed_headers_;
DISALLOW_COPY_AND_ASSIGN(QuicSpdyStream);
};
} // namespace net
#endif // NET_QUIC_QUIC_SPDY_STREAM_H_
|
