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 #include "net/third_party/quiche/src/quic/test_tools/quic_session_peer.h"
6
7 #include "net/third_party/quiche/src/quic/core/quic_session.h"
8 #include "net/third_party/quiche/src/quic/core/quic_stream.h"
9 #include "net/third_party/quiche/src/quic/core/quic_utils.h"
10 #include "net/third_party/quiche/src/quic/platform/api/quic_map_util.h"
11
12 namespace quic {
13 namespace test {
14
15 // static
GetNextOutgoingBidirectionalStreamId(QuicSession * session)16 QuicStreamId QuicSessionPeer::GetNextOutgoingBidirectionalStreamId(
17 QuicSession* session) {
18 return session->GetNextOutgoingBidirectionalStreamId();
19 }
20
21 // static
GetNextOutgoingUnidirectionalStreamId(QuicSession * session)22 QuicStreamId QuicSessionPeer::GetNextOutgoingUnidirectionalStreamId(
23 QuicSession* session) {
24 return session->GetNextOutgoingUnidirectionalStreamId();
25 }
26
27 // static
SetNextOutgoingBidirectionalStreamId(QuicSession * session,QuicStreamId id)28 void QuicSessionPeer::SetNextOutgoingBidirectionalStreamId(QuicSession* session,
29 QuicStreamId id) {
30 if (VersionHasIetfQuicFrames(session->transport_version())) {
31 session->ietf_streamid_manager_.bidirectional_stream_id_manager_
32 .next_outgoing_stream_id_ = id;
33 return;
34 }
35 session->stream_id_manager_.next_outgoing_stream_id_ = id;
36 }
37
38 // static
SetMaxOpenIncomingStreams(QuicSession * session,uint32_t max_streams)39 void QuicSessionPeer::SetMaxOpenIncomingStreams(QuicSession* session,
40 uint32_t max_streams) {
41 if (VersionHasIetfQuicFrames(session->transport_version())) {
42 QUIC_BUG << "SetmaxOpenIncomingStreams deprecated for IETF QUIC";
43 session->ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
44 max_streams);
45 session->ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
46 max_streams);
47 return;
48 }
49 session->stream_id_manager_.set_max_open_incoming_streams(max_streams);
50 }
51
52 // static
SetMaxOpenIncomingBidirectionalStreams(QuicSession * session,uint32_t max_streams)53 void QuicSessionPeer::SetMaxOpenIncomingBidirectionalStreams(
54 QuicSession* session,
55 uint32_t max_streams) {
56 DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
57 << "SetmaxOpenIncomingBidirectionalStreams not supported for Google "
58 "QUIC";
59 session->ietf_streamid_manager_.SetMaxOpenIncomingBidirectionalStreams(
60 max_streams);
61 }
62 // static
SetMaxOpenIncomingUnidirectionalStreams(QuicSession * session,uint32_t max_streams)63 void QuicSessionPeer::SetMaxOpenIncomingUnidirectionalStreams(
64 QuicSession* session,
65 uint32_t max_streams) {
66 DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
67 << "SetmaxOpenIncomingUnidirectionalStreams not supported for Google "
68 "QUIC";
69 session->ietf_streamid_manager_.SetMaxOpenIncomingUnidirectionalStreams(
70 max_streams);
71 }
72
73 // static
SetMaxOpenOutgoingStreams(QuicSession * session,uint32_t max_streams)74 void QuicSessionPeer::SetMaxOpenOutgoingStreams(QuicSession* session,
75 uint32_t max_streams) {
76 if (VersionHasIetfQuicFrames(session->transport_version())) {
77 QUIC_BUG << "SetmaxOpenOutgoingStreams deprecated for IETF QUIC";
78 return;
79 }
80 session->stream_id_manager_.set_max_open_outgoing_streams(max_streams);
81 }
82
83 // static
SetMaxOpenOutgoingBidirectionalStreams(QuicSession * session,uint32_t max_streams)84 void QuicSessionPeer::SetMaxOpenOutgoingBidirectionalStreams(
85 QuicSession* session,
86 uint32_t max_streams) {
87 DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
88 << "SetmaxOpenOutgoingBidirectionalStreams not supported for Google "
89 "QUIC";
90 session->ietf_streamid_manager_.MaybeAllowNewOutgoingBidirectionalStreams(
91 max_streams);
92 }
93 // static
SetMaxOpenOutgoingUnidirectionalStreams(QuicSession * session,uint32_t max_streams)94 void QuicSessionPeer::SetMaxOpenOutgoingUnidirectionalStreams(
95 QuicSession* session,
96 uint32_t max_streams) {
97 DCHECK(VersionHasIetfQuicFrames(session->transport_version()))
98 << "SetmaxOpenOutgoingUnidirectionalStreams not supported for Google "
99 "QUIC";
100 session->ietf_streamid_manager_.MaybeAllowNewOutgoingUnidirectionalStreams(
101 max_streams);
102 }
103
104 // static
GetMutableCryptoStream(QuicSession * session)105 QuicCryptoStream* QuicSessionPeer::GetMutableCryptoStream(
106 QuicSession* session) {
107 return session->GetMutableCryptoStream();
108 }
109
110 // static
GetWriteBlockedStreams(QuicSession * session)111 QuicWriteBlockedList* QuicSessionPeer::GetWriteBlockedStreams(
112 QuicSession* session) {
113 return &session->write_blocked_streams_;
114 }
115
116 // static
GetOrCreateStream(QuicSession * session,QuicStreamId stream_id)117 QuicStream* QuicSessionPeer::GetOrCreateStream(QuicSession* session,
118 QuicStreamId stream_id) {
119 return session->GetOrCreateStream(stream_id);
120 }
121
122 // static
123 QuicHashMap<QuicStreamId, QuicStreamOffset>&
GetLocallyClosedStreamsHighestOffset(QuicSession * session)124 QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(QuicSession* session) {
125 return session->locally_closed_streams_highest_offset_;
126 }
127
128 // static
stream_map(QuicSession * session)129 QuicSession::StreamMap& QuicSessionPeer::stream_map(QuicSession* session) {
130 return session->stream_map();
131 }
132
133 // static
closed_streams(QuicSession * session)134 const QuicSession::ClosedStreams& QuicSessionPeer::closed_streams(
135 QuicSession* session) {
136 return *session->closed_streams();
137 }
138
139 // static
ActivateStream(QuicSession * session,std::unique_ptr<QuicStream> stream)140 void QuicSessionPeer::ActivateStream(QuicSession* session,
141 std::unique_ptr<QuicStream> stream) {
142 return session->ActivateStream(std::move(stream));
143 }
144
145 // static
IsStreamClosed(QuicSession * session,QuicStreamId id)146 bool QuicSessionPeer::IsStreamClosed(QuicSession* session, QuicStreamId id) {
147 return session->IsClosedStream(id);
148 }
149
150 // static
IsStreamCreated(QuicSession * session,QuicStreamId id)151 bool QuicSessionPeer::IsStreamCreated(QuicSession* session, QuicStreamId id) {
152 return QuicContainsKey(session->stream_map(), id);
153 }
154
155 // static
IsStreamAvailable(QuicSession * session,QuicStreamId id)156 bool QuicSessionPeer::IsStreamAvailable(QuicSession* session, QuicStreamId id) {
157 if (VersionHasIetfQuicFrames(session->transport_version())) {
158 if (id % QuicUtils::StreamIdDelta(session->transport_version()) < 2) {
159 return QuicContainsKey(
160 session->ietf_streamid_manager_.bidirectional_stream_id_manager_
161 .available_streams_,
162 id);
163 }
164 return QuicContainsKey(
165 session->ietf_streamid_manager_.unidirectional_stream_id_manager_
166 .available_streams_,
167 id);
168 }
169 return QuicContainsKey(session->stream_id_manager_.available_streams_, id);
170 }
171
172 // static
GetStream(QuicSession * session,QuicStreamId id)173 QuicStream* QuicSessionPeer::GetStream(QuicSession* session, QuicStreamId id) {
174 return session->GetStream(id);
175 }
176
177 // static
IsStreamWriteBlocked(QuicSession * session,QuicStreamId id)178 bool QuicSessionPeer::IsStreamWriteBlocked(QuicSession* session,
179 QuicStreamId id) {
180 return session->write_blocked_streams_.IsStreamBlocked(id);
181 }
182
183 // static
GetCleanUpClosedStreamsAlarm(QuicSession * session)184 QuicAlarm* QuicSessionPeer::GetCleanUpClosedStreamsAlarm(QuicSession* session) {
185 return session->closed_streams_clean_up_alarm_.get();
186 }
187
188 // static
GetStreamIdManager(QuicSession * session)189 LegacyQuicStreamIdManager* QuicSessionPeer::GetStreamIdManager(
190 QuicSession* session) {
191 return &session->stream_id_manager_;
192 }
193
194 // static
ietf_streamid_manager(QuicSession * session)195 UberQuicStreamIdManager* QuicSessionPeer::ietf_streamid_manager(
196 QuicSession* session) {
197 return &session->ietf_streamid_manager_;
198 }
199
200 // static
ietf_bidirectional_stream_id_manager(QuicSession * session)201 QuicStreamIdManager* QuicSessionPeer::ietf_bidirectional_stream_id_manager(
202 QuicSession* session) {
203 return &session->ietf_streamid_manager_.bidirectional_stream_id_manager_;
204 }
205
206 // static
ietf_unidirectional_stream_id_manager(QuicSession * session)207 QuicStreamIdManager* QuicSessionPeer::ietf_unidirectional_stream_id_manager(
208 QuicSession* session) {
209 return &session->ietf_streamid_manager_.unidirectional_stream_id_manager_;
210 }
211
212 // static
GetPendingStream(QuicSession * session,QuicStreamId stream_id)213 PendingStream* QuicSessionPeer::GetPendingStream(QuicSession* session,
214 QuicStreamId stream_id) {
215 auto it = session->pending_stream_map_.find(stream_id);
216 return it == session->pending_stream_map_.end() ? nullptr : it->second.get();
217 }
218
219 // static
set_is_configured(QuicSession * session,bool value)220 void QuicSessionPeer::set_is_configured(QuicSession* session, bool value) {
221 session->is_configured_ = value;
222 }
223
224 // static
SetPerspective(QuicSession * session,Perspective perspective)225 void QuicSessionPeer::SetPerspective(QuicSession* session,
226 Perspective perspective) {
227 session->perspective_ = perspective;
228 }
229
230 // static
GetNumOpenDynamicStreams(QuicSession * session)231 size_t QuicSessionPeer::GetNumOpenDynamicStreams(QuicSession* session) {
232 size_t result = 0;
233 for (const auto& it : session->stream_map_) {
234 if (!it.second->is_static()) {
235 ++result;
236 }
237 }
238 // Exclude draining streams.
239 result -= session->num_draining_streams_;
240 // Add locally closed streams.
241 result += session->locally_closed_streams_highest_offset_.size();
242
243 return result;
244 }
245
246 // static
GetNumDrainingStreams(QuicSession * session)247 size_t QuicSessionPeer::GetNumDrainingStreams(QuicSession* session) {
248 return session->num_draining_streams_;
249 }
250
251 } // namespace test
252 } // namespace quic
253