Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(301)

Side by Side Diff: net/spdy/spdy_session_unittest.cc

Issue 2351513002: net: rename BoundNetLog to NetLogWithSource (Closed)
Patch Set: one more fix, content bound_net_log_ Created 4 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698