OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/quic/core/quic_server_session_base.h" | 5 #include "net/quic/core/quic_server_session_base.h" |
6 | 6 |
7 #include <cstdint> | 7 #include <cstdint> |
8 #include <memory> | 8 #include <memory> |
9 | 9 |
10 #include "base/macros.h" | 10 #include "base/macros.h" |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
144 config_, connection_, &owner_, &stream_helper_, &crypto_config_, | 144 config_, connection_, &owner_, &stream_helper_, &crypto_config_, |
145 &compressed_certs_cache_, &response_cache_)); | 145 &compressed_certs_cache_, &response_cache_)); |
146 MockClock clock; | 146 MockClock clock; |
147 handshake_message_.reset(crypto_config_.AddDefaultConfig( | 147 handshake_message_.reset(crypto_config_.AddDefaultConfig( |
148 QuicRandom::GetInstance(), &clock, | 148 QuicRandom::GetInstance(), &clock, |
149 QuicCryptoServerConfig::ConfigOptions())); | 149 QuicCryptoServerConfig::ConfigOptions())); |
150 session_->Initialize(); | 150 session_->Initialize(); |
151 visitor_ = QuicConnectionPeer::GetVisitor(connection_); | 151 visitor_ = QuicConnectionPeer::GetVisitor(connection_); |
152 } | 152 } |
153 | 153 |
| 154 QuicStreamId GetNthClientInitiatedId(int n) { |
| 155 return QuicSpdySessionPeer::GetNthClientInitiatedStreamId(*session_, n); |
| 156 } |
| 157 |
| 158 QuicStreamId GetNthServerInitiatedId(int n) { |
| 159 return QuicSpdySessionPeer::GetNthServerInitiatedStreamId(*session_, n); |
| 160 } |
| 161 |
154 StrictMock<MockQuicSessionVisitor> owner_; | 162 StrictMock<MockQuicSessionVisitor> owner_; |
155 StrictMock<MockQuicCryptoServerStreamHelper> stream_helper_; | 163 StrictMock<MockQuicCryptoServerStreamHelper> stream_helper_; |
156 MockQuicConnectionHelper helper_; | 164 MockQuicConnectionHelper helper_; |
157 MockAlarmFactory alarm_factory_; | 165 MockAlarmFactory alarm_factory_; |
158 StrictMock<MockQuicConnection>* connection_; | 166 StrictMock<MockQuicConnection>* connection_; |
159 QuicConfig config_; | 167 QuicConfig config_; |
160 QuicCryptoServerConfig crypto_config_; | 168 QuicCryptoServerConfig crypto_config_; |
161 QuicCompressedCertsCache compressed_certs_cache_; | 169 QuicCompressedCertsCache compressed_certs_cache_; |
162 QuicHttpResponseCache response_cache_; | 170 QuicHttpResponseCache response_cache_; |
163 std::unique_ptr<TestServerSession> session_; | 171 std::unique_ptr<TestServerSession> session_; |
(...skipping 27 matching lines...) Expand all Loading... |
191 EXPECT_FALSE( | 199 EXPECT_FALSE( |
192 session_->config()->HasReceivedConnectionOptions() && | 200 session_->config()->HasReceivedConnectionOptions() && |
193 ContainsQuicTag(session_->config()->ReceivedConnectionOptions(), kSPSH)); | 201 ContainsQuicTag(session_->config()->ReceivedConnectionOptions(), kSPSH)); |
194 session_->OnConfigNegotiated(); | 202 session_->OnConfigNegotiated(); |
195 EXPECT_TRUE(session_->server_push_enabled()); | 203 EXPECT_TRUE(session_->server_push_enabled()); |
196 } | 204 } |
197 | 205 |
198 TEST_P(QuicServerSessionBaseTest, CloseStreamDueToReset) { | 206 TEST_P(QuicServerSessionBaseTest, CloseStreamDueToReset) { |
199 // Open a stream, then reset it. | 207 // Open a stream, then reset it. |
200 // Send two bytes of payload to open it. | 208 // Send two bytes of payload to open it. |
201 QuicStreamFrame data1(kClientDataStreamId1, false, 0, QuicStringPiece("HT")); | 209 QuicStreamFrame data1(GetNthClientInitiatedId(0), false, 0, |
| 210 QuicStringPiece("HT")); |
202 session_->OnStreamFrame(data1); | 211 session_->OnStreamFrame(data1); |
203 EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams()); | 212 EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams()); |
204 | 213 |
205 // Send a reset (and expect the peer to send a RST in response). | 214 // Send a reset (and expect the peer to send a RST in response). |
206 QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_ERROR_PROCESSING_STREAM, | 215 QuicRstStreamFrame rst1(GetNthClientInitiatedId(0), |
207 0); | 216 QUIC_ERROR_PROCESSING_STREAM, 0); |
208 EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1); | 217 EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1); |
209 EXPECT_CALL(*connection_, | 218 EXPECT_CALL(*connection_, SendRstStream(GetNthClientInitiatedId(0), |
210 SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0)); | 219 QUIC_RST_ACKNOWLEDGEMENT, 0)); |
211 visitor_->OnRstStream(rst1); | 220 visitor_->OnRstStream(rst1); |
212 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); | 221 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); |
213 | 222 |
214 // Send the same two bytes of payload in a new packet. | 223 // Send the same two bytes of payload in a new packet. |
215 visitor_->OnStreamFrame(data1); | 224 visitor_->OnStreamFrame(data1); |
216 | 225 |
217 // The stream should not be re-opened. | 226 // The stream should not be re-opened. |
218 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); | 227 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); |
219 EXPECT_TRUE(connection_->connected()); | 228 EXPECT_TRUE(connection_->connected()); |
220 } | 229 } |
221 | 230 |
222 TEST_P(QuicServerSessionBaseTest, NeverOpenStreamDueToReset) { | 231 TEST_P(QuicServerSessionBaseTest, NeverOpenStreamDueToReset) { |
223 // Send a reset (and expect the peer to send a RST in response). | 232 // Send a reset (and expect the peer to send a RST in response). |
224 QuicRstStreamFrame rst1(kClientDataStreamId1, QUIC_ERROR_PROCESSING_STREAM, | 233 QuicRstStreamFrame rst1(GetNthClientInitiatedId(0), |
225 0); | 234 QUIC_ERROR_PROCESSING_STREAM, 0); |
226 EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1); | 235 EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1); |
227 EXPECT_CALL(*connection_, | 236 EXPECT_CALL(*connection_, SendRstStream(GetNthClientInitiatedId(0), |
228 SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0)); | 237 QUIC_RST_ACKNOWLEDGEMENT, 0)); |
229 visitor_->OnRstStream(rst1); | 238 visitor_->OnRstStream(rst1); |
230 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); | 239 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); |
231 | 240 |
232 // Send two bytes of payload. | 241 // Send two bytes of payload. |
233 QuicStreamFrame data1(kClientDataStreamId1, false, 0, QuicStringPiece("HT")); | 242 QuicStreamFrame data1(GetNthClientInitiatedId(0), false, 0, |
| 243 QuicStringPiece("HT")); |
234 visitor_->OnStreamFrame(data1); | 244 visitor_->OnStreamFrame(data1); |
235 | 245 |
236 // The stream should never be opened, now that the reset is received. | 246 // The stream should never be opened, now that the reset is received. |
237 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); | 247 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); |
238 EXPECT_TRUE(connection_->connected()); | 248 EXPECT_TRUE(connection_->connected()); |
239 } | 249 } |
240 | 250 |
241 TEST_P(QuicServerSessionBaseTest, AcceptClosedStream) { | 251 TEST_P(QuicServerSessionBaseTest, AcceptClosedStream) { |
242 // Send (empty) compressed headers followed by two bytes of data. | 252 // Send (empty) compressed headers followed by two bytes of data. |
243 QuicStreamFrame frame1(kClientDataStreamId1, false, 0, | 253 QuicStreamFrame frame1(GetNthClientInitiatedId(0), false, 0, |
244 QuicStringPiece("\1\0\0\0\0\0\0\0HT")); | 254 QuicStringPiece("\1\0\0\0\0\0\0\0HT")); |
245 QuicStreamFrame frame2(kClientDataStreamId2, false, 0, | 255 QuicStreamFrame frame2(GetNthClientInitiatedId(1), false, 0, |
246 QuicStringPiece("\2\0\0\0\0\0\0\0HT")); | 256 QuicStringPiece("\2\0\0\0\0\0\0\0HT")); |
247 visitor_->OnStreamFrame(frame1); | 257 visitor_->OnStreamFrame(frame1); |
248 visitor_->OnStreamFrame(frame2); | 258 visitor_->OnStreamFrame(frame2); |
249 EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams()); | 259 EXPECT_EQ(2u, session_->GetNumOpenIncomingStreams()); |
250 | 260 |
251 // Send a reset (and expect the peer to send a RST in response). | 261 // Send a reset (and expect the peer to send a RST in response). |
252 QuicRstStreamFrame rst(kClientDataStreamId1, QUIC_ERROR_PROCESSING_STREAM, 0); | 262 QuicRstStreamFrame rst(GetNthClientInitiatedId(0), |
| 263 QUIC_ERROR_PROCESSING_STREAM, 0); |
253 EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1); | 264 EXPECT_CALL(owner_, OnRstStreamReceived(_)).Times(1); |
254 EXPECT_CALL(*connection_, | 265 EXPECT_CALL(*connection_, SendRstStream(GetNthClientInitiatedId(0), |
255 SendRstStream(kClientDataStreamId1, QUIC_RST_ACKNOWLEDGEMENT, 0)); | 266 QUIC_RST_ACKNOWLEDGEMENT, 0)); |
256 visitor_->OnRstStream(rst); | 267 visitor_->OnRstStream(rst); |
257 | 268 |
258 // If we were tracking, we'd probably want to reject this because it's data | 269 // If we were tracking, we'd probably want to reject this because it's data |
259 // past the reset point of stream 3. As it's a closed stream we just drop the | 270 // past the reset point of stream 3. As it's a closed stream we just drop the |
260 // data on the floor, but accept the packet because it has data for stream 5. | 271 // data on the floor, but accept the packet because it has data for stream 5. |
261 QuicStreamFrame frame3(kClientDataStreamId1, false, 2, QuicStringPiece("TP")); | 272 QuicStreamFrame frame3(GetNthClientInitiatedId(0), false, 2, |
262 QuicStreamFrame frame4(kClientDataStreamId2, false, 2, QuicStringPiece("TP")); | 273 QuicStringPiece("TP")); |
| 274 QuicStreamFrame frame4(GetNthClientInitiatedId(1), false, 2, |
| 275 QuicStringPiece("TP")); |
263 visitor_->OnStreamFrame(frame3); | 276 visitor_->OnStreamFrame(frame3); |
264 visitor_->OnStreamFrame(frame4); | 277 visitor_->OnStreamFrame(frame4); |
265 // The stream should never be opened, now that the reset is received. | 278 // The stream should never be opened, now that the reset is received. |
266 EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams()); | 279 EXPECT_EQ(1u, session_->GetNumOpenIncomingStreams()); |
267 EXPECT_TRUE(connection_->connected()); | 280 EXPECT_TRUE(connection_->connected()); |
268 } | 281 } |
269 | 282 |
270 TEST_P(QuicServerSessionBaseTest, MaxOpenStreams) { | 283 TEST_P(QuicServerSessionBaseTest, MaxOpenStreams) { |
271 // Test that the server refuses if a client attempts to open too many data | 284 // Test that the server refuses if a client attempts to open too many data |
272 // streams. The server accepts slightly more than the negotiated stream limit | 285 // streams. The server accepts slightly more than the negotiated stream limit |
273 // to deal with rare cases where a client FIN/RST is lost. | 286 // to deal with rare cases where a client FIN/RST is lost. |
274 | 287 |
275 // The slightly increased stream limit is set during config negotiation. It | 288 // The slightly increased stream limit is set during config negotiation. It |
276 // is either an increase of 10 over negotiated limit, or a fixed percentage | 289 // is either an increase of 10 over negotiated limit, or a fixed percentage |
277 // scaling, whichever is larger. Test both before continuing. | 290 // scaling, whichever is larger. Test both before continuing. |
278 session_->OnConfigNegotiated(); | 291 session_->OnConfigNegotiated(); |
279 EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest, | 292 EXPECT_LT(kMaxStreamsMultiplier * kMaxStreamsForTest, |
280 kMaxStreamsForTest + kMaxStreamsMinimumIncrement); | 293 kMaxStreamsForTest + kMaxStreamsMinimumIncrement); |
281 EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement, | 294 EXPECT_EQ(kMaxStreamsForTest + kMaxStreamsMinimumIncrement, |
282 session_->max_open_incoming_streams()); | 295 session_->max_open_incoming_streams()); |
283 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); | 296 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); |
284 QuicStreamId stream_id = kClientDataStreamId1; | 297 QuicStreamId stream_id = GetNthClientInitiatedId(0); |
285 // Open the max configured number of streams, should be no problem. | 298 // Open the max configured number of streams, should be no problem. |
286 for (size_t i = 0; i < kMaxStreamsForTest; ++i) { | 299 for (size_t i = 0; i < kMaxStreamsForTest; ++i) { |
287 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( | 300 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
288 session_.get(), stream_id)); | 301 session_.get(), stream_id)); |
289 stream_id += 2; | 302 stream_id += QuicSpdySessionPeer::NextStreamId(*session_); |
290 } | 303 } |
291 | 304 |
292 // Open more streams: server should accept slightly more than the limit. | 305 // Open more streams: server should accept slightly more than the limit. |
293 for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) { | 306 for (size_t i = 0; i < kMaxStreamsMinimumIncrement; ++i) { |
294 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( | 307 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
295 session_.get(), stream_id)); | 308 session_.get(), stream_id)); |
296 stream_id += 2; | 309 stream_id += QuicSpdySessionPeer::NextStreamId(*session_); |
297 } | 310 } |
298 | 311 |
299 // Now violate the server's internal stream limit. | 312 // Now violate the server's internal stream limit. |
300 stream_id += 2; | 313 stream_id += QuicSpdySessionPeer::NextStreamId(*session_); |
301 EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0); | 314 EXPECT_CALL(*connection_, CloseConnection(_, _, _)).Times(0); |
302 EXPECT_CALL(*connection_, SendRstStream(stream_id, QUIC_REFUSED_STREAM, 0)); | 315 EXPECT_CALL(*connection_, SendRstStream(stream_id, QUIC_REFUSED_STREAM, 0)); |
303 // Even if the connection remains open, the stream creation should fail. | 316 // Even if the connection remains open, the stream creation should fail. |
304 EXPECT_FALSE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( | 317 EXPECT_FALSE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
305 session_.get(), stream_id)); | 318 session_.get(), stream_id)); |
306 } | 319 } |
307 | 320 |
308 TEST_P(QuicServerSessionBaseTest, MaxAvailableStreams) { | 321 TEST_P(QuicServerSessionBaseTest, MaxAvailableStreams) { |
309 // Test that the server closes the connection if a client makes too many data | 322 // Test that the server closes the connection if a client makes too many data |
310 // streams available. The server accepts slightly more than the negotiated | 323 // streams available. The server accepts slightly more than the negotiated |
311 // stream limit to deal with rare cases where a client FIN/RST is lost. | 324 // stream limit to deal with rare cases where a client FIN/RST is lost. |
312 | 325 |
313 session_->OnConfigNegotiated(); | 326 session_->OnConfigNegotiated(); |
314 const size_t kAvailableStreamLimit = session_->MaxAvailableStreams(); | 327 const size_t kAvailableStreamLimit = session_->MaxAvailableStreams(); |
315 EXPECT_EQ( | 328 EXPECT_EQ( |
316 session_->max_open_incoming_streams() * kMaxAvailableStreamsMultiplier, | 329 session_->max_open_incoming_streams() * kMaxAvailableStreamsMultiplier, |
317 session_->MaxAvailableStreams()); | 330 session_->MaxAvailableStreams()); |
318 // The protocol specification requires that there can be at least 10 times | 331 // The protocol specification requires that there can be at least 10 times |
319 // as many available streams as the connection's maximum open streams. | 332 // as many available streams as the connection's maximum open streams. |
320 EXPECT_LE(10 * kMaxStreamsForTest, kAvailableStreamLimit); | 333 EXPECT_LE(10 * kMaxStreamsForTest, kAvailableStreamLimit); |
321 | 334 |
322 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); | 335 EXPECT_EQ(0u, session_->GetNumOpenIncomingStreams()); |
323 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( | 336 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
324 session_.get(), kClientDataStreamId1)); | 337 session_.get(), GetNthClientInitiatedId(0))); |
325 | 338 |
326 // Establish available streams up to the server's limit. | 339 // Establish available streams up to the server's limit. |
| 340 QuicStreamId next_id = QuicSpdySessionPeer::NextStreamId(*session_); |
327 const int kLimitingStreamId = | 341 const int kLimitingStreamId = |
328 kClientDataStreamId1 + (kAvailableStreamLimit)*2 + 2; | 342 GetNthClientInitiatedId(kAvailableStreamLimit + 1); |
329 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( | 343 EXPECT_TRUE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
330 session_.get(), kLimitingStreamId)); | 344 session_.get(), kLimitingStreamId)); |
331 | 345 |
332 // A further available stream will result in connection close. | 346 // A further available stream will result in connection close. |
333 EXPECT_CALL(*connection_, | 347 EXPECT_CALL(*connection_, |
334 CloseConnection(QUIC_TOO_MANY_AVAILABLE_STREAMS, _, _)); | 348 CloseConnection(QUIC_TOO_MANY_AVAILABLE_STREAMS, _, _)); |
335 // This forces stream kLimitingStreamId + 2 to become available, which | 349 // This forces stream kLimitingStreamId + 2 to become available, which |
336 // violates the quota. | 350 // violates the quota. |
337 EXPECT_FALSE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( | 351 EXPECT_FALSE(QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
338 session_.get(), kLimitingStreamId + 4)); | 352 session_.get(), kLimitingStreamId + 2 * next_id)); |
339 } | 353 } |
340 | 354 |
341 // TODO(ckrasic): remove this when | 355 // TODO(ckrasic): remove this when |
342 // FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default is | 356 // FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default is |
343 // deprecated. | 357 // deprecated. |
344 TEST_P(QuicServerSessionBaseTest, EnableServerPushThroughConnectionOption) { | 358 TEST_P(QuicServerSessionBaseTest, EnableServerPushThroughConnectionOption) { |
345 FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default = false; | 359 FLAGS_quic_reloadable_flag_quic_enable_server_push_by_default = false; |
346 // Assume server received server push connection option. | 360 // Assume server received server push connection option. |
347 QuicTagVector copt; | 361 QuicTagVector copt; |
348 copt.push_back(kSPSH); | 362 copt.push_back(kSPSH); |
349 QuicConfigPeer::SetReceivedConnectionOptions(session_->config(), copt); | 363 QuicConfigPeer::SetReceivedConnectionOptions(session_->config(), copt); |
350 session_->OnConfigNegotiated(); | 364 session_->OnConfigNegotiated(); |
351 EXPECT_TRUE(session_->server_push_enabled()); | 365 EXPECT_TRUE(session_->server_push_enabled()); |
352 } | 366 } |
353 | 367 |
354 TEST_P(QuicServerSessionBaseTest, GetEvenIncomingError) { | 368 TEST_P(QuicServerSessionBaseTest, GetEvenIncomingError) { |
355 // Incoming streams on the server session must be odd. | 369 // Incoming streams on the server session must be odd. |
356 EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _)); | 370 EXPECT_CALL(*connection_, CloseConnection(QUIC_INVALID_STREAM_ID, _, _)); |
357 EXPECT_EQ(nullptr, QuicServerSessionBasePeer::GetOrCreateDynamicStream( | 371 EXPECT_EQ(nullptr, QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
358 session_.get(), 4)); | 372 session_.get(), GetNthServerInitiatedId(0))); |
359 } | 373 } |
360 | 374 |
361 TEST_P(QuicServerSessionBaseTest, GetStreamDisconnected) { | 375 TEST_P(QuicServerSessionBaseTest, GetStreamDisconnected) { |
362 // Don't create new streams if the connection is disconnected. | 376 // Don't create new streams if the connection is disconnected. |
363 QuicConnectionPeer::TearDownLocalConnectionState(connection_); | 377 QuicConnectionPeer::TearDownLocalConnectionState(connection_); |
364 EXPECT_QUIC_BUG( | 378 EXPECT_QUIC_BUG(QuicServerSessionBasePeer::GetOrCreateDynamicStream( |
365 QuicServerSessionBasePeer::GetOrCreateDynamicStream(session_.get(), 5), | 379 session_.get(), GetNthClientInitiatedId(0)), |
366 "ShouldCreateIncomingDynamicStream called when disconnected"); | 380 "ShouldCreateIncomingDynamicStream called when disconnected"); |
367 } | 381 } |
368 | 382 |
369 class MockQuicCryptoServerStream : public QuicCryptoServerStream { | 383 class MockQuicCryptoServerStream : public QuicCryptoServerStream { |
370 public: | 384 public: |
371 explicit MockQuicCryptoServerStream( | 385 explicit MockQuicCryptoServerStream( |
372 const QuicCryptoServerConfig* crypto_config, | 386 const QuicCryptoServerConfig* crypto_config, |
373 QuicCompressedCertsCache* compressed_certs_cache, | 387 QuicCompressedCertsCache* compressed_certs_cache, |
374 QuicServerSessionBase* session, | 388 QuicServerSessionBase* session, |
375 QuicCryptoServerStream::Helper* helper) | 389 QuicCryptoServerStream::Helper* helper) |
376 : QuicCryptoServerStream( | 390 : QuicCryptoServerStream( |
(...skipping 255 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
632 | 646 |
633 // Allow the async ProofSource::GetProof call to complete. Verify (under | 647 // Allow the async ProofSource::GetProof call to complete. Verify (under |
634 // asan) that this does not result in accesses to any freed memory from the | 648 // asan) that this does not result in accesses to any freed memory from the |
635 // session or its subobjects. | 649 // session or its subobjects. |
636 GetFakeProofSource()->InvokePendingCallback(0); | 650 GetFakeProofSource()->InvokePendingCallback(0); |
637 } | 651 } |
638 | 652 |
639 } // namespace | 653 } // namespace |
640 } // namespace test | 654 } // namespace test |
641 } // namespace net | 655 } // namespace net |
OLD | NEW |