OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 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/spdy/spdy_session.h" | 5 #include "net/spdy/spdy_session.h" |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 #include <utility> | 8 #include <utility> |
9 | 9 |
10 #include "base/base64.h" | 10 #include "base/base64.h" |
(...skipping 250 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
261 MockRead reads[] = {MockRead(ASYNC, 0, 0), }; | 261 MockRead reads[] = {MockRead(ASYNC, 0, 0), }; |
262 | 262 |
263 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); | 263 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); |
264 session_deps_.socket_factory->AddSocketDataProvider(&data); | 264 session_deps_.socket_factory->AddSocketDataProvider(&data); |
265 | 265 |
266 CreateNetworkSession(); | 266 CreateNetworkSession(); |
267 CreateInsecureSpdySession(); | 267 CreateInsecureSpdySession(); |
268 | 268 |
269 // Create the maximum number of concurrent streams. | 269 // Create the maximum number of concurrent streams. |
270 for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) { | 270 for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) { |
271 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 271 base::WeakPtr<SpdyStream> spdy_stream = |
272 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 272 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, |
| 273 test_url_, MEDIUM, NetLogWithSource()); |
273 ASSERT_TRUE(spdy_stream); | 274 ASSERT_TRUE(spdy_stream); |
274 } | 275 } |
275 | 276 |
276 SpdyStreamRequest request1; | 277 SpdyStreamRequest request1; |
277 std::unique_ptr<SpdyStreamRequest> request2(new SpdyStreamRequest); | 278 std::unique_ptr<SpdyStreamRequest> request2(new SpdyStreamRequest); |
278 | 279 |
279 StreamRequestDestroyingCallback callback1; | 280 StreamRequestDestroyingCallback callback1; |
280 ASSERT_EQ( | 281 ASSERT_EQ(ERR_IO_PENDING, |
281 ERR_IO_PENDING, | 282 request1.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, |
282 request1.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, | 283 test_url_, MEDIUM, NetLogWithSource(), |
283 MEDIUM, BoundNetLog(), callback1.MakeCallback())); | 284 callback1.MakeCallback())); |
284 | 285 |
285 // |callback2| is never called. | 286 // |callback2| is never called. |
286 TestCompletionCallback callback2; | 287 TestCompletionCallback callback2; |
287 ASSERT_EQ(ERR_IO_PENDING, request2->StartRequest( | 288 ASSERT_EQ( |
288 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, | 289 ERR_IO_PENDING, |
289 MEDIUM, BoundNetLog(), callback2.callback())); | 290 request2->StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 291 MEDIUM, NetLogWithSource(), callback2.callback())); |
290 | 292 |
291 callback1.SetRequestToDestroy(std::move(request2)); | 293 callback1.SetRequestToDestroy(std::move(request2)); |
292 | 294 |
293 session_->CloseSessionOnError(ERR_ABORTED, "Aborting session"); | 295 session_->CloseSessionOnError(ERR_ABORTED, "Aborting session"); |
294 | 296 |
295 EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_ABORTED)); | 297 EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_ABORTED)); |
296 } | 298 } |
297 | 299 |
298 // A session receiving a GOAWAY frame with no active streams should close. | 300 // A session receiving a GOAWAY frame with no active streams should close. |
299 TEST_F(SpdySessionTest, GoAwayWithNoActiveStreams) { | 301 TEST_F(SpdySessionTest, GoAwayWithNoActiveStreams) { |
(...skipping 25 matching lines...) Expand all Loading... |
325 SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); | 327 SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
326 MockRead reads[] = { | 328 MockRead reads[] = { |
327 CreateMockRead(goaway, 0, SYNCHRONOUS), MockRead(ASYNC, 0, 1) // EOF | 329 CreateMockRead(goaway, 0, SYNCHRONOUS), MockRead(ASYNC, 0, 1) // EOF |
328 }; | 330 }; |
329 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); | 331 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); |
330 session_deps_.socket_factory->AddSocketDataProvider(&data); | 332 session_deps_.socket_factory->AddSocketDataProvider(&data); |
331 | 333 |
332 CreateNetworkSession(); | 334 CreateNetworkSession(); |
333 | 335 |
334 session_ = TryCreateInsecureSpdySessionExpectingFailure( | 336 session_ = TryCreateInsecureSpdySessionExpectingFailure( |
335 http_session_.get(), key_, ERR_CONNECTION_CLOSED, BoundNetLog()); | 337 http_session_.get(), key_, ERR_CONNECTION_CLOSED, NetLogWithSource()); |
336 base::RunLoop().RunUntilIdle(); | 338 base::RunLoop().RunUntilIdle(); |
337 | 339 |
338 EXPECT_FALSE(session_); | 340 EXPECT_FALSE(session_); |
339 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); | 341 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
340 EXPECT_FALSE(data.AllReadDataConsumed()); | 342 EXPECT_FALSE(data.AllReadDataConsumed()); |
341 } | 343 } |
342 | 344 |
343 // A session receiving a GOAWAY frame with active streams should close | 345 // A session receiving a GOAWAY frame with active streams should close |
344 // when the last active stream is closed. | 346 // when the last active stream is closed. |
345 TEST_F(SpdySessionTest, GoAwayWithActiveStreams) { | 347 TEST_F(SpdySessionTest, GoAwayWithActiveStreams) { |
(...skipping 10 matching lines...) Expand all Loading... |
356 spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM, true)); | 358 spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM, true)); |
357 MockWrite writes[] = { | 359 MockWrite writes[] = { |
358 CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), | 360 CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
359 }; | 361 }; |
360 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 362 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
361 session_deps_.socket_factory->AddSocketDataProvider(&data); | 363 session_deps_.socket_factory->AddSocketDataProvider(&data); |
362 | 364 |
363 CreateNetworkSession(); | 365 CreateNetworkSession(); |
364 CreateInsecureSpdySession(); | 366 CreateInsecureSpdySession(); |
365 | 367 |
366 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 368 base::WeakPtr<SpdyStream> spdy_stream1 = |
367 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 369 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 370 test_url_, MEDIUM, NetLogWithSource()); |
368 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 371 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
369 spdy_stream1->SetDelegate(&delegate1); | 372 spdy_stream1->SetDelegate(&delegate1); |
370 | 373 |
371 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 374 base::WeakPtr<SpdyStream> spdy_stream2 = |
372 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 375 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 376 test_url_, MEDIUM, NetLogWithSource()); |
373 test::StreamDelegateDoNothing delegate2(spdy_stream2); | 377 test::StreamDelegateDoNothing delegate2(spdy_stream2); |
374 spdy_stream2->SetDelegate(&delegate2); | 378 spdy_stream2->SetDelegate(&delegate2); |
375 | 379 |
376 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 380 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
377 SpdyHeaderBlock headers2(headers.Clone()); | 381 SpdyHeaderBlock headers2(headers.Clone()); |
378 | 382 |
379 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 383 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
380 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); | 384 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
381 | 385 |
382 base::RunLoop().RunUntilIdle(); | 386 base::RunLoop().RunUntilIdle(); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
422 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); | 426 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); |
423 MockWrite writes[] = { | 427 MockWrite writes[] = { |
424 CreateMockWrite(req1, 0), | 428 CreateMockWrite(req1, 0), |
425 }; | 429 }; |
426 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 430 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
427 session_deps_.socket_factory->AddSocketDataProvider(&data); | 431 session_deps_.socket_factory->AddSocketDataProvider(&data); |
428 | 432 |
429 CreateNetworkSession(); | 433 CreateNetworkSession(); |
430 CreateInsecureSpdySession(); | 434 CreateInsecureSpdySession(); |
431 | 435 |
432 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 436 base::WeakPtr<SpdyStream> spdy_stream1 = |
433 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 437 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 438 test_url_, MEDIUM, NetLogWithSource()); |
434 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 439 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
435 spdy_stream1->SetDelegate(&delegate1); | 440 spdy_stream1->SetDelegate(&delegate1); |
436 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 441 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
437 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); | 442 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
438 | 443 |
439 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 444 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
440 | 445 |
441 // Active stream 1. | 446 // Active stream 1. |
442 base::RunLoop().RunUntilIdle(); | 447 base::RunLoop().RunUntilIdle(); |
443 EXPECT_EQ(1u, spdy_stream1->stream_id()); | 448 EXPECT_EQ(1u, spdy_stream1->stream_id()); |
444 EXPECT_TRUE(session_->IsStreamActive(1)); | 449 EXPECT_TRUE(session_->IsStreamActive(1)); |
445 | 450 |
446 // Create stream corresponding to the next request. | 451 // Create stream corresponding to the next request. |
447 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 452 base::WeakPtr<SpdyStream> spdy_stream2 = |
448 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 453 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 454 test_url_, MEDIUM, NetLogWithSource()); |
449 | 455 |
450 EXPECT_EQ(0u, spdy_stream2->stream_id()); | 456 EXPECT_EQ(0u, spdy_stream2->stream_id()); |
451 | 457 |
452 // Read and process the GOAWAY frame before the second stream could be | 458 // Read and process the GOAWAY frame before the second stream could be |
453 // activated. | 459 // activated. |
454 data.Resume(); | 460 data.Resume(); |
455 base::RunLoop().RunUntilIdle(); | 461 base::RunLoop().RunUntilIdle(); |
456 | 462 |
457 EXPECT_FALSE(session_); | 463 EXPECT_FALSE(session_); |
458 | 464 |
(...skipping 20 matching lines...) Expand all Loading... |
479 spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM, true)); | 485 spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM, true)); |
480 MockWrite writes[] = { | 486 MockWrite writes[] = { |
481 CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), | 487 CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
482 }; | 488 }; |
483 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 489 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
484 session_deps_.socket_factory->AddSocketDataProvider(&data); | 490 session_deps_.socket_factory->AddSocketDataProvider(&data); |
485 | 491 |
486 CreateNetworkSession(); | 492 CreateNetworkSession(); |
487 CreateInsecureSpdySession(); | 493 CreateInsecureSpdySession(); |
488 | 494 |
489 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 495 base::WeakPtr<SpdyStream> spdy_stream1 = |
490 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 496 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 497 test_url_, MEDIUM, NetLogWithSource()); |
491 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 498 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
492 spdy_stream1->SetDelegate(&delegate1); | 499 spdy_stream1->SetDelegate(&delegate1); |
493 | 500 |
494 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 501 base::WeakPtr<SpdyStream> spdy_stream2 = |
495 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 502 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 503 test_url_, MEDIUM, NetLogWithSource()); |
496 test::StreamDelegateDoNothing delegate2(spdy_stream2); | 504 test::StreamDelegateDoNothing delegate2(spdy_stream2); |
497 spdy_stream2->SetDelegate(&delegate2); | 505 spdy_stream2->SetDelegate(&delegate2); |
498 | 506 |
499 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 507 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
500 SpdyHeaderBlock headers2(headers.Clone()); | 508 SpdyHeaderBlock headers2(headers.Clone()); |
501 | 509 |
502 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 510 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
503 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); | 511 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
504 | 512 |
505 base::RunLoop().RunUntilIdle(); | 513 base::RunLoop().RunUntilIdle(); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
544 spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM, true)); | 552 spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM, true)); |
545 MockWrite writes[] = { | 553 MockWrite writes[] = { |
546 CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), | 554 CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
547 }; | 555 }; |
548 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 556 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
549 session_deps_.socket_factory->AddSocketDataProvider(&data); | 557 session_deps_.socket_factory->AddSocketDataProvider(&data); |
550 | 558 |
551 CreateNetworkSession(); | 559 CreateNetworkSession(); |
552 CreateInsecureSpdySession(); | 560 CreateInsecureSpdySession(); |
553 | 561 |
554 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 562 base::WeakPtr<SpdyStream> spdy_stream1 = |
555 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 563 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 564 test_url_, MEDIUM, NetLogWithSource()); |
556 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 565 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
557 spdy_stream1->SetDelegate(&delegate1); | 566 spdy_stream1->SetDelegate(&delegate1); |
558 | 567 |
559 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 568 base::WeakPtr<SpdyStream> spdy_stream2 = |
560 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 569 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 570 test_url_, MEDIUM, NetLogWithSource()); |
561 test::StreamDelegateDoNothing delegate2(spdy_stream2); | 571 test::StreamDelegateDoNothing delegate2(spdy_stream2); |
562 spdy_stream2->SetDelegate(&delegate2); | 572 spdy_stream2->SetDelegate(&delegate2); |
563 | 573 |
564 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 574 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
565 SpdyHeaderBlock headers2(headers.Clone()); | 575 SpdyHeaderBlock headers2(headers.Clone()); |
566 | 576 |
567 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 577 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
568 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); | 578 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
569 | 579 |
570 base::RunLoop().RunUntilIdle(); | 580 base::RunLoop().RunUntilIdle(); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
628 CreateMockRead(resp, 1), CreateMockRead(joint_frames, 2), | 638 CreateMockRead(resp, 1), CreateMockRead(joint_frames, 2), |
629 MockRead(ASYNC, 0, 3) // EOF | 639 MockRead(ASYNC, 0, 3) // EOF |
630 }; | 640 }; |
631 | 641 |
632 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 642 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
633 session_deps_.socket_factory->AddSocketDataProvider(&data); | 643 session_deps_.socket_factory->AddSocketDataProvider(&data); |
634 | 644 |
635 CreateNetworkSession(); | 645 CreateNetworkSession(); |
636 CreateInsecureSpdySession(); | 646 CreateInsecureSpdySession(); |
637 | 647 |
638 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 648 base::WeakPtr<SpdyStream> spdy_stream = |
639 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 649 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 650 test_url_, MEDIUM, NetLogWithSource()); |
640 test::StreamDelegateDoNothing delegate(spdy_stream); | 651 test::StreamDelegateDoNothing delegate(spdy_stream); |
641 spdy_stream->SetDelegate(&delegate); | 652 spdy_stream->SetDelegate(&delegate); |
642 | 653 |
643 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 654 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
644 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 655 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
645 | 656 |
646 base::RunLoop().RunUntilIdle(); | 657 base::RunLoop().RunUntilIdle(); |
647 | 658 |
648 // Stream and session closed gracefully. | 659 // Stream and session closed gracefully. |
649 EXPECT_TRUE(delegate.StreamIsClosed()); | 660 EXPECT_TRUE(delegate.StreamIsClosed()); |
(...skipping 16 matching lines...) Expand all Loading... |
666 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); | 677 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); |
667 MockWrite writes[] = { | 678 MockWrite writes[] = { |
668 CreateMockWrite(req, 0), | 679 CreateMockWrite(req, 0), |
669 }; | 680 }; |
670 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 681 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
671 session_deps_.socket_factory->AddSocketDataProvider(&data); | 682 session_deps_.socket_factory->AddSocketDataProvider(&data); |
672 | 683 |
673 CreateNetworkSession(); | 684 CreateNetworkSession(); |
674 CreateInsecureSpdySession(); | 685 CreateInsecureSpdySession(); |
675 | 686 |
676 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 687 base::WeakPtr<SpdyStream> spdy_stream = |
677 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 688 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 689 test_url_, MEDIUM, NetLogWithSource()); |
678 test::StreamDelegateDoNothing delegate(spdy_stream); | 690 test::StreamDelegateDoNothing delegate(spdy_stream); |
679 spdy_stream->SetDelegate(&delegate); | 691 spdy_stream->SetDelegate(&delegate); |
680 | 692 |
681 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 693 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
682 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 694 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
683 | 695 |
684 base::RunLoop().RunUntilIdle(); | 696 base::RunLoop().RunUntilIdle(); |
685 | 697 |
686 EXPECT_EQ(1u, spdy_stream->stream_id()); | 698 EXPECT_EQ(1u, spdy_stream->stream_id()); |
687 | 699 |
688 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); | 700 EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
689 | 701 |
690 // Read and process the GOAWAY frame. | 702 // Read and process the GOAWAY frame. |
691 data.Resume(); | 703 data.Resume(); |
692 base::RunLoop().RunUntilIdle(); | 704 base::RunLoop().RunUntilIdle(); |
693 | 705 |
694 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); | 706 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
695 EXPECT_TRUE(session_->IsStreamActive(1)); | 707 EXPECT_TRUE(session_->IsStreamActive(1)); |
696 | 708 |
697 SpdyStreamRequest stream_request; | 709 SpdyStreamRequest stream_request; |
698 int rv = stream_request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, | 710 int rv = stream_request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, |
699 test_url_, MEDIUM, BoundNetLog(), | 711 test_url_, MEDIUM, NetLogWithSource(), |
700 CompletionCallback()); | 712 CompletionCallback()); |
701 EXPECT_THAT(rv, IsError(ERR_FAILED)); | 713 EXPECT_THAT(rv, IsError(ERR_FAILED)); |
702 | 714 |
703 EXPECT_TRUE(session_); | 715 EXPECT_TRUE(session_); |
704 data.Resume(); | 716 data.Resume(); |
705 base::RunLoop().RunUntilIdle(); | 717 base::RunLoop().RunUntilIdle(); |
706 EXPECT_FALSE(session_); | 718 EXPECT_FALSE(session_); |
707 } | 719 } |
708 | 720 |
709 // Receiving a HEADERS frame after a GOAWAY frame should result in | 721 // Receiving a HEADERS frame after a GOAWAY frame should result in |
(...skipping 13 matching lines...) Expand all Loading... |
723 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); | 735 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); |
724 SpdySerializedFrame rst( | 736 SpdySerializedFrame rst( |
725 spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM)); | 737 spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM)); |
726 MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)}; | 738 MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)}; |
727 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 739 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
728 session_deps_.socket_factory->AddSocketDataProvider(&data); | 740 session_deps_.socket_factory->AddSocketDataProvider(&data); |
729 | 741 |
730 CreateNetworkSession(); | 742 CreateNetworkSession(); |
731 CreateInsecureSpdySession(); | 743 CreateInsecureSpdySession(); |
732 | 744 |
733 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 745 base::WeakPtr<SpdyStream> spdy_stream = |
734 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 746 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 747 test_url_, MEDIUM, NetLogWithSource()); |
735 test::StreamDelegateDoNothing delegate(spdy_stream); | 748 test::StreamDelegateDoNothing delegate(spdy_stream); |
736 spdy_stream->SetDelegate(&delegate); | 749 spdy_stream->SetDelegate(&delegate); |
737 | 750 |
738 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 751 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
739 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 752 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
740 | 753 |
741 base::RunLoop().RunUntilIdle(); | 754 base::RunLoop().RunUntilIdle(); |
742 | 755 |
743 EXPECT_EQ(1u, spdy_stream->stream_id()); | 756 EXPECT_EQ(1u, spdy_stream->stream_id()); |
744 | 757 |
(...skipping 25 matching lines...) Expand all Loading... |
770 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); | 783 spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM, true)); |
771 MockWrite writes[] = { | 784 MockWrite writes[] = { |
772 CreateMockWrite(req1, 0), | 785 CreateMockWrite(req1, 0), |
773 }; | 786 }; |
774 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 787 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
775 session_deps_.socket_factory->AddSocketDataProvider(&data); | 788 session_deps_.socket_factory->AddSocketDataProvider(&data); |
776 | 789 |
777 CreateNetworkSession(); | 790 CreateNetworkSession(); |
778 CreateInsecureSpdySession(); | 791 CreateInsecureSpdySession(); |
779 | 792 |
780 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 793 base::WeakPtr<SpdyStream> spdy_stream = |
781 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 794 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 795 test_url_, MEDIUM, NetLogWithSource()); |
782 test::StreamDelegateDoNothing delegate(spdy_stream); | 796 test::StreamDelegateDoNothing delegate(spdy_stream); |
783 spdy_stream->SetDelegate(&delegate); | 797 spdy_stream->SetDelegate(&delegate); |
784 | 798 |
785 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 799 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
786 | 800 |
787 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 801 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
788 | 802 |
789 base::RunLoop().RunUntilIdle(); | 803 base::RunLoop().RunUntilIdle(); |
790 | 804 |
791 EXPECT_EQ(1u, spdy_stream->stream_id()); | 805 EXPECT_EQ(1u, spdy_stream->stream_id()); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
829 SpdySerializedFrame write_ping(spdy_util_.ConstructSpdyPing(1, false)); | 843 SpdySerializedFrame write_ping(spdy_util_.ConstructSpdyPing(1, false)); |
830 MockWrite writes[] = { | 844 MockWrite writes[] = { |
831 CreateMockWrite(write_ping, 0), | 845 CreateMockWrite(write_ping, 0), |
832 }; | 846 }; |
833 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 847 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
834 session_deps_.socket_factory->AddSocketDataProvider(&data); | 848 session_deps_.socket_factory->AddSocketDataProvider(&data); |
835 | 849 |
836 CreateNetworkSession(); | 850 CreateNetworkSession(); |
837 CreateInsecureSpdySession(); | 851 CreateInsecureSpdySession(); |
838 | 852 |
839 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 853 base::WeakPtr<SpdyStream> spdy_stream1 = |
840 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 854 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 855 MEDIUM, NetLogWithSource()); |
841 ASSERT_TRUE(spdy_stream1); | 856 ASSERT_TRUE(spdy_stream1); |
842 test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr); | 857 test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr); |
843 spdy_stream1->SetDelegate(&delegate); | 858 spdy_stream1->SetDelegate(&delegate); |
844 | 859 |
845 base::TimeTicks before_ping_time = base::TimeTicks::Now(); | 860 base::TimeTicks before_ping_time = base::TimeTicks::Now(); |
846 | 861 |
847 session_->set_connection_at_risk_of_loss_time( | 862 session_->set_connection_at_risk_of_loss_time( |
848 base::TimeDelta::FromSeconds(-1)); | 863 base::TimeDelta::FromSeconds(-1)); |
849 session_->set_hung_interval(base::TimeDelta::FromMilliseconds(50)); | 864 session_->set_hung_interval(base::TimeDelta::FromMilliseconds(50)); |
850 | 865 |
(...skipping 28 matching lines...) Expand all Loading... |
879 MockWrite writes[] = { | 894 MockWrite writes[] = { |
880 CreateMockWrite(write_ping), | 895 CreateMockWrite(write_ping), |
881 }; | 896 }; |
882 StaticSocketDataProvider data( | 897 StaticSocketDataProvider data( |
883 reads, arraysize(reads), writes, arraysize(writes)); | 898 reads, arraysize(reads), writes, arraysize(writes)); |
884 session_deps_.socket_factory->AddSocketDataProvider(&data); | 899 session_deps_.socket_factory->AddSocketDataProvider(&data); |
885 | 900 |
886 CreateNetworkSession(); | 901 CreateNetworkSession(); |
887 CreateInsecureSpdySession(); | 902 CreateInsecureSpdySession(); |
888 | 903 |
889 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 904 base::WeakPtr<SpdyStream> spdy_stream1 = |
890 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 905 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 906 MEDIUM, NetLogWithSource()); |
891 ASSERT_TRUE(spdy_stream1); | 907 ASSERT_TRUE(spdy_stream1); |
892 test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr); | 908 test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr); |
893 spdy_stream1->SetDelegate(&delegate); | 909 spdy_stream1->SetDelegate(&delegate); |
894 | 910 |
895 // Flush the read completion task. | 911 // Flush the read completion task. |
896 base::RunLoop().RunUntilIdle(); | 912 base::RunLoop().RunUntilIdle(); |
897 | 913 |
898 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); | 914 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
899 | 915 |
900 EXPECT_FALSE(session_); | 916 EXPECT_FALSE(session_); |
(...skipping 20 matching lines...) Expand all Loading... |
921 }; | 937 }; |
922 | 938 |
923 session_deps_.host_resolver->set_synchronous_mode(true); | 939 session_deps_.host_resolver->set_synchronous_mode(true); |
924 | 940 |
925 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 941 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
926 session_deps_.socket_factory->AddSocketDataProvider(&data); | 942 session_deps_.socket_factory->AddSocketDataProvider(&data); |
927 | 943 |
928 CreateNetworkSession(); | 944 CreateNetworkSession(); |
929 CreateInsecureSpdySession(); | 945 CreateInsecureSpdySession(); |
930 | 946 |
931 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 947 base::WeakPtr<SpdyStream> spdy_stream = |
932 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 948 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 949 test_url_, LOWEST, NetLogWithSource()); |
933 test::StreamDelegateDoNothing delegate(spdy_stream); | 950 test::StreamDelegateDoNothing delegate(spdy_stream); |
934 spdy_stream->SetDelegate(&delegate); | 951 spdy_stream->SetDelegate(&delegate); |
935 | 952 |
936 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 953 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
937 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 954 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
938 | 955 |
939 // Shift time so that a ping will be sent out. | 956 // Shift time so that a ping will be sent out. |
940 g_time_delta = base::TimeDelta::FromSeconds(11); | 957 g_time_delta = base::TimeDelta::FromSeconds(11); |
941 | 958 |
942 base::RunLoop().RunUntilIdle(); | 959 base::RunLoop().RunUntilIdle(); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
988 | 1005 |
989 CreateNetworkSession(); | 1006 CreateNetworkSession(); |
990 CreateInsecureSpdySession(); | 1007 CreateInsecureSpdySession(); |
991 | 1008 |
992 // Fix stream_hi_water_mark_ to allow for two stream activations. | 1009 // Fix stream_hi_water_mark_ to allow for two stream activations. |
993 session_->stream_hi_water_mark_ = kLastStreamId - 2; | 1010 session_->stream_hi_water_mark_ = kLastStreamId - 2; |
994 // Fix max_concurrent_streams to allow for three stream creations. | 1011 // Fix max_concurrent_streams to allow for three stream creations. |
995 session_->max_concurrent_streams_ = 3; | 1012 session_->max_concurrent_streams_ = 3; |
996 | 1013 |
997 // Create three streams synchronously, and begin a fourth (which is stalled). | 1014 // Create three streams synchronously, and begin a fourth (which is stalled). |
998 base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously( | 1015 base::WeakPtr<SpdyStream> stream1 = |
999 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1016 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1017 test_url_, MEDIUM, NetLogWithSource()); |
1000 test::StreamDelegateDoNothing delegate1(stream1); | 1018 test::StreamDelegateDoNothing delegate1(stream1); |
1001 stream1->SetDelegate(&delegate1); | 1019 stream1->SetDelegate(&delegate1); |
1002 | 1020 |
1003 base::WeakPtr<SpdyStream> stream2 = CreateStreamSynchronously( | 1021 base::WeakPtr<SpdyStream> stream2 = |
1004 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1022 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1023 test_url_, MEDIUM, NetLogWithSource()); |
1005 test::StreamDelegateDoNothing delegate2(stream2); | 1024 test::StreamDelegateDoNothing delegate2(stream2); |
1006 stream2->SetDelegate(&delegate2); | 1025 stream2->SetDelegate(&delegate2); |
1007 | 1026 |
1008 base::WeakPtr<SpdyStream> stream3 = CreateStreamSynchronously( | 1027 base::WeakPtr<SpdyStream> stream3 = |
1009 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1028 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1029 test_url_, MEDIUM, NetLogWithSource()); |
1010 test::StreamDelegateDoNothing delegate3(stream3); | 1030 test::StreamDelegateDoNothing delegate3(stream3); |
1011 stream3->SetDelegate(&delegate3); | 1031 stream3->SetDelegate(&delegate3); |
1012 | 1032 |
1013 SpdyStreamRequest request4; | 1033 SpdyStreamRequest request4; |
1014 TestCompletionCallback callback4; | 1034 TestCompletionCallback callback4; |
1015 EXPECT_EQ( | 1035 EXPECT_EQ( |
1016 ERR_IO_PENDING, | 1036 ERR_IO_PENDING, |
1017 request4.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, | 1037 request4.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, |
1018 MEDIUM, BoundNetLog(), callback4.callback())); | 1038 MEDIUM, NetLogWithSource(), callback4.callback())); |
1019 | 1039 |
1020 // Streams 1-3 were created. 4th is stalled. No streams are active yet. | 1040 // Streams 1-3 were created. 4th is stalled. No streams are active yet. |
1021 EXPECT_EQ(0u, session_->num_active_streams()); | 1041 EXPECT_EQ(0u, session_->num_active_streams()); |
1022 EXPECT_EQ(3u, session_->num_created_streams()); | 1042 EXPECT_EQ(3u, session_->num_created_streams()); |
1023 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); | 1043 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); |
1024 | 1044 |
1025 // Activate stream 1. One ID remains available. | 1045 // Activate stream 1. One ID remains available. |
1026 stream1->SendRequestHeaders(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl), | 1046 stream1->SendRequestHeaders(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl), |
1027 NO_MORE_DATA_TO_SEND); | 1047 NO_MORE_DATA_TO_SEND); |
1028 base::RunLoop().RunUntilIdle(); | 1048 base::RunLoop().RunUntilIdle(); |
(...skipping 83 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1112 | 1132 |
1113 // Receive SETTINGS frame that sets max_concurrent_streams to zero. | 1133 // Receive SETTINGS frame that sets max_concurrent_streams to zero. |
1114 base::RunLoop().RunUntilIdle(); | 1134 base::RunLoop().RunUntilIdle(); |
1115 EXPECT_EQ(0u, session_->max_concurrent_streams_); | 1135 EXPECT_EQ(0u, session_->max_concurrent_streams_); |
1116 | 1136 |
1117 // Start request. | 1137 // Start request. |
1118 SpdyStreamRequest request; | 1138 SpdyStreamRequest request; |
1119 TestCompletionCallback callback; | 1139 TestCompletionCallback callback; |
1120 int rv = | 1140 int rv = |
1121 request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, | 1141 request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, |
1122 MEDIUM, BoundNetLog(), callback.callback()); | 1142 MEDIUM, NetLogWithSource(), callback.callback()); |
1123 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); | 1143 EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
1124 | 1144 |
1125 // Stream is stalled. | 1145 // Stream is stalled. |
1126 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); | 1146 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); |
1127 EXPECT_EQ(0u, session_->num_created_streams()); | 1147 EXPECT_EQ(0u, session_->num_created_streams()); |
1128 | 1148 |
1129 // Receive SETTINGS frame that sets max_concurrent_streams to one. | 1149 // Receive SETTINGS frame that sets max_concurrent_streams to one. |
1130 data.Resume(); | 1150 data.Resume(); |
1131 base::RunLoop().RunUntilIdle(); | 1151 base::RunLoop().RunUntilIdle(); |
1132 EXPECT_EQ(1u, session_->max_concurrent_streams_); | 1152 EXPECT_EQ(1u, session_->max_concurrent_streams_); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1164 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); | 1184 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); |
1165 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1185 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1166 | 1186 |
1167 CreateNetworkSession(); | 1187 CreateNetworkSession(); |
1168 CreateInsecureSpdySession(); | 1188 CreateInsecureSpdySession(); |
1169 | 1189 |
1170 // Fix max_concurrent_streams to allow for one open stream. | 1190 // Fix max_concurrent_streams to allow for one open stream. |
1171 session_->max_concurrent_streams_ = 1; | 1191 session_->max_concurrent_streams_ = 1; |
1172 | 1192 |
1173 // Create two streams: one synchronously, and one which stalls. | 1193 // Create two streams: one synchronously, and one which stalls. |
1174 base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously( | 1194 base::WeakPtr<SpdyStream> stream1 = |
1175 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1195 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1196 test_url_, MEDIUM, NetLogWithSource()); |
1176 | 1197 |
1177 SpdyStreamRequest request2; | 1198 SpdyStreamRequest request2; |
1178 TestCompletionCallback callback2; | 1199 TestCompletionCallback callback2; |
1179 EXPECT_EQ( | 1200 EXPECT_EQ( |
1180 ERR_IO_PENDING, | 1201 ERR_IO_PENDING, |
1181 request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, | 1202 request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, |
1182 MEDIUM, BoundNetLog(), callback2.callback())); | 1203 MEDIUM, NetLogWithSource(), callback2.callback())); |
1183 | 1204 |
1184 EXPECT_EQ(1u, session_->num_created_streams()); | 1205 EXPECT_EQ(1u, session_->num_created_streams()); |
1185 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); | 1206 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); |
1186 | 1207 |
1187 // Cancel the first stream. A callback to unstall the second stream was | 1208 // Cancel the first stream. A callback to unstall the second stream was |
1188 // posted. Don't run it yet. | 1209 // posted. Don't run it yet. |
1189 stream1->Cancel(); | 1210 stream1->Cancel(); |
1190 | 1211 |
1191 EXPECT_EQ(0u, session_->num_created_streams()); | 1212 EXPECT_EQ(0u, session_->num_created_streams()); |
1192 EXPECT_EQ(0u, session_->pending_create_stream_queue_size(MEDIUM)); | 1213 EXPECT_EQ(0u, session_->pending_create_stream_queue_size(MEDIUM)); |
1193 | 1214 |
1194 // Create a third stream prior to the second stream's callback. | 1215 // Create a third stream prior to the second stream's callback. |
1195 base::WeakPtr<SpdyStream> stream3 = CreateStreamSynchronously( | 1216 base::WeakPtr<SpdyStream> stream3 = |
1196 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1217 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1218 test_url_, MEDIUM, NetLogWithSource()); |
1197 | 1219 |
1198 EXPECT_EQ(1u, session_->num_created_streams()); | 1220 EXPECT_EQ(1u, session_->num_created_streams()); |
1199 EXPECT_EQ(0u, session_->pending_create_stream_queue_size(MEDIUM)); | 1221 EXPECT_EQ(0u, session_->pending_create_stream_queue_size(MEDIUM)); |
1200 | 1222 |
1201 // Now run the message loop. The unstalled stream will re-stall itself. | 1223 // Now run the message loop. The unstalled stream will re-stall itself. |
1202 base::RunLoop().RunUntilIdle(); | 1224 base::RunLoop().RunUntilIdle(); |
1203 EXPECT_EQ(1u, session_->num_created_streams()); | 1225 EXPECT_EQ(1u, session_->num_created_streams()); |
1204 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); | 1226 EXPECT_EQ(1u, session_->pending_create_stream_queue_size(MEDIUM)); |
1205 | 1227 |
1206 // Cancel the third stream and run the message loop. Verify that the second | 1228 // Cancel the third stream and run the message loop. Verify that the second |
(...skipping 29 matching lines...) Expand all Loading... |
1236 MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7) // EOF | 1258 MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7) // EOF |
1237 }; | 1259 }; |
1238 | 1260 |
1239 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 1261 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
1240 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1262 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1241 | 1263 |
1242 CreateNetworkSession(); | 1264 CreateNetworkSession(); |
1243 CreateInsecureSpdySession(); | 1265 CreateInsecureSpdySession(); |
1244 | 1266 |
1245 // Process the principal request, and the first push stream request & body. | 1267 // Process the principal request, and the first push stream request & body. |
1246 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 1268 base::WeakPtr<SpdyStream> spdy_stream = |
1247 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1269 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1270 test_url_, MEDIUM, NetLogWithSource()); |
1248 test::StreamDelegateDoNothing delegate(spdy_stream); | 1271 test::StreamDelegateDoNothing delegate(spdy_stream); |
1249 spdy_stream->SetDelegate(&delegate); | 1272 spdy_stream->SetDelegate(&delegate); |
1250 | 1273 |
1251 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 1274 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
1252 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 1275 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
1253 | 1276 |
1254 base::RunLoop().RunUntilIdle(); | 1277 base::RunLoop().RunUntilIdle(); |
1255 | 1278 |
1256 // Verify that there is one unclaimed push stream. | 1279 // Verify that there is one unclaimed push stream. |
1257 EXPECT_EQ(1u, session_->num_unclaimed_pushed_streams()); | 1280 EXPECT_EQ(1u, session_->num_unclaimed_pushed_streams()); |
(...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1296 spdy_util_.ConstructSpdyGoAway(0, GOAWAY_PROTOCOL_ERROR, "Failed ping.")); | 1319 spdy_util_.ConstructSpdyGoAway(0, GOAWAY_PROTOCOL_ERROR, "Failed ping.")); |
1297 MockWrite writes[] = {CreateMockWrite(write_ping), CreateMockWrite(goaway)}; | 1320 MockWrite writes[] = {CreateMockWrite(write_ping), CreateMockWrite(goaway)}; |
1298 | 1321 |
1299 StaticSocketDataProvider data( | 1322 StaticSocketDataProvider data( |
1300 reads, arraysize(reads), writes, arraysize(writes)); | 1323 reads, arraysize(reads), writes, arraysize(writes)); |
1301 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1324 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1302 | 1325 |
1303 CreateNetworkSession(); | 1326 CreateNetworkSession(); |
1304 CreateInsecureSpdySession(); | 1327 CreateInsecureSpdySession(); |
1305 | 1328 |
1306 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 1329 base::WeakPtr<SpdyStream> spdy_stream1 = |
1307 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1330 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 1331 MEDIUM, NetLogWithSource()); |
1308 ASSERT_TRUE(spdy_stream1); | 1332 ASSERT_TRUE(spdy_stream1); |
1309 test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr); | 1333 test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr); |
1310 spdy_stream1->SetDelegate(&delegate); | 1334 spdy_stream1->SetDelegate(&delegate); |
1311 | 1335 |
1312 session_->set_connection_at_risk_of_loss_time( | 1336 session_->set_connection_at_risk_of_loss_time( |
1313 base::TimeDelta::FromSeconds(0)); | 1337 base::TimeDelta::FromSeconds(0)); |
1314 session_->set_hung_interval(base::TimeDelta::FromSeconds(0)); | 1338 session_->set_hung_interval(base::TimeDelta::FromSeconds(0)); |
1315 | 1339 |
1316 // Send a PING frame. | 1340 // Send a PING frame. |
1317 session_->WritePingFrame(1, false); | 1341 session_->WritePingFrame(1, false); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1361 MockWrite writes[] = {CreateMockWrite(settings_ack, 1)}; | 1385 MockWrite writes[] = {CreateMockWrite(settings_ack, 1)}; |
1362 | 1386 |
1363 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 1387 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
1364 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1388 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1365 | 1389 |
1366 CreateNetworkSession(); | 1390 CreateNetworkSession(); |
1367 CreateInsecureSpdySession(); | 1391 CreateInsecureSpdySession(); |
1368 | 1392 |
1369 // Create the maximum number of concurrent streams. | 1393 // Create the maximum number of concurrent streams. |
1370 for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) { | 1394 for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) { |
1371 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 1395 base::WeakPtr<SpdyStream> spdy_stream = |
1372 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1396 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, |
| 1397 test_url_, MEDIUM, NetLogWithSource()); |
1373 ASSERT_TRUE(spdy_stream); | 1398 ASSERT_TRUE(spdy_stream); |
1374 } | 1399 } |
1375 | 1400 |
1376 StreamReleaserCallback stream_releaser; | 1401 StreamReleaserCallback stream_releaser; |
1377 SpdyStreamRequest request; | 1402 SpdyStreamRequest request; |
1378 ASSERT_EQ(ERR_IO_PENDING, | 1403 ASSERT_EQ(ERR_IO_PENDING, |
1379 request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, | 1404 request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
1380 MEDIUM, BoundNetLog(), | 1405 MEDIUM, NetLogWithSource(), |
1381 stream_releaser.MakeCallback(&request))); | 1406 stream_releaser.MakeCallback(&request))); |
1382 | 1407 |
1383 base::RunLoop().RunUntilIdle(); | 1408 base::RunLoop().RunUntilIdle(); |
1384 | 1409 |
1385 EXPECT_THAT(stream_releaser.WaitForResult(), IsOk()); | 1410 EXPECT_THAT(stream_releaser.WaitForResult(), IsOk()); |
1386 | 1411 |
1387 data.Resume(); | 1412 data.Resume(); |
1388 base::RunLoop().RunUntilIdle(); | 1413 base::RunLoop().RunUntilIdle(); |
1389 EXPECT_FALSE(session_); | 1414 EXPECT_FALSE(session_); |
1390 | 1415 |
(...skipping 20 matching lines...) Expand all Loading... |
1411 | 1436 |
1412 // Initialize the SpdySetting with 1 max concurrent streams. | 1437 // Initialize the SpdySetting with 1 max concurrent streams. |
1413 spdy_session_pool_->http_server_properties()->SetSpdySetting( | 1438 spdy_session_pool_->http_server_properties()->SetSpdySetting( |
1414 test_server_, SETTINGS_MAX_CONCURRENT_STREAMS, | 1439 test_server_, SETTINGS_MAX_CONCURRENT_STREAMS, |
1415 SETTINGS_FLAG_PLEASE_PERSIST, 1); | 1440 SETTINGS_FLAG_PLEASE_PERSIST, 1); |
1416 | 1441 |
1417 CreateInsecureSpdySession(); | 1442 CreateInsecureSpdySession(); |
1418 | 1443 |
1419 // Leave room for only one more stream to be created. | 1444 // Leave room for only one more stream to be created. |
1420 for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) { | 1445 for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) { |
1421 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 1446 base::WeakPtr<SpdyStream> spdy_stream = |
1422 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1447 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, |
| 1448 test_url_, MEDIUM, NetLogWithSource()); |
1423 ASSERT_TRUE(spdy_stream); | 1449 ASSERT_TRUE(spdy_stream); |
1424 } | 1450 } |
1425 | 1451 |
1426 // Create 2 more streams. First will succeed. Second will be pending. | 1452 // Create 2 more streams. First will succeed. Second will be pending. |
1427 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 1453 base::WeakPtr<SpdyStream> spdy_stream1 = |
1428 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1454 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 1455 MEDIUM, NetLogWithSource()); |
1429 ASSERT_TRUE(spdy_stream1); | 1456 ASSERT_TRUE(spdy_stream1); |
1430 | 1457 |
1431 // Use scoped_ptr to let us invalidate the memory when we want to, to trigger | 1458 // Use scoped_ptr to let us invalidate the memory when we want to, to trigger |
1432 // a valgrind error if the callback is invoked when it's not supposed to be. | 1459 // a valgrind error if the callback is invoked when it's not supposed to be. |
1433 std::unique_ptr<TestCompletionCallback> callback(new TestCompletionCallback); | 1460 std::unique_ptr<TestCompletionCallback> callback(new TestCompletionCallback); |
1434 | 1461 |
1435 SpdyStreamRequest request; | 1462 SpdyStreamRequest request; |
1436 ASSERT_EQ(ERR_IO_PENDING, | 1463 ASSERT_EQ( |
1437 request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, | 1464 ERR_IO_PENDING, |
1438 MEDIUM, BoundNetLog(), callback->callback())); | 1465 request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 1466 MEDIUM, NetLogWithSource(), callback->callback())); |
1439 | 1467 |
1440 // Release the first one, this will allow the second to be created. | 1468 // Release the first one, this will allow the second to be created. |
1441 spdy_stream1->Cancel(); | 1469 spdy_stream1->Cancel(); |
1442 EXPECT_FALSE(spdy_stream1); | 1470 EXPECT_FALSE(spdy_stream1); |
1443 | 1471 |
1444 request.CancelRequest(); | 1472 request.CancelRequest(); |
1445 callback.reset(); | 1473 callback.reset(); |
1446 | 1474 |
1447 // Should not crash when running the pending callback. | 1475 // Should not crash when running the pending callback. |
1448 base::RunLoop().RunUntilIdle(); | 1476 base::RunLoop().RunUntilIdle(); |
(...skipping 205 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1654 }; | 1682 }; |
1655 MockRead reads[] = { | 1683 MockRead reads[] = { |
1656 MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF | 1684 MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF |
1657 }; | 1685 }; |
1658 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 1686 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
1659 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1687 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1660 | 1688 |
1661 CreateNetworkSession(); | 1689 CreateNetworkSession(); |
1662 CreateInsecureSpdySession(); | 1690 CreateInsecureSpdySession(); |
1663 | 1691 |
1664 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 1692 base::WeakPtr<SpdyStream> spdy_stream = |
1665 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1693 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1694 test_url_, MEDIUM, NetLogWithSource()); |
1666 test::StreamDelegateDoNothing delegate(spdy_stream); | 1695 test::StreamDelegateDoNothing delegate(spdy_stream); |
1667 spdy_stream->SetDelegate(&delegate); | 1696 spdy_stream->SetDelegate(&delegate); |
1668 | 1697 |
1669 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 1698 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
1670 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 1699 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
1671 | 1700 |
1672 // Write request headers & capture resulting histogram update. | 1701 // Write request headers & capture resulting histogram update. |
1673 base::HistogramTester histogram_tester; | 1702 base::HistogramTester histogram_tester; |
1674 | 1703 |
1675 base::RunLoop().RunUntilIdle(); | 1704 base::RunLoop().RunUntilIdle(); |
(...skipping 34 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1710 }; | 1739 }; |
1711 | 1740 |
1712 session_deps_.host_resolver->set_synchronous_mode(true); | 1741 session_deps_.host_resolver->set_synchronous_mode(true); |
1713 | 1742 |
1714 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 1743 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
1715 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1744 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1716 | 1745 |
1717 CreateNetworkSession(); | 1746 CreateNetworkSession(); |
1718 CreateInsecureSpdySession(); | 1747 CreateInsecureSpdySession(); |
1719 | 1748 |
1720 base::WeakPtr<SpdyStream> spdy_stream_lowest = CreateStreamSynchronously( | 1749 base::WeakPtr<SpdyStream> spdy_stream_lowest = |
1721 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 1750 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1751 test_url_, LOWEST, NetLogWithSource()); |
1722 ASSERT_TRUE(spdy_stream_lowest); | 1752 ASSERT_TRUE(spdy_stream_lowest); |
1723 EXPECT_EQ(0u, spdy_stream_lowest->stream_id()); | 1753 EXPECT_EQ(0u, spdy_stream_lowest->stream_id()); |
1724 test::StreamDelegateDoNothing delegate_lowest(spdy_stream_lowest); | 1754 test::StreamDelegateDoNothing delegate_lowest(spdy_stream_lowest); |
1725 spdy_stream_lowest->SetDelegate(&delegate_lowest); | 1755 spdy_stream_lowest->SetDelegate(&delegate_lowest); |
1726 | 1756 |
1727 base::WeakPtr<SpdyStream> spdy_stream_highest = | 1757 base::WeakPtr<SpdyStream> spdy_stream_highest = |
1728 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, | 1758 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
1729 test_url_, HIGHEST, BoundNetLog()); | 1759 test_url_, HIGHEST, NetLogWithSource()); |
1730 ASSERT_TRUE(spdy_stream_highest); | 1760 ASSERT_TRUE(spdy_stream_highest); |
1731 EXPECT_EQ(0u, spdy_stream_highest->stream_id()); | 1761 EXPECT_EQ(0u, spdy_stream_highest->stream_id()); |
1732 test::StreamDelegateDoNothing delegate_highest(spdy_stream_highest); | 1762 test::StreamDelegateDoNothing delegate_highest(spdy_stream_highest); |
1733 spdy_stream_highest->SetDelegate(&delegate_highest); | 1763 spdy_stream_highest->SetDelegate(&delegate_highest); |
1734 | 1764 |
1735 // Queue the lower priority one first. | 1765 // Queue the lower priority one first. |
1736 | 1766 |
1737 SpdyHeaderBlock headers_lowest( | 1767 SpdyHeaderBlock headers_lowest( |
1738 spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 1768 spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
1739 spdy_stream_lowest->SendRequestHeaders(std::move(headers_lowest), | 1769 spdy_stream_lowest->SendRequestHeaders(std::move(headers_lowest), |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1771 session_deps_.host_resolver->set_synchronous_mode(true); | 1801 session_deps_.host_resolver->set_synchronous_mode(true); |
1772 | 1802 |
1773 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 1803 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
1774 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1804 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1775 | 1805 |
1776 CreateNetworkSession(); | 1806 CreateNetworkSession(); |
1777 CreateInsecureSpdySession(); | 1807 CreateInsecureSpdySession(); |
1778 | 1808 |
1779 base::WeakPtr<SpdyStream> spdy_stream1 = | 1809 base::WeakPtr<SpdyStream> spdy_stream1 = |
1780 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, | 1810 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
1781 test_url_, HIGHEST, BoundNetLog()); | 1811 test_url_, HIGHEST, NetLogWithSource()); |
1782 ASSERT_TRUE(spdy_stream1); | 1812 ASSERT_TRUE(spdy_stream1); |
1783 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 1813 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
1784 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 1814 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
1785 spdy_stream1->SetDelegate(&delegate1); | 1815 spdy_stream1->SetDelegate(&delegate1); |
1786 | 1816 |
1787 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 1817 base::WeakPtr<SpdyStream> spdy_stream2 = |
1788 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 1818 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1819 test_url_, LOWEST, NetLogWithSource()); |
1789 ASSERT_TRUE(spdy_stream2); | 1820 ASSERT_TRUE(spdy_stream2); |
1790 EXPECT_EQ(0u, spdy_stream2->stream_id()); | 1821 EXPECT_EQ(0u, spdy_stream2->stream_id()); |
1791 test::StreamDelegateDoNothing delegate2(spdy_stream2); | 1822 test::StreamDelegateDoNothing delegate2(spdy_stream2); |
1792 spdy_stream2->SetDelegate(&delegate2); | 1823 spdy_stream2->SetDelegate(&delegate2); |
1793 | 1824 |
1794 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 1825 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
1795 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 1826 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
1796 | 1827 |
1797 SpdyHeaderBlock headers2(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 1828 SpdyHeaderBlock headers2(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
1798 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); | 1829 spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
(...skipping 28 matching lines...) Expand all Loading... |
1827 | 1858 |
1828 MockRead reads[] = { | 1859 MockRead reads[] = { |
1829 MockRead(ASYNC, 0, 0) // EOF | 1860 MockRead(ASYNC, 0, 0) // EOF |
1830 }; | 1861 }; |
1831 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 1862 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
1832 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1863 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1833 | 1864 |
1834 CreateNetworkSession(); | 1865 CreateNetworkSession(); |
1835 CreateInsecureSpdySession(); | 1866 CreateInsecureSpdySession(); |
1836 | 1867 |
1837 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 1868 base::WeakPtr<SpdyStream> spdy_stream1 = |
1838 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, HIGHEST, BoundNetLog()); | 1869 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 1870 HIGHEST, NetLogWithSource()); |
1839 ASSERT_TRUE(spdy_stream1); | 1871 ASSERT_TRUE(spdy_stream1); |
1840 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 1872 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
1841 | 1873 |
1842 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 1874 base::WeakPtr<SpdyStream> spdy_stream2 = |
1843 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 1875 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 1876 LOWEST, NetLogWithSource()); |
1844 ASSERT_TRUE(spdy_stream2); | 1877 ASSERT_TRUE(spdy_stream2); |
1845 EXPECT_EQ(0u, spdy_stream2->stream_id()); | 1878 EXPECT_EQ(0u, spdy_stream2->stream_id()); |
1846 | 1879 |
1847 test::ClosingDelegate delegate1(spdy_stream1); | 1880 test::ClosingDelegate delegate1(spdy_stream1); |
1848 spdy_stream1->SetDelegate(&delegate1); | 1881 spdy_stream1->SetDelegate(&delegate1); |
1849 | 1882 |
1850 test::ClosingDelegate delegate2(spdy_stream2); | 1883 test::ClosingDelegate delegate2(spdy_stream2); |
1851 spdy_stream2->SetDelegate(&delegate2); | 1884 spdy_stream2->SetDelegate(&delegate2); |
1852 | 1885 |
1853 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 1886 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
(...skipping 23 matching lines...) Expand all Loading... |
1877 // then close the session. Nothing should blow up. | 1910 // then close the session. Nothing should blow up. |
1878 TEST_F(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) { | 1911 TEST_F(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) { |
1879 session_deps_.host_resolver->set_synchronous_mode(true); | 1912 session_deps_.host_resolver->set_synchronous_mode(true); |
1880 | 1913 |
1881 SequencedSocketData data(nullptr, 0, nullptr, 0); | 1914 SequencedSocketData data(nullptr, 0, nullptr, 0); |
1882 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1915 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1883 | 1916 |
1884 CreateNetworkSession(); | 1917 CreateNetworkSession(); |
1885 CreateInsecureSpdySession(); | 1918 CreateInsecureSpdySession(); |
1886 | 1919 |
1887 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 1920 base::WeakPtr<SpdyStream> spdy_stream1 = |
1888 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, HIGHEST, BoundNetLog()); | 1921 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 1922 HIGHEST, NetLogWithSource()); |
1889 ASSERT_TRUE(spdy_stream1); | 1923 ASSERT_TRUE(spdy_stream1); |
1890 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 1924 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
1891 | 1925 |
1892 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 1926 base::WeakPtr<SpdyStream> spdy_stream2 = |
1893 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 1927 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 1928 LOWEST, NetLogWithSource()); |
1894 ASSERT_TRUE(spdy_stream2); | 1929 ASSERT_TRUE(spdy_stream2); |
1895 EXPECT_EQ(0u, spdy_stream2->stream_id()); | 1930 EXPECT_EQ(0u, spdy_stream2->stream_id()); |
1896 | 1931 |
1897 // Make |spdy_stream1| close |spdy_stream2|. | 1932 // Make |spdy_stream1| close |spdy_stream2|. |
1898 test::ClosingDelegate delegate1(spdy_stream2); | 1933 test::ClosingDelegate delegate1(spdy_stream2); |
1899 spdy_stream1->SetDelegate(&delegate1); | 1934 spdy_stream1->SetDelegate(&delegate1); |
1900 | 1935 |
1901 // Make |spdy_stream2| close |spdy_stream1|. | 1936 // Make |spdy_stream2| close |spdy_stream1|. |
1902 test::ClosingDelegate delegate2(spdy_stream1); | 1937 test::ClosingDelegate delegate2(spdy_stream1); |
1903 spdy_stream2->SetDelegate(&delegate2); | 1938 spdy_stream2->SetDelegate(&delegate2); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1941 MockRead reads[] = { | 1976 MockRead reads[] = { |
1942 MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF | 1977 MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF |
1943 }; | 1978 }; |
1944 | 1979 |
1945 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 1980 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
1946 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1981 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1947 | 1982 |
1948 CreateNetworkSession(); | 1983 CreateNetworkSession(); |
1949 CreateInsecureSpdySession(); | 1984 CreateInsecureSpdySession(); |
1950 | 1985 |
1951 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 1986 base::WeakPtr<SpdyStream> spdy_stream1 = |
1952 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1987 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1988 test_url_, MEDIUM, NetLogWithSource()); |
1953 ASSERT_TRUE(spdy_stream1); | 1989 ASSERT_TRUE(spdy_stream1); |
1954 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 1990 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
1955 | 1991 |
1956 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 1992 base::WeakPtr<SpdyStream> spdy_stream2 = |
1957 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 1993 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 1994 test_url_, MEDIUM, NetLogWithSource()); |
1958 ASSERT_TRUE(spdy_stream2); | 1995 ASSERT_TRUE(spdy_stream2); |
1959 EXPECT_EQ(0u, spdy_stream2->stream_id()); | 1996 EXPECT_EQ(0u, spdy_stream2->stream_id()); |
1960 | 1997 |
1961 test::ClosingDelegate delegate1(spdy_stream1); | 1998 test::ClosingDelegate delegate1(spdy_stream1); |
1962 spdy_stream1->SetDelegate(&delegate1); | 1999 spdy_stream1->SetDelegate(&delegate1); |
1963 | 2000 |
1964 test::ClosingDelegate delegate2(spdy_stream2); | 2001 test::ClosingDelegate delegate2(spdy_stream2); |
1965 spdy_stream2->SetDelegate(&delegate2); | 2002 spdy_stream2->SetDelegate(&delegate2); |
1966 | 2003 |
1967 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2004 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
(...skipping 42 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2010 MockRead reads[] = { | 2047 MockRead reads[] = { |
2011 MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF | 2048 MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF |
2012 }; | 2049 }; |
2013 | 2050 |
2014 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2051 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2015 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2052 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2016 | 2053 |
2017 CreateNetworkSession(); | 2054 CreateNetworkSession(); |
2018 CreateInsecureSpdySession(); | 2055 CreateInsecureSpdySession(); |
2019 | 2056 |
2020 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2057 base::WeakPtr<SpdyStream> spdy_stream1 = |
2021 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2058 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2059 test_url_, MEDIUM, NetLogWithSource()); |
2022 ASSERT_TRUE(spdy_stream1); | 2060 ASSERT_TRUE(spdy_stream1); |
2023 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2061 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2024 | 2062 |
2025 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 2063 base::WeakPtr<SpdyStream> spdy_stream2 = |
2026 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2064 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2065 test_url_, MEDIUM, NetLogWithSource()); |
2027 ASSERT_TRUE(spdy_stream2); | 2066 ASSERT_TRUE(spdy_stream2); |
2028 EXPECT_EQ(0u, spdy_stream2->stream_id()); | 2067 EXPECT_EQ(0u, spdy_stream2->stream_id()); |
2029 | 2068 |
2030 // Make |spdy_stream1| close |spdy_stream2|. | 2069 // Make |spdy_stream1| close |spdy_stream2|. |
2031 test::ClosingDelegate delegate1(spdy_stream2); | 2070 test::ClosingDelegate delegate1(spdy_stream2); |
2032 spdy_stream1->SetDelegate(&delegate1); | 2071 spdy_stream1->SetDelegate(&delegate1); |
2033 | 2072 |
2034 // Make |spdy_stream2| close |spdy_stream1|. | 2073 // Make |spdy_stream2| close |spdy_stream1|. |
2035 test::ClosingDelegate delegate2(spdy_stream1); | 2074 test::ClosingDelegate delegate2(spdy_stream1); |
2036 spdy_stream2->SetDelegate(&delegate2); | 2075 spdy_stream2->SetDelegate(&delegate2); |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2103 | 2142 |
2104 MockRead reads[] = { | 2143 MockRead reads[] = { |
2105 MockRead(ASYNC, 0, 2) // EOF | 2144 MockRead(ASYNC, 0, 2) // EOF |
2106 }; | 2145 }; |
2107 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2146 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2108 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2147 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2109 | 2148 |
2110 CreateNetworkSession(); | 2149 CreateNetworkSession(); |
2111 CreateInsecureSpdySession(); | 2150 CreateInsecureSpdySession(); |
2112 | 2151 |
2113 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 2152 base::WeakPtr<SpdyStream> spdy_stream = |
2114 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2153 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2154 test_url_, MEDIUM, NetLogWithSource()); |
2115 ASSERT_TRUE(spdy_stream); | 2155 ASSERT_TRUE(spdy_stream); |
2116 EXPECT_EQ(0u, spdy_stream->stream_id()); | 2156 EXPECT_EQ(0u, spdy_stream->stream_id()); |
2117 | 2157 |
2118 SessionClosingDelegate delegate(spdy_stream, session_); | 2158 SessionClosingDelegate delegate(spdy_stream, session_); |
2119 spdy_stream->SetDelegate(&delegate); | 2159 spdy_stream->SetDelegate(&delegate); |
2120 | 2160 |
2121 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2161 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2122 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 2162 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
2123 | 2163 |
2124 EXPECT_EQ(0u, spdy_stream->stream_id()); | 2164 EXPECT_EQ(0u, spdy_stream->stream_id()); |
(...skipping 123 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2248 | 2288 |
2249 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2289 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2250 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2290 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2251 | 2291 |
2252 CreateNetworkSession(); | 2292 CreateNetworkSession(); |
2253 CreateInsecureSpdySession(); | 2293 CreateInsecureSpdySession(); |
2254 | 2294 |
2255 // Read the settings frame. | 2295 // Read the settings frame. |
2256 base::RunLoop().RunUntilIdle(); | 2296 base::RunLoop().RunUntilIdle(); |
2257 | 2297 |
2258 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2298 base::WeakPtr<SpdyStream> spdy_stream1 = |
2259 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 2299 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2300 test_url_, LOWEST, NetLogWithSource()); |
2260 ASSERT_TRUE(spdy_stream1); | 2301 ASSERT_TRUE(spdy_stream1); |
2261 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2302 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2262 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 2303 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
2263 spdy_stream1->SetDelegate(&delegate1); | 2304 spdy_stream1->SetDelegate(&delegate1); |
2264 | 2305 |
2265 TestCompletionCallback callback2; | 2306 TestCompletionCallback callback2; |
2266 SpdyStreamRequest request2; | 2307 SpdyStreamRequest request2; |
2267 ASSERT_EQ( | 2308 ASSERT_EQ( |
2268 ERR_IO_PENDING, | 2309 ERR_IO_PENDING, |
2269 request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, | 2310 request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, |
2270 LOWEST, BoundNetLog(), callback2.callback())); | 2311 LOWEST, NetLogWithSource(), callback2.callback())); |
2271 | 2312 |
2272 TestCompletionCallback callback3; | 2313 TestCompletionCallback callback3; |
2273 SpdyStreamRequest request3; | 2314 SpdyStreamRequest request3; |
2274 ASSERT_EQ( | 2315 ASSERT_EQ( |
2275 ERR_IO_PENDING, | 2316 ERR_IO_PENDING, |
2276 request3.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, | 2317 request3.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, |
2277 LOWEST, BoundNetLog(), callback3.callback())); | 2318 LOWEST, NetLogWithSource(), callback3.callback())); |
2278 | 2319 |
2279 EXPECT_EQ(0u, session_->num_active_streams()); | 2320 EXPECT_EQ(0u, session_->num_active_streams()); |
2280 EXPECT_EQ(1u, session_->num_created_streams()); | 2321 EXPECT_EQ(1u, session_->num_created_streams()); |
2281 EXPECT_EQ(2u, session_->pending_create_stream_queue_size(LOWEST)); | 2322 EXPECT_EQ(2u, session_->pending_create_stream_queue_size(LOWEST)); |
2282 | 2323 |
2283 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2324 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2284 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 2325 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
2285 | 2326 |
2286 // Run until 1st stream is activated and then closed. | 2327 // Run until 1st stream is activated and then closed. |
2287 EXPECT_EQ(0u, delegate1.stream_id()); | 2328 EXPECT_EQ(0u, delegate1.stream_id()); |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2351 }; | 2392 }; |
2352 | 2393 |
2353 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); | 2394 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); |
2354 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2395 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2355 | 2396 |
2356 CreateNetworkSession(); | 2397 CreateNetworkSession(); |
2357 CreateInsecureSpdySession(); | 2398 CreateInsecureSpdySession(); |
2358 | 2399 |
2359 // Leave room for only one more stream to be created. | 2400 // Leave room for only one more stream to be created. |
2360 for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) { | 2401 for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) { |
2361 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 2402 base::WeakPtr<SpdyStream> spdy_stream = |
2362 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2403 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, |
| 2404 test_url_, MEDIUM, NetLogWithSource()); |
2363 ASSERT_TRUE(spdy_stream); | 2405 ASSERT_TRUE(spdy_stream); |
2364 } | 2406 } |
2365 | 2407 |
2366 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2408 base::WeakPtr<SpdyStream> spdy_stream1 = |
2367 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 2409 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 2410 LOWEST, NetLogWithSource()); |
2368 ASSERT_TRUE(spdy_stream1); | 2411 ASSERT_TRUE(spdy_stream1); |
2369 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2412 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2370 | 2413 |
2371 TestCompletionCallback callback2; | 2414 TestCompletionCallback callback2; |
2372 SpdyStreamRequest request2; | 2415 SpdyStreamRequest request2; |
2373 ASSERT_EQ(ERR_IO_PENDING, request2.StartRequest( | 2416 ASSERT_EQ( |
2374 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, | 2417 ERR_IO_PENDING, |
2375 LOWEST, BoundNetLog(), callback2.callback())); | 2418 request2.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 2419 LOWEST, NetLogWithSource(), callback2.callback())); |
2376 | 2420 |
2377 TestCompletionCallback callback3; | 2421 TestCompletionCallback callback3; |
2378 SpdyStreamRequest request3; | 2422 SpdyStreamRequest request3; |
2379 ASSERT_EQ(ERR_IO_PENDING, request3.StartRequest( | 2423 ASSERT_EQ( |
2380 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, | 2424 ERR_IO_PENDING, |
2381 LOWEST, BoundNetLog(), callback3.callback())); | 2425 request3.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 2426 LOWEST, NetLogWithSource(), callback3.callback())); |
2382 | 2427 |
2383 EXPECT_EQ(0u, session_->num_active_streams()); | 2428 EXPECT_EQ(0u, session_->num_active_streams()); |
2384 EXPECT_EQ(kInitialMaxConcurrentStreams, session_->num_created_streams()); | 2429 EXPECT_EQ(kInitialMaxConcurrentStreams, session_->num_created_streams()); |
2385 EXPECT_EQ(2u, session_->pending_create_stream_queue_size(LOWEST)); | 2430 EXPECT_EQ(2u, session_->pending_create_stream_queue_size(LOWEST)); |
2386 | 2431 |
2387 // Cancel the first stream; this will allow the second stream to be created. | 2432 // Cancel the first stream; this will allow the second stream to be created. |
2388 EXPECT_TRUE(spdy_stream1); | 2433 EXPECT_TRUE(spdy_stream1); |
2389 spdy_stream1->Cancel(); | 2434 spdy_stream1->Cancel(); |
2390 EXPECT_FALSE(spdy_stream1); | 2435 EXPECT_FALSE(spdy_stream1); |
2391 | 2436 |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2458 MockRead(ASYNC, 0, 7) // EOF | 2503 MockRead(ASYNC, 0, 7) // EOF |
2459 }; | 2504 }; |
2460 | 2505 |
2461 // Create SpdySession and SpdyStream and send the request. | 2506 // Create SpdySession and SpdyStream and send the request. |
2462 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2507 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2463 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2508 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2464 | 2509 |
2465 CreateNetworkSession(); | 2510 CreateNetworkSession(); |
2466 CreateInsecureSpdySession(); | 2511 CreateInsecureSpdySession(); |
2467 | 2512 |
2468 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2513 base::WeakPtr<SpdyStream> spdy_stream1 = |
2469 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2514 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2515 test_url_, MEDIUM, NetLogWithSource()); |
2470 ASSERT_TRUE(spdy_stream1); | 2516 ASSERT_TRUE(spdy_stream1); |
2471 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2517 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2472 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 2518 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
2473 spdy_stream1->SetDelegate(&delegate1); | 2519 spdy_stream1->SetDelegate(&delegate1); |
2474 | 2520 |
2475 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2521 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2476 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); | 2522 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
2477 | 2523 |
2478 // Set up the TaskObserver to verify SpdySession::DoReadLoop doesn't | 2524 // Set up the TaskObserver to verify SpdySession::DoReadLoop doesn't |
2479 // post a task. | 2525 // post a task. |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2517 CreateMockRead(resp1, 1), MockRead(ASYNC, 0, 2) // EOF | 2563 CreateMockRead(resp1, 1), MockRead(ASYNC, 0, 2) // EOF |
2518 }; | 2564 }; |
2519 | 2565 |
2520 // Create SpdySession and SpdyStream and send the request. | 2566 // Create SpdySession and SpdyStream and send the request. |
2521 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2567 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2522 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2568 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2523 | 2569 |
2524 CreateNetworkSession(); | 2570 CreateNetworkSession(); |
2525 CreateInsecureSpdySession(); | 2571 CreateInsecureSpdySession(); |
2526 | 2572 |
2527 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2573 base::WeakPtr<SpdyStream> spdy_stream1 = |
2528 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2574 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2575 test_url_, MEDIUM, NetLogWithSource()); |
2529 ASSERT_TRUE(spdy_stream1); | 2576 ASSERT_TRUE(spdy_stream1); |
2530 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2577 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2531 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 2578 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
2532 spdy_stream1->SetDelegate(&delegate1); | 2579 spdy_stream1->SetDelegate(&delegate1); |
2533 | 2580 |
2534 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2581 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2535 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); | 2582 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
2536 | 2583 |
2537 // Set up the TaskObserver to verify that SpdySession::DoReadLoop posts a | 2584 // Set up the TaskObserver to verify that SpdySession::DoReadLoop posts a |
2538 // task. | 2585 // task. |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2584 MockRead(ASYNC, 0, 7) // EOF | 2631 MockRead(ASYNC, 0, 7) // EOF |
2585 }; | 2632 }; |
2586 | 2633 |
2587 // Create SpdySession and SpdyStream and send the request. | 2634 // Create SpdySession and SpdyStream and send the request. |
2588 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2635 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2589 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2636 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2590 | 2637 |
2591 CreateNetworkSession(); | 2638 CreateNetworkSession(); |
2592 CreateInsecureSpdySession(); | 2639 CreateInsecureSpdySession(); |
2593 | 2640 |
2594 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2641 base::WeakPtr<SpdyStream> spdy_stream1 = |
2595 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2642 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2643 test_url_, MEDIUM, NetLogWithSource()); |
2596 ASSERT_TRUE(spdy_stream1); | 2644 ASSERT_TRUE(spdy_stream1); |
2597 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2645 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2598 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 2646 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
2599 spdy_stream1->SetDelegate(&delegate1); | 2647 spdy_stream1->SetDelegate(&delegate1); |
2600 | 2648 |
2601 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2649 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2602 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); | 2650 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
2603 | 2651 |
2604 // Run until 1st read. | 2652 // Run until 1st read. |
2605 EXPECT_EQ(0u, delegate1.stream_id()); | 2653 EXPECT_EQ(0u, delegate1.stream_id()); |
(...skipping 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2662 MockRead(ASYNC, 0, 8) // EOF | 2710 MockRead(ASYNC, 0, 8) // EOF |
2663 }; | 2711 }; |
2664 | 2712 |
2665 // Create SpdySession and SpdyStream and send the request. | 2713 // Create SpdySession and SpdyStream and send the request. |
2666 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2714 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2667 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2715 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2668 | 2716 |
2669 CreateNetworkSession(); | 2717 CreateNetworkSession(); |
2670 CreateInsecureSpdySession(); | 2718 CreateInsecureSpdySession(); |
2671 | 2719 |
2672 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2720 base::WeakPtr<SpdyStream> spdy_stream1 = |
2673 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2721 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2722 test_url_, MEDIUM, NetLogWithSource()); |
2674 ASSERT_TRUE(spdy_stream1); | 2723 ASSERT_TRUE(spdy_stream1); |
2675 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2724 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2676 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 2725 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
2677 spdy_stream1->SetDelegate(&delegate1); | 2726 spdy_stream1->SetDelegate(&delegate1); |
2678 | 2727 |
2679 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2728 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2680 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); | 2729 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
2681 | 2730 |
2682 // Set up the TaskObserver to verify SpdySession::DoReadLoop posts a task. | 2731 // Set up the TaskObserver to verify SpdySession::DoReadLoop posts a task. |
2683 SpdySessionTestTaskObserver observer("spdy_session.cc", "DoReadLoop"); | 2732 SpdySessionTestTaskObserver observer("spdy_session.cc", "DoReadLoop"); |
(...skipping 82 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2766 MockRead(ASYNC, 0, 13) // EOF | 2815 MockRead(ASYNC, 0, 13) // EOF |
2767 }; | 2816 }; |
2768 | 2817 |
2769 // Create SpdySession and SpdyStream and send the request. | 2818 // Create SpdySession and SpdyStream and send the request. |
2770 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2819 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2771 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2820 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2772 | 2821 |
2773 CreateNetworkSession(); | 2822 CreateNetworkSession(); |
2774 CreateInsecureSpdySession(); | 2823 CreateInsecureSpdySession(); |
2775 | 2824 |
2776 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2825 base::WeakPtr<SpdyStream> spdy_stream1 = |
2777 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2826 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2827 test_url_, MEDIUM, NetLogWithSource()); |
2778 ASSERT_TRUE(spdy_stream1); | 2828 ASSERT_TRUE(spdy_stream1); |
2779 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2829 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2780 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 2830 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
2781 spdy_stream1->SetDelegate(&delegate1); | 2831 spdy_stream1->SetDelegate(&delegate1); |
2782 | 2832 |
2783 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2833 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2784 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); | 2834 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
2785 | 2835 |
2786 // Set up the TaskObserver to monitor SpdySession::DoReadLoop | 2836 // Set up the TaskObserver to monitor SpdySession::DoReadLoop |
2787 // posting of tasks. | 2837 // posting of tasks. |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2827 CreateMockRead(body1, 3), CreateMockRead(goaway, 4), | 2877 CreateMockRead(body1, 3), CreateMockRead(goaway, 4), |
2828 }; | 2878 }; |
2829 | 2879 |
2830 // Create SpdySession and SpdyStream and send the request. | 2880 // Create SpdySession and SpdyStream and send the request. |
2831 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 2881 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
2832 session_deps_.socket_factory->AddSocketDataProvider(&data); | 2882 session_deps_.socket_factory->AddSocketDataProvider(&data); |
2833 | 2883 |
2834 CreateNetworkSession(); | 2884 CreateNetworkSession(); |
2835 CreateInsecureSpdySession(); | 2885 CreateInsecureSpdySession(); |
2836 | 2886 |
2837 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 2887 base::WeakPtr<SpdyStream> spdy_stream1 = |
2838 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 2888 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 2889 test_url_, MEDIUM, NetLogWithSource()); |
2839 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 2890 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
2840 spdy_stream1->SetDelegate(&delegate1); | 2891 spdy_stream1->SetDelegate(&delegate1); |
2841 ASSERT_TRUE(spdy_stream1); | 2892 ASSERT_TRUE(spdy_stream1); |
2842 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2893 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
2843 | 2894 |
2844 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 2895 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
2845 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); | 2896 spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
2846 | 2897 |
2847 // Run until 1st read. | 2898 // Run until 1st read. |
2848 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 2899 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2908 // post a task asynchronously to try and close the session. | 2959 // post a task asynchronously to try and close the session. |
2909 TestCompletionCallback callback2; | 2960 TestCompletionCallback callback2; |
2910 HostPortPair host_port2("2.com", 80); | 2961 HostPortPair host_port2("2.com", 80); |
2911 scoped_refptr<TransportSocketParams> params2(new TransportSocketParams( | 2962 scoped_refptr<TransportSocketParams> params2(new TransportSocketParams( |
2912 host_port2, false, OnHostResolutionCallback(), | 2963 host_port2, false, OnHostResolutionCallback(), |
2913 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); | 2964 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); |
2914 std::unique_ptr<ClientSocketHandle> connection2(new ClientSocketHandle); | 2965 std::unique_ptr<ClientSocketHandle> connection2(new ClientSocketHandle); |
2915 EXPECT_EQ(ERR_IO_PENDING, | 2966 EXPECT_EQ(ERR_IO_PENDING, |
2916 connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY, | 2967 connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY, |
2917 ClientSocketPool::RespectLimits::ENABLED, | 2968 ClientSocketPool::RespectLimits::ENABLED, |
2918 callback2.callback(), pool, BoundNetLog())); | 2969 callback2.callback(), pool, NetLogWithSource())); |
2919 EXPECT_TRUE(pool->IsStalled()); | 2970 EXPECT_TRUE(pool->IsStalled()); |
2920 | 2971 |
2921 // The socket pool should close the connection asynchronously and establish a | 2972 // The socket pool should close the connection asynchronously and establish a |
2922 // new connection. | 2973 // new connection. |
2923 EXPECT_THAT(callback2.WaitForResult(), IsOk()); | 2974 EXPECT_THAT(callback2.WaitForResult(), IsOk()); |
2924 EXPECT_FALSE(pool->IsStalled()); | 2975 EXPECT_FALSE(pool->IsStalled()); |
2925 EXPECT_FALSE(session_); | 2976 EXPECT_FALSE(session_); |
2926 } | 2977 } |
2927 | 2978 |
2928 // Tests the case of a non-SPDY request closing an idle SPDY session when no | 2979 // Tests the case of a non-SPDY request closing an idle SPDY session when no |
(...skipping 24 matching lines...) Expand all Loading... |
2953 CreateNetworkSession(); | 3004 CreateNetworkSession(); |
2954 | 3005 |
2955 TransportClientSocketPool* pool = | 3006 TransportClientSocketPool* pool = |
2956 http_session_->GetTransportSocketPool( | 3007 http_session_->GetTransportSocketPool( |
2957 HttpNetworkSession::NORMAL_SOCKET_POOL); | 3008 HttpNetworkSession::NORMAL_SOCKET_POOL); |
2958 | 3009 |
2959 // Create an idle SPDY session. | 3010 // Create an idle SPDY session. |
2960 SpdySessionKey key1(HostPortPair("1.com", 80), ProxyServer::Direct(), | 3011 SpdySessionKey key1(HostPortPair("1.com", 80), ProxyServer::Direct(), |
2961 PRIVACY_MODE_DISABLED); | 3012 PRIVACY_MODE_DISABLED); |
2962 base::WeakPtr<SpdySession> session1 = ::net::CreateInsecureSpdySession( | 3013 base::WeakPtr<SpdySession> session1 = ::net::CreateInsecureSpdySession( |
2963 http_session_.get(), key1, BoundNetLog()); | 3014 http_session_.get(), key1, NetLogWithSource()); |
2964 EXPECT_FALSE(pool->IsStalled()); | 3015 EXPECT_FALSE(pool->IsStalled()); |
2965 | 3016 |
2966 // Set up an alias for the idle SPDY session, increasing its ref count to 2. | 3017 // Set up an alias for the idle SPDY session, increasing its ref count to 2. |
2967 SpdySessionKey key2(HostPortPair("2.com", 80), ProxyServer::Direct(), | 3018 SpdySessionKey key2(HostPortPair("2.com", 80), ProxyServer::Direct(), |
2968 PRIVACY_MODE_DISABLED); | 3019 PRIVACY_MODE_DISABLED); |
2969 HostResolver::RequestInfo info(key2.host_port_pair()); | 3020 HostResolver::RequestInfo info(key2.host_port_pair()); |
2970 AddressList addresses; | 3021 AddressList addresses; |
2971 std::unique_ptr<HostResolver::Request> request; | 3022 std::unique_ptr<HostResolver::Request> request; |
2972 // Pre-populate the DNS cache, since a synchronous resolution is required in | 3023 // Pre-populate the DNS cache, since a synchronous resolution is required in |
2973 // order to create the alias. | 3024 // order to create the alias. |
2974 session_deps_.host_resolver->Resolve(info, DEFAULT_PRIORITY, &addresses, | 3025 session_deps_.host_resolver->Resolve(info, DEFAULT_PRIORITY, &addresses, |
2975 CompletionCallback(), &request, | 3026 CompletionCallback(), &request, |
2976 BoundNetLog()); | 3027 NetLogWithSource()); |
2977 // Get a session for |key2|, which should return the session created earlier. | 3028 // Get a session for |key2|, which should return the session created earlier. |
2978 base::WeakPtr<SpdySession> session2 = | 3029 base::WeakPtr<SpdySession> session2 = |
2979 spdy_session_pool_->FindAvailableSession(key2, GURL(), BoundNetLog()); | 3030 spdy_session_pool_->FindAvailableSession(key2, GURL(), |
| 3031 NetLogWithSource()); |
2980 ASSERT_EQ(session1.get(), session2.get()); | 3032 ASSERT_EQ(session1.get(), session2.get()); |
2981 EXPECT_FALSE(pool->IsStalled()); | 3033 EXPECT_FALSE(pool->IsStalled()); |
2982 | 3034 |
2983 // Trying to create a new connection should cause the pool to be stalled, and | 3035 // Trying to create a new connection should cause the pool to be stalled, and |
2984 // post a task asynchronously to try and close the session. | 3036 // post a task asynchronously to try and close the session. |
2985 TestCompletionCallback callback3; | 3037 TestCompletionCallback callback3; |
2986 HostPortPair host_port3("3.com", 80); | 3038 HostPortPair host_port3("3.com", 80); |
2987 scoped_refptr<TransportSocketParams> params3(new TransportSocketParams( | 3039 scoped_refptr<TransportSocketParams> params3(new TransportSocketParams( |
2988 host_port3, false, OnHostResolutionCallback(), | 3040 host_port3, false, OnHostResolutionCallback(), |
2989 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); | 3041 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); |
2990 std::unique_ptr<ClientSocketHandle> connection3(new ClientSocketHandle); | 3042 std::unique_ptr<ClientSocketHandle> connection3(new ClientSocketHandle); |
2991 EXPECT_EQ(ERR_IO_PENDING, | 3043 EXPECT_EQ(ERR_IO_PENDING, |
2992 connection3->Init(host_port3.ToString(), params3, DEFAULT_PRIORITY, | 3044 connection3->Init(host_port3.ToString(), params3, DEFAULT_PRIORITY, |
2993 ClientSocketPool::RespectLimits::ENABLED, | 3045 ClientSocketPool::RespectLimits::ENABLED, |
2994 callback3.callback(), pool, BoundNetLog())); | 3046 callback3.callback(), pool, NetLogWithSource())); |
2995 EXPECT_TRUE(pool->IsStalled()); | 3047 EXPECT_TRUE(pool->IsStalled()); |
2996 | 3048 |
2997 // The socket pool should close the connection asynchronously and establish a | 3049 // The socket pool should close the connection asynchronously and establish a |
2998 // new connection. | 3050 // new connection. |
2999 EXPECT_THAT(callback3.WaitForResult(), IsOk()); | 3051 EXPECT_THAT(callback3.WaitForResult(), IsOk()); |
3000 EXPECT_FALSE(pool->IsStalled()); | 3052 EXPECT_FALSE(pool->IsStalled()); |
3001 EXPECT_FALSE(session1); | 3053 EXPECT_FALSE(session1); |
3002 EXPECT_FALSE(session2); | 3054 EXPECT_FALSE(session2); |
3003 } | 3055 } |
3004 | 3056 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3038 http_session_->GetTransportSocketPool( | 3090 http_session_->GetTransportSocketPool( |
3039 HttpNetworkSession::NORMAL_SOCKET_POOL); | 3091 HttpNetworkSession::NORMAL_SOCKET_POOL); |
3040 | 3092 |
3041 // Create a SPDY session. | 3093 // Create a SPDY session. |
3042 CreateInsecureSpdySession(); | 3094 CreateInsecureSpdySession(); |
3043 EXPECT_FALSE(pool->IsStalled()); | 3095 EXPECT_FALSE(pool->IsStalled()); |
3044 | 3096 |
3045 // Create a stream using the session, and send a request. | 3097 // Create a stream using the session, and send a request. |
3046 | 3098 |
3047 TestCompletionCallback callback1; | 3099 TestCompletionCallback callback1; |
3048 base::WeakPtr<SpdyStream> spdy_stream1 = | 3100 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( |
3049 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, | 3101 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, DEFAULT_PRIORITY, |
3050 test_url_, DEFAULT_PRIORITY, BoundNetLog()); | 3102 NetLogWithSource()); |
3051 ASSERT_TRUE(spdy_stream1.get()); | 3103 ASSERT_TRUE(spdy_stream1.get()); |
3052 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 3104 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
3053 spdy_stream1->SetDelegate(&delegate1); | 3105 spdy_stream1->SetDelegate(&delegate1); |
3054 | 3106 |
3055 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 3107 SpdyHeaderBlock headers1(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
3056 EXPECT_EQ(ERR_IO_PENDING, spdy_stream1->SendRequestHeaders( | 3108 EXPECT_EQ(ERR_IO_PENDING, spdy_stream1->SendRequestHeaders( |
3057 std::move(headers1), NO_MORE_DATA_TO_SEND)); | 3109 std::move(headers1), NO_MORE_DATA_TO_SEND)); |
3058 | 3110 |
3059 base::RunLoop().RunUntilIdle(); | 3111 base::RunLoop().RunUntilIdle(); |
3060 | 3112 |
3061 // Trying to create a new connection should cause the pool to be stalled, and | 3113 // Trying to create a new connection should cause the pool to be stalled, and |
3062 // post a task asynchronously to try and close the session. | 3114 // post a task asynchronously to try and close the session. |
3063 TestCompletionCallback callback2; | 3115 TestCompletionCallback callback2; |
3064 HostPortPair host_port2("2.com", 80); | 3116 HostPortPair host_port2("2.com", 80); |
3065 scoped_refptr<TransportSocketParams> params2(new TransportSocketParams( | 3117 scoped_refptr<TransportSocketParams> params2(new TransportSocketParams( |
3066 host_port2, false, OnHostResolutionCallback(), | 3118 host_port2, false, OnHostResolutionCallback(), |
3067 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); | 3119 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); |
3068 std::unique_ptr<ClientSocketHandle> connection2(new ClientSocketHandle); | 3120 std::unique_ptr<ClientSocketHandle> connection2(new ClientSocketHandle); |
3069 EXPECT_EQ(ERR_IO_PENDING, | 3121 EXPECT_EQ(ERR_IO_PENDING, |
3070 connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY, | 3122 connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY, |
3071 ClientSocketPool::RespectLimits::ENABLED, | 3123 ClientSocketPool::RespectLimits::ENABLED, |
3072 callback2.callback(), pool, BoundNetLog())); | 3124 callback2.callback(), pool, NetLogWithSource())); |
3073 EXPECT_TRUE(pool->IsStalled()); | 3125 EXPECT_TRUE(pool->IsStalled()); |
3074 | 3126 |
3075 // Running the message loop should cause the socket pool to ask the SPDY | 3127 // Running the message loop should cause the socket pool to ask the SPDY |
3076 // session to close an idle socket, but since the socket is in use, nothing | 3128 // session to close an idle socket, but since the socket is in use, nothing |
3077 // happens. | 3129 // happens. |
3078 base::RunLoop().RunUntilIdle(); | 3130 base::RunLoop().RunUntilIdle(); |
3079 EXPECT_TRUE(pool->IsStalled()); | 3131 EXPECT_TRUE(pool->IsStalled()); |
3080 EXPECT_FALSE(callback2.have_result()); | 3132 EXPECT_FALSE(callback2.have_result()); |
3081 | 3133 |
3082 // Cancelling the request should result in the session's socket being | 3134 // Cancelling the request should result in the session's socket being |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3130 public: | 3182 public: |
3131 StreamCreatingDelegate(const base::WeakPtr<SpdyStream>& stream, | 3183 StreamCreatingDelegate(const base::WeakPtr<SpdyStream>& stream, |
3132 const base::WeakPtr<SpdySession>& session) | 3184 const base::WeakPtr<SpdySession>& session) |
3133 : StreamDelegateDoNothing(stream), | 3185 : StreamDelegateDoNothing(stream), |
3134 session_(session) {} | 3186 session_(session) {} |
3135 | 3187 |
3136 ~StreamCreatingDelegate() override {} | 3188 ~StreamCreatingDelegate() override {} |
3137 | 3189 |
3138 void OnClose(int status) override { | 3190 void OnClose(int status) override { |
3139 GURL url(kDefaultUrl); | 3191 GURL url(kDefaultUrl); |
3140 ignore_result( | 3192 ignore_result(CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, |
3141 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, | 3193 session_, url, MEDIUM, |
3142 session_, url, MEDIUM, BoundNetLog())); | 3194 NetLogWithSource())); |
3143 } | 3195 } |
3144 | 3196 |
3145 private: | 3197 private: |
3146 const base::WeakPtr<SpdySession> session_; | 3198 const base::WeakPtr<SpdySession> session_; |
3147 }; | 3199 }; |
3148 | 3200 |
3149 // Create another stream in response to a stream being reset. Nothing | 3201 // Create another stream in response to a stream being reset. Nothing |
3150 // should blow up. This is a regression test for | 3202 // should blow up. This is a regression test for |
3151 // http://crbug.com/263690 . | 3203 // http://crbug.com/263690 . |
3152 TEST_F(SpdySessionTest, CreateStreamOnStreamReset) { | 3204 TEST_F(SpdySessionTest, CreateStreamOnStreamReset) { |
(...skipping 10 matching lines...) Expand all Loading... |
3163 MockRead reads[] = { | 3215 MockRead reads[] = { |
3164 MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(rst, 2), | 3216 MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(rst, 2), |
3165 MockRead(ASYNC, ERR_IO_PENDING, 3), MockRead(ASYNC, 0, 4) // EOF | 3217 MockRead(ASYNC, ERR_IO_PENDING, 3), MockRead(ASYNC, 0, 4) // EOF |
3166 }; | 3218 }; |
3167 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3219 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3168 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3220 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3169 | 3221 |
3170 CreateNetworkSession(); | 3222 CreateNetworkSession(); |
3171 CreateInsecureSpdySession(); | 3223 CreateInsecureSpdySession(); |
3172 | 3224 |
3173 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 3225 base::WeakPtr<SpdyStream> spdy_stream = |
3174 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 3226 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 3227 test_url_, MEDIUM, NetLogWithSource()); |
3175 ASSERT_TRUE(spdy_stream); | 3228 ASSERT_TRUE(spdy_stream); |
3176 EXPECT_EQ(0u, spdy_stream->stream_id()); | 3229 EXPECT_EQ(0u, spdy_stream->stream_id()); |
3177 | 3230 |
3178 StreamCreatingDelegate delegate(spdy_stream, session_); | 3231 StreamCreatingDelegate delegate(spdy_stream, session_); |
3179 spdy_stream->SetDelegate(&delegate); | 3232 spdy_stream->SetDelegate(&delegate); |
3180 | 3233 |
3181 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 3234 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
3182 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 3235 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
3183 | 3236 |
3184 EXPECT_EQ(0u, spdy_stream->stream_id()); | 3237 EXPECT_EQ(0u, spdy_stream->stream_id()); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3224 CreateMockWrite(settings_ack, 3), | 3277 CreateMockWrite(settings_ack, 3), |
3225 }; | 3278 }; |
3226 | 3279 |
3227 session_deps_.host_resolver->set_synchronous_mode(true); | 3280 session_deps_.host_resolver->set_synchronous_mode(true); |
3228 | 3281 |
3229 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3282 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3230 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3283 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3231 | 3284 |
3232 CreateNetworkSession(); | 3285 CreateNetworkSession(); |
3233 CreateInsecureSpdySession(); | 3286 CreateInsecureSpdySession(); |
3234 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 3287 base::WeakPtr<SpdyStream> spdy_stream1 = |
3235 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 3288 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 3289 MEDIUM, NetLogWithSource()); |
3236 ASSERT_TRUE(spdy_stream1); | 3290 ASSERT_TRUE(spdy_stream1); |
3237 TestCompletionCallback callback1; | 3291 TestCompletionCallback callback1; |
3238 EXPECT_NE(spdy_stream1->send_window_size(), window_size); | 3292 EXPECT_NE(spdy_stream1->send_window_size(), window_size); |
3239 | 3293 |
3240 // Process the SETTINGS frame. | 3294 // Process the SETTINGS frame. |
3241 base::RunLoop().RunUntilIdle(); | 3295 base::RunLoop().RunUntilIdle(); |
3242 EXPECT_EQ(session_->stream_initial_send_window_size(), window_size); | 3296 EXPECT_EQ(session_->stream_initial_send_window_size(), window_size); |
3243 EXPECT_EQ(spdy_stream1->send_window_size(), window_size); | 3297 EXPECT_EQ(spdy_stream1->send_window_size(), window_size); |
3244 | 3298 |
3245 // Release the first one, this will allow the second to be created. | 3299 // Release the first one, this will allow the second to be created. |
3246 spdy_stream1->Cancel(); | 3300 spdy_stream1->Cancel(); |
3247 EXPECT_FALSE(spdy_stream1); | 3301 EXPECT_FALSE(spdy_stream1); |
3248 | 3302 |
3249 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 3303 base::WeakPtr<SpdyStream> spdy_stream2 = |
3250 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 3304 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 3305 MEDIUM, NetLogWithSource()); |
3251 ASSERT_TRUE(spdy_stream2); | 3306 ASSERT_TRUE(spdy_stream2); |
3252 EXPECT_EQ(spdy_stream2->send_window_size(), window_size); | 3307 EXPECT_EQ(spdy_stream2->send_window_size(), window_size); |
3253 spdy_stream2->Cancel(); | 3308 spdy_stream2->Cancel(); |
3254 EXPECT_FALSE(spdy_stream2); | 3309 EXPECT_FALSE(spdy_stream2); |
3255 | 3310 |
3256 EXPECT_TRUE(session_); | 3311 EXPECT_TRUE(session_); |
3257 data.Resume(); | 3312 data.Resume(); |
3258 base::RunLoop().RunUntilIdle(); | 3313 base::RunLoop().RunUntilIdle(); |
3259 EXPECT_FALSE(session_); | 3314 EXPECT_FALSE(session_); |
3260 } | 3315 } |
(...skipping 167 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3428 }; | 3483 }; |
3429 | 3484 |
3430 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3485 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3431 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3486 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3432 CreateNetworkSession(); | 3487 CreateNetworkSession(); |
3433 | 3488 |
3434 SpdySessionPoolPeer pool_peer(spdy_session_pool_); | 3489 SpdySessionPoolPeer pool_peer(spdy_session_pool_); |
3435 pool_peer.SetStreamInitialRecvWindowSize(stream_max_recv_window_size); | 3490 pool_peer.SetStreamInitialRecvWindowSize(stream_max_recv_window_size); |
3436 CreateInsecureSpdySession(); | 3491 CreateInsecureSpdySession(); |
3437 | 3492 |
3438 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 3493 base::WeakPtr<SpdyStream> spdy_stream = |
3439 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 3494 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 3495 test_url_, LOWEST, NetLogWithSource()); |
3440 EXPECT_EQ(stream_max_recv_window_size, spdy_stream->recv_window_size()); | 3496 EXPECT_EQ(stream_max_recv_window_size, spdy_stream->recv_window_size()); |
3441 | 3497 |
3442 test::StreamDelegateDoNothing delegate(spdy_stream); | 3498 test::StreamDelegateDoNothing delegate(spdy_stream); |
3443 spdy_stream->SetDelegate(&delegate); | 3499 spdy_stream->SetDelegate(&delegate); |
3444 | 3500 |
3445 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 3501 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
3446 EXPECT_EQ(ERR_IO_PENDING, spdy_stream->SendRequestHeaders( | 3502 EXPECT_EQ(ERR_IO_PENDING, spdy_stream->SendRequestHeaders( |
3447 std::move(headers), NO_MORE_DATA_TO_SEND)); | 3503 std::move(headers), NO_MORE_DATA_TO_SEND)); |
3448 | 3504 |
3449 // Request and response. | 3505 // Request and response. |
(...skipping 111 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3561 | 3617 |
3562 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3618 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3563 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3619 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3564 | 3620 |
3565 CreateNetworkSession(); | 3621 CreateNetworkSession(); |
3566 SpdySessionPoolPeer pool_peer(spdy_session_pool_); | 3622 SpdySessionPoolPeer pool_peer(spdy_session_pool_); |
3567 pool_peer.SetStreamInitialRecvWindowSize(stream_max_recv_window_size); | 3623 pool_peer.SetStreamInitialRecvWindowSize(stream_max_recv_window_size); |
3568 | 3624 |
3569 CreateInsecureSpdySession(); | 3625 CreateInsecureSpdySession(); |
3570 | 3626 |
3571 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 3627 base::WeakPtr<SpdyStream> spdy_stream = |
3572 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 3628 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 3629 test_url_, LOWEST, NetLogWithSource()); |
3573 test::StreamDelegateDoNothing delegate(spdy_stream); | 3630 test::StreamDelegateDoNothing delegate(spdy_stream); |
3574 spdy_stream->SetDelegate(&delegate); | 3631 spdy_stream->SetDelegate(&delegate); |
3575 | 3632 |
3576 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 3633 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
3577 EXPECT_EQ(ERR_IO_PENDING, spdy_stream->SendRequestHeaders( | 3634 EXPECT_EQ(ERR_IO_PENDING, spdy_stream->SendRequestHeaders( |
3578 std::move(headers), NO_MORE_DATA_TO_SEND)); | 3635 std::move(headers), NO_MORE_DATA_TO_SEND)); |
3579 | 3636 |
3580 // Request and response. | 3637 // Request and response. |
3581 base::RunLoop().RunUntilIdle(); | 3638 base::RunLoop().RunUntilIdle(); |
3582 EXPECT_TRUE(spdy_stream->IsLocallyClosed()); | 3639 EXPECT_TRUE(spdy_stream->IsLocallyClosed()); |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3645 }; | 3702 }; |
3646 | 3703 |
3647 // Create SpdySession and SpdyStream and send the request. | 3704 // Create SpdySession and SpdyStream and send the request. |
3648 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3705 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3649 session_deps_.host_resolver->set_synchronous_mode(true); | 3706 session_deps_.host_resolver->set_synchronous_mode(true); |
3650 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3707 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3651 | 3708 |
3652 CreateNetworkSession(); | 3709 CreateNetworkSession(); |
3653 CreateInsecureSpdySession(); | 3710 CreateInsecureSpdySession(); |
3654 | 3711 |
3655 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( | 3712 base::WeakPtr<SpdyStream> stream = |
3656 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 3713 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 3714 MEDIUM, NetLogWithSource()); |
3657 ASSERT_TRUE(stream); | 3715 ASSERT_TRUE(stream); |
3658 EXPECT_EQ(0u, stream->stream_id()); | 3716 EXPECT_EQ(0u, stream->stream_id()); |
3659 | 3717 |
3660 DropReceivedDataDelegate delegate(stream, msg_data); | 3718 DropReceivedDataDelegate delegate(stream, msg_data); |
3661 stream->SetDelegate(&delegate); | 3719 stream->SetDelegate(&delegate); |
3662 | 3720 |
3663 SpdyHeaderBlock headers( | 3721 SpdyHeaderBlock headers( |
3664 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kMsgDataSize)); | 3722 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kMsgDataSize)); |
3665 EXPECT_EQ(ERR_IO_PENDING, | 3723 EXPECT_EQ(ERR_IO_PENDING, |
3666 stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND)); | 3724 stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND)); |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3707 }; | 3765 }; |
3708 | 3766 |
3709 // Create SpdySession and SpdyStream and send the request. | 3767 // Create SpdySession and SpdyStream and send the request. |
3710 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3768 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3711 session_deps_.host_resolver->set_synchronous_mode(true); | 3769 session_deps_.host_resolver->set_synchronous_mode(true); |
3712 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3770 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3713 | 3771 |
3714 CreateNetworkSession(); | 3772 CreateNetworkSession(); |
3715 CreateInsecureSpdySession(); | 3773 CreateInsecureSpdySession(); |
3716 | 3774 |
3717 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( | 3775 base::WeakPtr<SpdyStream> stream = |
3718 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 3776 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 3777 MEDIUM, NetLogWithSource()); |
3719 ASSERT_TRUE(stream); | 3778 ASSERT_TRUE(stream); |
3720 EXPECT_EQ(0u, stream->stream_id()); | 3779 EXPECT_EQ(0u, stream->stream_id()); |
3721 | 3780 |
3722 test::StreamDelegateSendImmediate delegate(stream, msg_data); | 3781 test::StreamDelegateSendImmediate delegate(stream, msg_data); |
3723 stream->SetDelegate(&delegate); | 3782 stream->SetDelegate(&delegate); |
3724 | 3783 |
3725 SpdyHeaderBlock headers( | 3784 SpdyHeaderBlock headers( |
3726 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kMsgDataSize)); | 3785 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kMsgDataSize)); |
3727 EXPECT_EQ(ERR_IO_PENDING, | 3786 EXPECT_EQ(ERR_IO_PENDING, |
3728 stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND)); | 3787 stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND)); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3787 }; | 3846 }; |
3788 | 3847 |
3789 // Create SpdySession and SpdyStream and send the request. | 3848 // Create SpdySession and SpdyStream and send the request. |
3790 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3849 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3791 session_deps_.host_resolver->set_synchronous_mode(true); | 3850 session_deps_.host_resolver->set_synchronous_mode(true); |
3792 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3851 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3793 | 3852 |
3794 CreateNetworkSession(); | 3853 CreateNetworkSession(); |
3795 CreateInsecureSpdySession(); | 3854 CreateInsecureSpdySession(); |
3796 | 3855 |
3797 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( | 3856 base::WeakPtr<SpdyStream> stream = |
3798 SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 3857 CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| 3858 MEDIUM, NetLogWithSource()); |
3799 ASSERT_TRUE(stream); | 3859 ASSERT_TRUE(stream); |
3800 EXPECT_EQ(0u, stream->stream_id()); | 3860 EXPECT_EQ(0u, stream->stream_id()); |
3801 | 3861 |
3802 test::StreamDelegateSendImmediate delegate(stream, msg_data); | 3862 test::StreamDelegateSendImmediate delegate(stream, msg_data); |
3803 stream->SetDelegate(&delegate); | 3863 stream->SetDelegate(&delegate); |
3804 | 3864 |
3805 SpdyHeaderBlock headers( | 3865 SpdyHeaderBlock headers( |
3806 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kMsgDataSize)); | 3866 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kMsgDataSize)); |
3807 EXPECT_EQ(ERR_IO_PENDING, | 3867 EXPECT_EQ(ERR_IO_PENDING, |
3808 stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND)); | 3868 stream->SendRequestHeaders(std::move(headers), MORE_DATA_TO_SEND)); |
(...skipping 73 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3882 MockRead reads[] = { | 3942 MockRead reads[] = { |
3883 CreateMockRead(resp, 2), MockRead(ASYNC, 0, 3) // EOF | 3943 CreateMockRead(resp, 2), MockRead(ASYNC, 0, 3) // EOF |
3884 }; | 3944 }; |
3885 | 3945 |
3886 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 3946 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
3887 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3947 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3888 | 3948 |
3889 CreateNetworkSession(); | 3949 CreateNetworkSession(); |
3890 CreateInsecureSpdySession(); | 3950 CreateInsecureSpdySession(); |
3891 | 3951 |
3892 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( | 3952 base::WeakPtr<SpdyStream> stream = |
3893 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 3953 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 3954 test_url_, LOWEST, NetLogWithSource()); |
3894 ASSERT_TRUE(stream); | 3955 ASSERT_TRUE(stream); |
3895 | 3956 |
3896 test::StreamDelegateWithBody delegate(stream, kBodyDataStringPiece); | 3957 test::StreamDelegateWithBody delegate(stream, kBodyDataStringPiece); |
3897 stream->SetDelegate(&delegate); | 3958 stream->SetDelegate(&delegate); |
3898 | 3959 |
3899 EXPECT_FALSE(stream->send_stalled_by_flow_control()); | 3960 EXPECT_FALSE(stream->send_stalled_by_flow_control()); |
3900 | 3961 |
3901 SpdyHeaderBlock headers( | 3962 SpdyHeaderBlock headers( |
3902 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize)); | 3963 spdy_util_.ConstructPostHeaderBlock(kDefaultUrl, kBodyDataSize)); |
3903 EXPECT_EQ(ERR_IO_PENDING, | 3964 EXPECT_EQ(ERR_IO_PENDING, |
(...skipping 97 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4001 CreateMockRead(resp1, 4), CreateMockRead(resp2, 5), | 4062 CreateMockRead(resp1, 4), CreateMockRead(resp2, 5), |
4002 MockRead(ASYNC, 0, 6) // EOF | 4063 MockRead(ASYNC, 0, 6) // EOF |
4003 }; | 4064 }; |
4004 | 4065 |
4005 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4066 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4006 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4067 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4007 | 4068 |
4008 CreateNetworkSession(); | 4069 CreateNetworkSession(); |
4009 CreateInsecureSpdySession(); | 4070 CreateInsecureSpdySession(); |
4010 | 4071 |
4011 base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously( | 4072 base::WeakPtr<SpdyStream> stream1 = |
4012 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4073 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4074 test_url_, LOWEST, NetLogWithSource()); |
4013 ASSERT_TRUE(stream1); | 4075 ASSERT_TRUE(stream1); |
4014 | 4076 |
4015 test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece); | 4077 test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece); |
4016 stream1->SetDelegate(&delegate1); | 4078 stream1->SetDelegate(&delegate1); |
4017 | 4079 |
4018 base::WeakPtr<SpdyStream> stream2 = CreateStreamSynchronously( | 4080 base::WeakPtr<SpdyStream> stream2 = |
4019 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, MEDIUM, BoundNetLog()); | 4081 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4082 test_url_, MEDIUM, NetLogWithSource()); |
4020 ASSERT_TRUE(stream2); | 4083 ASSERT_TRUE(stream2); |
4021 | 4084 |
4022 test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece); | 4085 test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece); |
4023 stream2->SetDelegate(&delegate2); | 4086 stream2->SetDelegate(&delegate2); |
4024 | 4087 |
4025 EXPECT_FALSE(stream1->send_stalled_by_flow_control()); | 4088 EXPECT_FALSE(stream1->send_stalled_by_flow_control()); |
4026 EXPECT_FALSE(stream2->send_stalled_by_flow_control()); | 4089 EXPECT_FALSE(stream2->send_stalled_by_flow_control()); |
4027 | 4090 |
4028 StallSessionSend(); | 4091 StallSessionSend(); |
4029 | 4092 |
(...skipping 100 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4130 CreateMockRead(resp2, 4), MockRead(ASYNC, ERR_IO_PENDING, 5), | 4193 CreateMockRead(resp2, 4), MockRead(ASYNC, ERR_IO_PENDING, 5), |
4131 MockRead(ASYNC, 0, 6) // EOF | 4194 MockRead(ASYNC, 0, 6) // EOF |
4132 }; | 4195 }; |
4133 | 4196 |
4134 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4197 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4135 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4198 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4136 | 4199 |
4137 CreateNetworkSession(); | 4200 CreateNetworkSession(); |
4138 CreateInsecureSpdySession(); | 4201 CreateInsecureSpdySession(); |
4139 | 4202 |
4140 base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously( | 4203 base::WeakPtr<SpdyStream> stream1 = |
4141 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4204 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4205 test_url_, LOWEST, NetLogWithSource()); |
4142 ASSERT_TRUE(stream1); | 4206 ASSERT_TRUE(stream1); |
4143 | 4207 |
4144 test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece); | 4208 test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece); |
4145 stream1->SetDelegate(&delegate1); | 4209 stream1->SetDelegate(&delegate1); |
4146 | 4210 |
4147 base::WeakPtr<SpdyStream> stream2 = CreateStreamSynchronously( | 4211 base::WeakPtr<SpdyStream> stream2 = |
4148 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4212 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4213 test_url_, LOWEST, NetLogWithSource()); |
4149 ASSERT_TRUE(stream2); | 4214 ASSERT_TRUE(stream2); |
4150 | 4215 |
4151 StreamClosingDelegate delegate2(stream2, kBodyDataStringPiece); | 4216 StreamClosingDelegate delegate2(stream2, kBodyDataStringPiece); |
4152 stream2->SetDelegate(&delegate2); | 4217 stream2->SetDelegate(&delegate2); |
4153 | 4218 |
4154 base::WeakPtr<SpdyStream> stream3 = CreateStreamSynchronously( | 4219 base::WeakPtr<SpdyStream> stream3 = |
4155 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4220 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4221 test_url_, LOWEST, NetLogWithSource()); |
4156 ASSERT_TRUE(stream3); | 4222 ASSERT_TRUE(stream3); |
4157 | 4223 |
4158 test::StreamDelegateWithBody delegate3(stream3, kBodyDataStringPiece); | 4224 test::StreamDelegateWithBody delegate3(stream3, kBodyDataStringPiece); |
4159 stream3->SetDelegate(&delegate3); | 4225 stream3->SetDelegate(&delegate3); |
4160 | 4226 |
4161 EXPECT_FALSE(stream1->send_stalled_by_flow_control()); | 4227 EXPECT_FALSE(stream1->send_stalled_by_flow_control()); |
4162 EXPECT_FALSE(stream2->send_stalled_by_flow_control()); | 4228 EXPECT_FALSE(stream2->send_stalled_by_flow_control()); |
4163 EXPECT_FALSE(stream3->send_stalled_by_flow_control()); | 4229 EXPECT_FALSE(stream3->send_stalled_by_flow_control()); |
4164 | 4230 |
4165 StallSessionSend(); | 4231 StallSessionSend(); |
(...skipping 93 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4259 MockRead reads[] = { | 4325 MockRead reads[] = { |
4260 MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF | 4326 MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF |
4261 }; | 4327 }; |
4262 | 4328 |
4263 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4329 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4264 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4330 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4265 | 4331 |
4266 CreateNetworkSession(); | 4332 CreateNetworkSession(); |
4267 CreateInsecureSpdySession(); | 4333 CreateInsecureSpdySession(); |
4268 | 4334 |
4269 base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously( | 4335 base::WeakPtr<SpdyStream> stream1 = |
4270 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4336 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4337 test_url_, LOWEST, NetLogWithSource()); |
4271 ASSERT_TRUE(stream1); | 4338 ASSERT_TRUE(stream1); |
4272 | 4339 |
4273 test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece); | 4340 test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece); |
4274 stream1->SetDelegate(&delegate1); | 4341 stream1->SetDelegate(&delegate1); |
4275 | 4342 |
4276 base::WeakPtr<SpdyStream> stream2 = CreateStreamSynchronously( | 4343 base::WeakPtr<SpdyStream> stream2 = |
4277 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4344 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4345 test_url_, LOWEST, NetLogWithSource()); |
4278 ASSERT_TRUE(stream2); | 4346 ASSERT_TRUE(stream2); |
4279 | 4347 |
4280 test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece); | 4348 test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece); |
4281 stream2->SetDelegate(&delegate2); | 4349 stream2->SetDelegate(&delegate2); |
4282 | 4350 |
4283 EXPECT_FALSE(stream1->send_stalled_by_flow_control()); | 4351 EXPECT_FALSE(stream1->send_stalled_by_flow_control()); |
4284 EXPECT_FALSE(stream2->send_stalled_by_flow_control()); | 4352 EXPECT_FALSE(stream2->send_stalled_by_flow_control()); |
4285 | 4353 |
4286 StallSessionSend(); | 4354 StallSessionSend(); |
4287 | 4355 |
(...skipping 60 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4348 MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(resp, 2), | 4416 MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(resp, 2), |
4349 CreateMockRead(body, 3), | 4417 CreateMockRead(body, 3), |
4350 }; | 4418 }; |
4351 | 4419 |
4352 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4420 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4353 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4421 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4354 | 4422 |
4355 CreateNetworkSession(); | 4423 CreateNetworkSession(); |
4356 CreateInsecureSpdySession(); | 4424 CreateInsecureSpdySession(); |
4357 | 4425 |
4358 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 4426 base::WeakPtr<SpdyStream> spdy_stream = |
4359 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4427 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4428 test_url_, LOWEST, NetLogWithSource()); |
4360 ASSERT_TRUE(spdy_stream); | 4429 ASSERT_TRUE(spdy_stream); |
4361 test::StreamDelegateDoNothing delegate(spdy_stream); | 4430 test::StreamDelegateDoNothing delegate(spdy_stream); |
4362 spdy_stream->SetDelegate(&delegate); | 4431 spdy_stream->SetDelegate(&delegate); |
4363 | 4432 |
4364 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); | 4433 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
4365 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 4434 spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
4366 | 4435 |
4367 // Write request. | 4436 // Write request. |
4368 base::RunLoop().RunUntilIdle(); | 4437 base::RunLoop().RunUntilIdle(); |
4369 | 4438 |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4406 | 4475 |
4407 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4476 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4408 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4477 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4409 | 4478 |
4410 CreateNetworkSession(); | 4479 CreateNetworkSession(); |
4411 CreateInsecureSpdySession(); | 4480 CreateInsecureSpdySession(); |
4412 | 4481 |
4413 // Read the settings frame. | 4482 // Read the settings frame. |
4414 base::RunLoop().RunUntilIdle(); | 4483 base::RunLoop().RunUntilIdle(); |
4415 | 4484 |
4416 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 4485 base::WeakPtr<SpdyStream> spdy_stream1 = |
4417 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4486 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4487 test_url_, LOWEST, NetLogWithSource()); |
4418 ASSERT_TRUE(spdy_stream1); | 4488 ASSERT_TRUE(spdy_stream1); |
4419 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 4489 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
4420 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 4490 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
4421 spdy_stream1->SetDelegate(&delegate1); | 4491 spdy_stream1->SetDelegate(&delegate1); |
4422 | 4492 |
4423 EXPECT_EQ(0u, session_->num_active_streams()); | 4493 EXPECT_EQ(0u, session_->num_active_streams()); |
4424 EXPECT_EQ(1u, session_->num_created_streams()); | 4494 EXPECT_EQ(1u, session_->num_created_streams()); |
4425 EXPECT_EQ(0u, session_->num_pushed_streams()); | 4495 EXPECT_EQ(0u, session_->num_pushed_streams()); |
4426 EXPECT_EQ(0u, session_->num_active_pushed_streams()); | 4496 EXPECT_EQ(0u, session_->num_active_pushed_streams()); |
4427 | 4497 |
(...skipping 13 matching lines...) Expand all Loading... |
4441 data.Resume(); | 4511 data.Resume(); |
4442 base::RunLoop().RunUntilIdle(); | 4512 base::RunLoop().RunUntilIdle(); |
4443 EXPECT_EQ(2u, session_->num_active_streams()); | 4513 EXPECT_EQ(2u, session_->num_active_streams()); |
4444 EXPECT_EQ(0u, session_->num_created_streams()); | 4514 EXPECT_EQ(0u, session_->num_created_streams()); |
4445 EXPECT_EQ(1u, session_->num_pushed_streams()); | 4515 EXPECT_EQ(1u, session_->num_pushed_streams()); |
4446 EXPECT_EQ(1u, session_->num_active_pushed_streams()); | 4516 EXPECT_EQ(1u, session_->num_active_pushed_streams()); |
4447 | 4517 |
4448 // Second stream should not be stalled, although we have 2 active streams, but | 4518 // Second stream should not be stalled, although we have 2 active streams, but |
4449 // one of them is push stream and should not be taken into account when we | 4519 // one of them is push stream and should not be taken into account when we |
4450 // create streams on the client. | 4520 // create streams on the client. |
4451 base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously( | 4521 base::WeakPtr<SpdyStream> spdy_stream2 = |
4452 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4522 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4523 test_url_, LOWEST, NetLogWithSource()); |
4453 EXPECT_TRUE(spdy_stream2); | 4524 EXPECT_TRUE(spdy_stream2); |
4454 EXPECT_EQ(2u, session_->num_active_streams()); | 4525 EXPECT_EQ(2u, session_->num_active_streams()); |
4455 EXPECT_EQ(1u, session_->num_created_streams()); | 4526 EXPECT_EQ(1u, session_->num_created_streams()); |
4456 EXPECT_EQ(1u, session_->num_pushed_streams()); | 4527 EXPECT_EQ(1u, session_->num_pushed_streams()); |
4457 EXPECT_EQ(1u, session_->num_active_pushed_streams()); | 4528 EXPECT_EQ(1u, session_->num_active_pushed_streams()); |
4458 | 4529 |
4459 // Read EOF. | 4530 // Read EOF. |
4460 data.Resume(); | 4531 data.Resume(); |
4461 base::RunLoop().RunUntilIdle(); | 4532 base::RunLoop().RunUntilIdle(); |
4462 EXPECT_FALSE(session_); | 4533 EXPECT_FALSE(session_); |
(...skipping 18 matching lines...) Expand all Loading... |
4481 CreateMockWrite(req, 0), CreateMockWrite(rst, 5), | 4552 CreateMockWrite(req, 0), CreateMockWrite(rst, 5), |
4482 }; | 4553 }; |
4483 | 4554 |
4484 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4555 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4485 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4556 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4486 | 4557 |
4487 CreateNetworkSession(); | 4558 CreateNetworkSession(); |
4488 CreateInsecureSpdySession(); | 4559 CreateInsecureSpdySession(); |
4489 session_->set_max_concurrent_pushed_streams(1); | 4560 session_->set_max_concurrent_pushed_streams(1); |
4490 | 4561 |
4491 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 4562 base::WeakPtr<SpdyStream> spdy_stream1 = |
4492 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4563 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4564 test_url_, LOWEST, NetLogWithSource()); |
4493 ASSERT_TRUE(spdy_stream1); | 4565 ASSERT_TRUE(spdy_stream1); |
4494 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 4566 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
4495 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 4567 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
4496 spdy_stream1->SetDelegate(&delegate1); | 4568 spdy_stream1->SetDelegate(&delegate1); |
4497 | 4569 |
4498 EXPECT_EQ(0u, session_->num_active_streams()); | 4570 EXPECT_EQ(0u, session_->num_active_streams()); |
4499 EXPECT_EQ(1u, session_->num_created_streams()); | 4571 EXPECT_EQ(1u, session_->num_created_streams()); |
4500 EXPECT_EQ(0u, session_->num_pushed_streams()); | 4572 EXPECT_EQ(0u, session_->num_pushed_streams()); |
4501 EXPECT_EQ(0u, session_->num_active_pushed_streams()); | 4573 EXPECT_EQ(0u, session_->num_active_pushed_streams()); |
4502 | 4574 |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4584 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); | 4656 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); |
4585 ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get()); | 4657 ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get()); |
4586 | 4658 |
4587 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); | 4659 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
4588 ssl.cert = test_cert; | 4660 ssl.cert = test_cert; |
4589 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4661 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4590 | 4662 |
4591 CreateNetworkSession(); | 4663 CreateNetworkSession(); |
4592 CreateSecureSpdySession(); | 4664 CreateSecureSpdySession(); |
4593 | 4665 |
4594 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 4666 base::WeakPtr<SpdyStream> spdy_stream = |
4595 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4667 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4668 test_url_, LOWEST, NetLogWithSource()); |
4596 ASSERT_TRUE(spdy_stream); | 4669 ASSERT_TRUE(spdy_stream); |
4597 EXPECT_EQ(0u, spdy_stream->stream_id()); | 4670 EXPECT_EQ(0u, spdy_stream->stream_id()); |
4598 test::StreamDelegateDoNothing delegate(spdy_stream); | 4671 test::StreamDelegateDoNothing delegate(spdy_stream); |
4599 spdy_stream->SetDelegate(&delegate); | 4672 spdy_stream->SetDelegate(&delegate); |
4600 | 4673 |
4601 EXPECT_EQ(0u, session_->num_active_streams()); | 4674 EXPECT_EQ(0u, session_->num_active_streams()); |
4602 EXPECT_EQ(1u, session_->num_created_streams()); | 4675 EXPECT_EQ(1u, session_->num_created_streams()); |
4603 EXPECT_EQ(0u, session_->num_pushed_streams()); | 4676 EXPECT_EQ(0u, session_->num_pushed_streams()); |
4604 EXPECT_EQ(0u, session_->num_active_pushed_streams()); | 4677 EXPECT_EQ(0u, session_->num_active_pushed_streams()); |
4605 | 4678 |
(...skipping 67 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4673 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); | 4746 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); |
4674 ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get()); | 4747 ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get()); |
4675 | 4748 |
4676 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); | 4749 SSLSocketDataProvider ssl(SYNCHRONOUS, OK); |
4677 ssl.cert = test_cert; | 4750 ssl.cert = test_cert; |
4678 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4751 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4679 | 4752 |
4680 CreateNetworkSession(); | 4753 CreateNetworkSession(); |
4681 CreateSecureSpdySession(); | 4754 CreateSecureSpdySession(); |
4682 | 4755 |
4683 base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously( | 4756 base::WeakPtr<SpdyStream> spdy_stream = |
4684 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4757 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4758 test_url_, LOWEST, NetLogWithSource()); |
4685 ASSERT_TRUE(spdy_stream); | 4759 ASSERT_TRUE(spdy_stream); |
4686 EXPECT_EQ(0u, spdy_stream->stream_id()); | 4760 EXPECT_EQ(0u, spdy_stream->stream_id()); |
4687 test::StreamDelegateDoNothing delegate(spdy_stream); | 4761 test::StreamDelegateDoNothing delegate(spdy_stream); |
4688 spdy_stream->SetDelegate(&delegate); | 4762 spdy_stream->SetDelegate(&delegate); |
4689 | 4763 |
4690 EXPECT_EQ(0u, session_->num_active_streams()); | 4764 EXPECT_EQ(0u, session_->num_active_streams()); |
4691 EXPECT_EQ(1u, session_->num_created_streams()); | 4765 EXPECT_EQ(1u, session_->num_created_streams()); |
4692 EXPECT_EQ(0u, session_->num_pushed_streams()); | 4766 EXPECT_EQ(0u, session_->num_pushed_streams()); |
4693 EXPECT_EQ(0u, session_->num_active_pushed_streams()); | 4767 EXPECT_EQ(0u, session_->num_active_pushed_streams()); |
4694 | 4768 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4735 CreateMockWrite(req, 0), CreateMockWrite(rst, 7), | 4809 CreateMockWrite(req, 0), CreateMockWrite(rst, 7), |
4736 }; | 4810 }; |
4737 | 4811 |
4738 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4812 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4739 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4813 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4740 | 4814 |
4741 CreateNetworkSession(); | 4815 CreateNetworkSession(); |
4742 CreateInsecureSpdySession(); | 4816 CreateInsecureSpdySession(); |
4743 session_->set_max_concurrent_pushed_streams(1); | 4817 session_->set_max_concurrent_pushed_streams(1); |
4744 | 4818 |
4745 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 4819 base::WeakPtr<SpdyStream> spdy_stream1 = |
4746 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4820 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4821 test_url_, LOWEST, NetLogWithSource()); |
4747 ASSERT_TRUE(spdy_stream1); | 4822 ASSERT_TRUE(spdy_stream1); |
4748 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 4823 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
4749 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 4824 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
4750 spdy_stream1->SetDelegate(&delegate1); | 4825 spdy_stream1->SetDelegate(&delegate1); |
4751 | 4826 |
4752 EXPECT_EQ(0u, session_->num_active_streams()); | 4827 EXPECT_EQ(0u, session_->num_active_streams()); |
4753 EXPECT_EQ(1u, session_->num_created_streams()); | 4828 EXPECT_EQ(1u, session_->num_created_streams()); |
4754 EXPECT_EQ(0u, session_->num_pushed_streams()); | 4829 EXPECT_EQ(0u, session_->num_pushed_streams()); |
4755 EXPECT_EQ(0u, session_->num_active_pushed_streams()); | 4830 EXPECT_EQ(0u, session_->num_active_pushed_streams()); |
4756 | 4831 |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4818 MockWrite writes[] = { | 4893 MockWrite writes[] = { |
4819 CreateMockWrite(req, 0), CreateMockWrite(rst, 5), | 4894 CreateMockWrite(req, 0), CreateMockWrite(rst, 5), |
4820 }; | 4895 }; |
4821 | 4896 |
4822 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 4897 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
4823 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4898 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4824 | 4899 |
4825 CreateNetworkSession(); | 4900 CreateNetworkSession(); |
4826 CreateInsecureSpdySession(); | 4901 CreateInsecureSpdySession(); |
4827 | 4902 |
4828 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( | 4903 base::WeakPtr<SpdyStream> spdy_stream1 = |
4829 SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, LOWEST, BoundNetLog()); | 4904 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| 4905 test_url_, LOWEST, NetLogWithSource()); |
4830 ASSERT_TRUE(spdy_stream1); | 4906 ASSERT_TRUE(spdy_stream1); |
4831 EXPECT_EQ(0u, spdy_stream1->stream_id()); | 4907 EXPECT_EQ(0u, spdy_stream1->stream_id()); |
4832 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 4908 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
4833 spdy_stream1->SetDelegate(&delegate1); | 4909 spdy_stream1->SetDelegate(&delegate1); |
4834 | 4910 |
4835 EXPECT_EQ(0u, session_->num_active_streams()); | 4911 EXPECT_EQ(0u, session_->num_active_streams()); |
4836 EXPECT_EQ(1u, session_->num_created_streams()); | 4912 EXPECT_EQ(1u, session_->num_created_streams()); |
4837 EXPECT_EQ(0u, session_->num_pushed_streams()); | 4913 EXPECT_EQ(0u, session_->num_pushed_streams()); |
4838 EXPECT_EQ(0u, session_->num_active_pushed_streams()); | 4914 EXPECT_EQ(0u, session_->num_active_pushed_streams()); |
4839 | 4915 |
(...skipping 11 matching lines...) Expand all Loading... |
4851 | 4927 |
4852 // Run until pushed stream is created. | 4928 // Run until pushed stream is created. |
4853 data.Resume(); | 4929 data.Resume(); |
4854 base::RunLoop().RunUntilIdle(); | 4930 base::RunLoop().RunUntilIdle(); |
4855 EXPECT_EQ(2u, session_->num_active_streams()); | 4931 EXPECT_EQ(2u, session_->num_active_streams()); |
4856 EXPECT_EQ(0u, session_->num_created_streams()); | 4932 EXPECT_EQ(0u, session_->num_created_streams()); |
4857 EXPECT_EQ(1u, session_->num_pushed_streams()); | 4933 EXPECT_EQ(1u, session_->num_pushed_streams()); |
4858 EXPECT_EQ(0u, session_->num_active_pushed_streams()); | 4934 EXPECT_EQ(0u, session_->num_active_pushed_streams()); |
4859 | 4935 |
4860 base::WeakPtr<SpdyStream> pushed_stream; | 4936 base::WeakPtr<SpdyStream> pushed_stream; |
4861 int rv = | 4937 int rv = session_->GetPushStream(GURL(kPushedUrl), &pushed_stream, |
4862 session_->GetPushStream(GURL(kPushedUrl), &pushed_stream, BoundNetLog()); | 4938 NetLogWithSource()); |
4863 ASSERT_THAT(rv, IsOk()); | 4939 ASSERT_THAT(rv, IsOk()); |
4864 ASSERT_TRUE(pushed_stream); | 4940 ASSERT_TRUE(pushed_stream); |
4865 test::StreamDelegateCloseOnHeaders delegate2(pushed_stream); | 4941 test::StreamDelegateCloseOnHeaders delegate2(pushed_stream); |
4866 pushed_stream->SetDelegate(&delegate2); | 4942 pushed_stream->SetDelegate(&delegate2); |
4867 | 4943 |
4868 // Receive headers for pushed stream. Delegate will cancel the stream, ensure | 4944 // Receive headers for pushed stream. Delegate will cancel the stream, ensure |
4869 // that all our counters are in consistent state. | 4945 // that all our counters are in consistent state. |
4870 data.Resume(); | 4946 data.Resume(); |
4871 base::RunLoop().RunUntilIdle(); | 4947 base::RunLoop().RunUntilIdle(); |
4872 EXPECT_EQ(1u, session_->num_active_streams()); | 4948 EXPECT_EQ(1u, session_->num_active_streams()); |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4931 // Load a cert that is valid for | 5007 // Load a cert that is valid for |
4932 // www.example.org, mail.example.org, and mail.example.com. | 5008 // www.example.org, mail.example.org, and mail.example.com. |
4933 cert_ = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 5009 cert_ = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
4934 ASSERT_TRUE(cert_); | 5010 ASSERT_TRUE(cert_); |
4935 ssl_.cert = cert_; | 5011 ssl_.cert = cert_; |
4936 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_); | 5012 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_); |
4937 } | 5013 } |
4938 | 5014 |
4939 void CreateSecureSpdySession() { | 5015 void CreateSecureSpdySession() { |
4940 session_ = ::net::CreateSecureSpdySession(http_session_.get(), key_, | 5016 session_ = ::net::CreateSecureSpdySession(http_session_.get(), key_, |
4941 BoundNetLog()); | 5017 NetLogWithSource()); |
4942 } | 5018 } |
4943 | 5019 |
4944 SpdyAltSvcWireFormat::AlternativeService alternative_service_; | 5020 SpdyAltSvcWireFormat::AlternativeService alternative_service_; |
4945 | 5021 |
4946 private: | 5022 private: |
4947 SpdySerializedFrame altsvc_frame_; | 5023 SpdySerializedFrame altsvc_frame_; |
4948 std::vector<MockRead> reads_; | 5024 std::vector<MockRead> reads_; |
4949 std::unique_ptr<SequencedSocketData> data_; | 5025 std::unique_ptr<SequencedSocketData> data_; |
4950 scoped_refptr<X509Certificate> cert_; | 5026 scoped_refptr<X509Certificate> cert_; |
4951 SSLSocketDataProvider ssl_; | 5027 SSLSocketDataProvider ssl_; |
(...skipping 118 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5070 CreateMockWrite(req, 0), | 5146 CreateMockWrite(req, 0), |
5071 }; | 5147 }; |
5072 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 5148 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
5073 session_deps_.socket_factory->AddSocketDataProvider(&data); | 5149 session_deps_.socket_factory->AddSocketDataProvider(&data); |
5074 | 5150 |
5075 AddSSLSocketData(); | 5151 AddSSLSocketData(); |
5076 | 5152 |
5077 CreateNetworkSession(); | 5153 CreateNetworkSession(); |
5078 CreateSecureSpdySession(); | 5154 CreateSecureSpdySession(); |
5079 | 5155 |
5080 base::WeakPtr<SpdyStream> spdy_stream1 = | 5156 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( |
5081 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, | 5157 SPDY_REQUEST_RESPONSE_STREAM, session_, GURL(request_origin), MEDIUM, |
5082 GURL(request_origin), MEDIUM, BoundNetLog()); | 5158 NetLogWithSource()); |
5083 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 5159 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
5084 spdy_stream1->SetDelegate(&delegate1); | 5160 spdy_stream1->SetDelegate(&delegate1); |
5085 | 5161 |
5086 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(request_origin)); | 5162 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(request_origin)); |
5087 | 5163 |
5088 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 5164 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
5089 | 5165 |
5090 base::RunLoop().RunUntilIdle(); | 5166 base::RunLoop().RunUntilIdle(); |
5091 | 5167 |
5092 const url::SchemeHostPort session_origin("https", test_url_.host(), | 5168 const url::SchemeHostPort session_origin("https", test_url_.host(), |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5124 CreateMockWrite(req, 0), | 5200 CreateMockWrite(req, 0), |
5125 }; | 5201 }; |
5126 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); | 5202 SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes)); |
5127 session_deps_.socket_factory->AddSocketDataProvider(&data); | 5203 session_deps_.socket_factory->AddSocketDataProvider(&data); |
5128 | 5204 |
5129 AddSSLSocketData(); | 5205 AddSSLSocketData(); |
5130 | 5206 |
5131 CreateNetworkSession(); | 5207 CreateNetworkSession(); |
5132 CreateSecureSpdySession(); | 5208 CreateSecureSpdySession(); |
5133 | 5209 |
5134 base::WeakPtr<SpdyStream> spdy_stream1 = | 5210 base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously( |
5135 CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, | 5211 SPDY_REQUEST_RESPONSE_STREAM, session_, GURL(request_origin), MEDIUM, |
5136 GURL(request_origin), MEDIUM, BoundNetLog()); | 5212 NetLogWithSource()); |
5137 test::StreamDelegateDoNothing delegate1(spdy_stream1); | 5213 test::StreamDelegateDoNothing delegate1(spdy_stream1); |
5138 spdy_stream1->SetDelegate(&delegate1); | 5214 spdy_stream1->SetDelegate(&delegate1); |
5139 | 5215 |
5140 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(request_origin)); | 5216 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(request_origin)); |
5141 | 5217 |
5142 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); | 5218 spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
5143 | 5219 |
5144 base::RunLoop().RunUntilIdle(); | 5220 base::RunLoop().RunUntilIdle(); |
5145 | 5221 |
5146 const url::SchemeHostPort session_origin("https", test_url_.host(), | 5222 const url::SchemeHostPort session_origin("https", test_url_.host(), |
(...skipping 257 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5404 ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(), | 5480 ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(), |
5405 "spdy_pooling.pem"); | 5481 "spdy_pooling.pem"); |
5406 ssl_info.is_issued_by_known_root = true; | 5482 ssl_info.is_issued_by_known_root = true; |
5407 ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin)); | 5483 ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin)); |
5408 | 5484 |
5409 EXPECT_TRUE(SpdySession::CanPool( | 5485 EXPECT_TRUE(SpdySession::CanPool( |
5410 &tss, ssl_info, "www.example.org", "mail.example.org")); | 5486 &tss, ssl_info, "www.example.org", "mail.example.org")); |
5411 } | 5487 } |
5412 | 5488 |
5413 } // namespace net | 5489 } // namespace net |
OLD | NEW |