OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/spdy/spdy_stream.h" | 5 #include "net/spdy/spdy_stream.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include <cstddef> | 9 #include <cstddef> |
10 #include <limits> | 10 #include <limits> |
(...skipping 50 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
61 SpdyStreamTest() : offset_(0) { | 61 SpdyStreamTest() : offset_(0) { |
62 spdy_util_.set_default_url(GURL(kStreamUrl)); | 62 spdy_util_.set_default_url(GURL(kStreamUrl)); |
63 session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_); | 63 session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_); |
64 } | 64 } |
65 | 65 |
66 ~SpdyStreamTest() override {} | 66 ~SpdyStreamTest() override {} |
67 | 67 |
68 base::WeakPtr<SpdySession> CreateDefaultSpdySession() { | 68 base::WeakPtr<SpdySession> CreateDefaultSpdySession() { |
69 SpdySessionKey key(HostPortPair("www.example.org", 80), | 69 SpdySessionKey key(HostPortPair("www.example.org", 80), |
70 ProxyServer::Direct(), PRIVACY_MODE_DISABLED); | 70 ProxyServer::Direct(), PRIVACY_MODE_DISABLED); |
71 return CreateInsecureSpdySession(session_.get(), key, BoundNetLog()); | 71 return CreateInsecureSpdySession(session_.get(), key, NetLogWithSource()); |
72 } | 72 } |
73 | 73 |
74 void TearDown() override { base::RunLoop().RunUntilIdle(); } | 74 void TearDown() override { base::RunLoop().RunUntilIdle(); } |
75 | 75 |
76 void RunResumeAfterUnstallRequestResponseTest( | 76 void RunResumeAfterUnstallRequestResponseTest( |
77 const UnstallFunction& unstall_function); | 77 const UnstallFunction& unstall_function); |
78 | 78 |
79 void RunResumeAfterUnstallBidirectionalTest( | 79 void RunResumeAfterUnstallBidirectionalTest( |
80 const UnstallFunction& unstall_function); | 80 const UnstallFunction& unstall_function); |
81 | 81 |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
154 | 154 |
155 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 155 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
156 GetNumWrites()); | 156 GetNumWrites()); |
157 MockConnect connect_data(SYNCHRONOUS, OK); | 157 MockConnect connect_data(SYNCHRONOUS, OK); |
158 data.set_connect_data(connect_data); | 158 data.set_connect_data(connect_data); |
159 | 159 |
160 session_deps_.socket_factory->AddSocketDataProvider(&data); | 160 session_deps_.socket_factory->AddSocketDataProvider(&data); |
161 | 161 |
162 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 162 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
163 | 163 |
164 base::WeakPtr<SpdyStream> stream = | 164 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
165 CreateStreamSynchronously( | 165 SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, NetLogWithSource()); |
166 SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, BoundNetLog()); | |
167 ASSERT_TRUE(stream); | 166 ASSERT_TRUE(stream); |
168 | 167 |
169 StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece); | 168 StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece); |
170 stream->SetDelegate(&delegate); | 169 stream->SetDelegate(&delegate); |
171 | 170 |
172 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 171 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
173 | 172 |
174 SpdyHeaderBlock headers( | 173 SpdyHeaderBlock headers( |
175 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); | 174 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); |
176 EXPECT_EQ(ERR_IO_PENDING, | 175 EXPECT_EQ(ERR_IO_PENDING, |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
235 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 234 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
236 GetNumWrites()); | 235 GetNumWrites()); |
237 MockConnect connect_data(SYNCHRONOUS, OK); | 236 MockConnect connect_data(SYNCHRONOUS, OK); |
238 data.set_connect_data(connect_data); | 237 data.set_connect_data(connect_data); |
239 | 238 |
240 session_deps_.socket_factory->AddSocketDataProvider(&data); | 239 session_deps_.socket_factory->AddSocketDataProvider(&data); |
241 | 240 |
242 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 241 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
243 | 242 |
244 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( | 243 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
245 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | 244 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
246 ASSERT_TRUE(stream); | 245 ASSERT_TRUE(stream); |
247 | 246 |
248 StreamDelegateWithTrailers delegate(stream, kPostBodyStringPiece); | 247 StreamDelegateWithTrailers delegate(stream, kPostBodyStringPiece); |
249 stream->SetDelegate(&delegate); | 248 stream->SetDelegate(&delegate); |
250 | 249 |
251 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 250 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
252 | 251 |
253 SpdyHeaderBlock headers( | 252 SpdyHeaderBlock headers( |
254 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); | 253 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); |
255 EXPECT_EQ(ERR_IO_PENDING, | 254 EXPECT_EQ(ERR_IO_PENDING, |
(...skipping 19 matching lines...) Expand all Loading... |
275 GetNumWrites()); | 274 GetNumWrites()); |
276 MockConnect connect_data(SYNCHRONOUS, OK); | 275 MockConnect connect_data(SYNCHRONOUS, OK); |
277 data.set_connect_data(connect_data); | 276 data.set_connect_data(connect_data); |
278 | 277 |
279 session_deps_.socket_factory->AddSocketDataProvider(&data); | 278 session_deps_.socket_factory->AddSocketDataProvider(&data); |
280 | 279 |
281 base::WeakPtr<SpdySession> spdy_session(CreateDefaultSpdySession()); | 280 base::WeakPtr<SpdySession> spdy_session(CreateDefaultSpdySession()); |
282 | 281 |
283 // Conjure up a stream. | 282 // Conjure up a stream. |
284 SpdyStreamRequest stream_request; | 283 SpdyStreamRequest stream_request; |
285 int result = stream_request.StartRequest(SPDY_PUSH_STREAM, spdy_session, | 284 int result = stream_request.StartRequest( |
286 GURL(), DEFAULT_PRIORITY, | 285 SPDY_PUSH_STREAM, spdy_session, GURL(), DEFAULT_PRIORITY, |
287 BoundNetLog(), CompletionCallback()); | 286 NetLogWithSource(), CompletionCallback()); |
288 ASSERT_THAT(result, IsOk()); | 287 ASSERT_THAT(result, IsOk()); |
289 base::WeakPtr<SpdyStream> stream = stream_request.ReleaseStream(); | 288 base::WeakPtr<SpdyStream> stream = stream_request.ReleaseStream(); |
290 ActivatePushStream(spdy_session.get(), stream.get()); | 289 ActivatePushStream(spdy_session.get(), stream.get()); |
291 | 290 |
292 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 291 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
293 | 292 |
294 // Set required request headers. | 293 // Set required request headers. |
295 SpdyHeaderBlock request_headers; | 294 SpdyHeaderBlock request_headers; |
296 spdy_util_.AddUrlToHeaderBlock(kStreamUrl, &request_headers); | 295 spdy_util_.AddUrlToHeaderBlock(kStreamUrl, &request_headers); |
297 stream->OnPushPromiseHeadersReceived(std::move(request_headers)); | 296 stream->OnPushPromiseHeadersReceived(std::move(request_headers)); |
(...skipping 133 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
431 | 430 |
432 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 431 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
433 GetNumWrites()); | 432 GetNumWrites()); |
434 MockConnect connect_data(SYNCHRONOUS, OK); | 433 MockConnect connect_data(SYNCHRONOUS, OK); |
435 data.set_connect_data(connect_data); | 434 data.set_connect_data(connect_data); |
436 | 435 |
437 session_deps_.socket_factory->AddSocketDataProvider(&data); | 436 session_deps_.socket_factory->AddSocketDataProvider(&data); |
438 | 437 |
439 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 438 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
440 | 439 |
441 base::WeakPtr<SpdyStream> stream = | 440 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
442 CreateStreamSynchronously( | 441 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
443 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | |
444 ASSERT_TRUE(stream); | 442 ASSERT_TRUE(stream); |
445 | 443 |
446 std::string body_data(3 * kMaxSpdyFrameChunkSize, 'x'); | 444 std::string body_data(3 * kMaxSpdyFrameChunkSize, 'x'); |
447 StreamDelegateWithBody delegate(stream, body_data); | 445 StreamDelegateWithBody delegate(stream, body_data); |
448 stream->SetDelegate(&delegate); | 446 stream->SetDelegate(&delegate); |
449 | 447 |
450 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 448 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
451 | 449 |
452 SpdyHeaderBlock headers( | 450 SpdyHeaderBlock headers( |
453 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); | 451 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
487 | 485 |
488 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 486 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
489 GetNumWrites()); | 487 GetNumWrites()); |
490 MockConnect connect_data(SYNCHRONOUS, OK); | 488 MockConnect connect_data(SYNCHRONOUS, OK); |
491 data.set_connect_data(connect_data); | 489 data.set_connect_data(connect_data); |
492 | 490 |
493 session_deps_.socket_factory->AddSocketDataProvider(&data); | 491 session_deps_.socket_factory->AddSocketDataProvider(&data); |
494 | 492 |
495 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 493 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
496 | 494 |
497 base::WeakPtr<SpdyStream> stream = | 495 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
498 CreateStreamSynchronously( | 496 SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, NetLogWithSource()); |
499 SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, BoundNetLog()); | |
500 ASSERT_TRUE(stream); | 497 ASSERT_TRUE(stream); |
501 | 498 |
502 std::string body_data(3 * kMaxSpdyFrameChunkSize, 'x'); | 499 std::string body_data(3 * kMaxSpdyFrameChunkSize, 'x'); |
503 StreamDelegateSendImmediate delegate(stream, body_data); | 500 StreamDelegateSendImmediate delegate(stream, body_data); |
504 stream->SetDelegate(&delegate); | 501 stream->SetDelegate(&delegate); |
505 | 502 |
506 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 503 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
507 | 504 |
508 SpdyHeaderBlock headers( | 505 SpdyHeaderBlock headers( |
509 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); | 506 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
541 | 538 |
542 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 539 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
543 GetNumWrites()); | 540 GetNumWrites()); |
544 MockConnect connect_data(SYNCHRONOUS, OK); | 541 MockConnect connect_data(SYNCHRONOUS, OK); |
545 data.set_connect_data(connect_data); | 542 data.set_connect_data(connect_data); |
546 | 543 |
547 session_deps_.socket_factory->AddSocketDataProvider(&data); | 544 session_deps_.socket_factory->AddSocketDataProvider(&data); |
548 | 545 |
549 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 546 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
550 | 547 |
551 base::WeakPtr<SpdyStream> stream = | 548 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
552 CreateStreamSynchronously( | 549 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
553 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | |
554 ASSERT_TRUE(stream); | 550 ASSERT_TRUE(stream); |
555 | 551 |
556 StreamDelegateDoNothing delegate(stream); | 552 StreamDelegateDoNothing delegate(stream); |
557 stream->SetDelegate(&delegate); | 553 stream->SetDelegate(&delegate); |
558 | 554 |
559 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 555 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
560 | 556 |
561 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); | 557 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); |
562 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), | 558 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), |
563 NO_MORE_DATA_TO_SEND)); | 559 NO_MORE_DATA_TO_SEND)); |
(...skipping 29 matching lines...) Expand all Loading... |
593 | 589 |
594 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 590 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
595 GetNumWrites()); | 591 GetNumWrites()); |
596 MockConnect connect_data(SYNCHRONOUS, OK); | 592 MockConnect connect_data(SYNCHRONOUS, OK); |
597 data.set_connect_data(connect_data); | 593 data.set_connect_data(connect_data); |
598 | 594 |
599 session_deps_.socket_factory->AddSocketDataProvider(&data); | 595 session_deps_.socket_factory->AddSocketDataProvider(&data); |
600 | 596 |
601 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 597 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
602 | 598 |
603 base::WeakPtr<SpdyStream> stream = | 599 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
604 CreateStreamSynchronously( | 600 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
605 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | |
606 ASSERT_TRUE(stream); | 601 ASSERT_TRUE(stream); |
607 | 602 |
608 StreamDelegateDoNothing delegate(stream); | 603 StreamDelegateDoNothing delegate(stream); |
609 stream->SetDelegate(&delegate); | 604 stream->SetDelegate(&delegate); |
610 | 605 |
611 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 606 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
612 | 607 |
613 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); | 608 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); |
614 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), | 609 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), |
615 NO_MORE_DATA_TO_SEND)); | 610 NO_MORE_DATA_TO_SEND)); |
616 EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec()); | 611 EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec()); |
617 | 612 |
618 data.RunUntilPaused(); | 613 data.RunUntilPaused(); |
619 | 614 |
620 base::WeakPtr<SpdyStream> push_stream; | 615 base::WeakPtr<SpdyStream> push_stream; |
621 EXPECT_THAT(session->GetPushStream(url, &push_stream, BoundNetLog()), IsOk()); | 616 EXPECT_THAT(session->GetPushStream(url, &push_stream, NetLogWithSource()), |
| 617 IsOk()); |
622 EXPECT_FALSE(push_stream); | 618 EXPECT_FALSE(push_stream); |
623 | 619 |
624 data.Resume(); | 620 data.Resume(); |
625 | 621 |
626 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); | 622 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); |
627 } | 623 } |
628 | 624 |
629 // Receiving a header with uppercase ASCII in a HEADERS frame should | 625 // Receiving a header with uppercase ASCII in a HEADERS frame should |
630 // result in a protocol error. | 626 // result in a protocol error. |
631 TEST_F(SpdyStreamTest, UpperCaseHeadersInHeadersFrame) { | 627 TEST_F(SpdyStreamTest, UpperCaseHeadersInHeadersFrame) { |
(...skipping 28 matching lines...) Expand all Loading... |
660 | 656 |
661 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 657 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
662 GetNumWrites()); | 658 GetNumWrites()); |
663 MockConnect connect_data(SYNCHRONOUS, OK); | 659 MockConnect connect_data(SYNCHRONOUS, OK); |
664 data.set_connect_data(connect_data); | 660 data.set_connect_data(connect_data); |
665 | 661 |
666 session_deps_.socket_factory->AddSocketDataProvider(&data); | 662 session_deps_.socket_factory->AddSocketDataProvider(&data); |
667 | 663 |
668 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 664 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
669 | 665 |
670 base::WeakPtr<SpdyStream> stream = | 666 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
671 CreateStreamSynchronously( | 667 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
672 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | |
673 ASSERT_TRUE(stream); | 668 ASSERT_TRUE(stream); |
674 | 669 |
675 StreamDelegateDoNothing delegate(stream); | 670 StreamDelegateDoNothing delegate(stream); |
676 stream->SetDelegate(&delegate); | 671 stream->SetDelegate(&delegate); |
677 | 672 |
678 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 673 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
679 | 674 |
680 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); | 675 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); |
681 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), | 676 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), |
682 NO_MORE_DATA_TO_SEND)); | 677 NO_MORE_DATA_TO_SEND)); |
683 EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec()); | 678 EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec()); |
684 | 679 |
685 data.RunUntilPaused(); | 680 data.RunUntilPaused(); |
686 | 681 |
687 base::WeakPtr<SpdyStream> push_stream; | 682 base::WeakPtr<SpdyStream> push_stream; |
688 EXPECT_THAT(session->GetPushStream(url, &push_stream, BoundNetLog()), IsOk()); | 683 EXPECT_THAT(session->GetPushStream(url, &push_stream, NetLogWithSource()), |
| 684 IsOk()); |
689 EXPECT_TRUE(push_stream); | 685 EXPECT_TRUE(push_stream); |
690 | 686 |
691 data.Resume(); | 687 data.Resume(); |
692 data.RunUntilPaused(); | 688 data.RunUntilPaused(); |
693 | 689 |
694 EXPECT_THAT(session->GetPushStream(url, &push_stream, BoundNetLog()), IsOk()); | 690 EXPECT_THAT(session->GetPushStream(url, &push_stream, NetLogWithSource()), |
| 691 IsOk()); |
695 EXPECT_FALSE(push_stream); | 692 EXPECT_FALSE(push_stream); |
696 | 693 |
697 data.Resume(); | 694 data.Resume(); |
698 | 695 |
699 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); | 696 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); |
700 } | 697 } |
701 | 698 |
702 // Receiving a duplicate header in a HEADERS frame should result in a | 699 // Receiving a duplicate header in a HEADERS frame should result in a |
703 // protocol error. | 700 // protocol error. |
704 TEST_F(SpdyStreamTest, DuplicateHeaders) { | 701 TEST_F(SpdyStreamTest, DuplicateHeaders) { |
(...skipping 28 matching lines...) Expand all Loading... |
733 | 730 |
734 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 731 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
735 GetNumWrites()); | 732 GetNumWrites()); |
736 MockConnect connect_data(SYNCHRONOUS, OK); | 733 MockConnect connect_data(SYNCHRONOUS, OK); |
737 data.set_connect_data(connect_data); | 734 data.set_connect_data(connect_data); |
738 | 735 |
739 session_deps_.socket_factory->AddSocketDataProvider(&data); | 736 session_deps_.socket_factory->AddSocketDataProvider(&data); |
740 | 737 |
741 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 738 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
742 | 739 |
743 base::WeakPtr<SpdyStream> stream = | 740 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
744 CreateStreamSynchronously( | 741 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
745 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | |
746 ASSERT_TRUE(stream); | 742 ASSERT_TRUE(stream); |
747 | 743 |
748 StreamDelegateDoNothing delegate(stream); | 744 StreamDelegateDoNothing delegate(stream); |
749 stream->SetDelegate(&delegate); | 745 stream->SetDelegate(&delegate); |
750 | 746 |
751 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 747 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
752 | 748 |
753 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); | 749 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); |
754 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), | 750 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), |
755 NO_MORE_DATA_TO_SEND)); | 751 NO_MORE_DATA_TO_SEND)); |
756 EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec()); | 752 EXPECT_EQ(kStreamUrl, stream->GetUrlFromHeaders().spec()); |
757 | 753 |
758 data.RunUntilPaused(); | 754 data.RunUntilPaused(); |
759 | 755 |
760 base::WeakPtr<SpdyStream> push_stream; | 756 base::WeakPtr<SpdyStream> push_stream; |
761 EXPECT_THAT(session->GetPushStream(url, &push_stream, BoundNetLog()), IsOk()); | 757 EXPECT_THAT(session->GetPushStream(url, &push_stream, NetLogWithSource()), |
| 758 IsOk()); |
762 EXPECT_TRUE(push_stream); | 759 EXPECT_TRUE(push_stream); |
763 | 760 |
764 data.Resume(); | 761 data.Resume(); |
765 data.RunUntilPaused(); | 762 data.RunUntilPaused(); |
766 | 763 |
767 EXPECT_THAT(session->GetPushStream(url, &push_stream, BoundNetLog()), IsOk()); | 764 EXPECT_THAT(session->GetPushStream(url, &push_stream, NetLogWithSource()), |
| 765 IsOk()); |
768 EXPECT_FALSE(push_stream); | 766 EXPECT_FALSE(push_stream); |
769 | 767 |
770 data.Resume(); | 768 data.Resume(); |
771 | 769 |
772 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); | 770 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); |
773 } | 771 } |
774 | 772 |
775 // Call IncreaseSendWindowSize on a stream with a large enough delta | 773 // Call IncreaseSendWindowSize on a stream with a large enough delta |
776 // to overflow an int32_t. The SpdyStream should handle that case | 774 // to overflow an int32_t. The SpdyStream should handle that case |
777 // gracefully. | 775 // gracefully. |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
882 | 880 |
883 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 881 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
884 GetNumWrites()); | 882 GetNumWrites()); |
885 MockConnect connect_data(SYNCHRONOUS, OK); | 883 MockConnect connect_data(SYNCHRONOUS, OK); |
886 data.set_connect_data(connect_data); | 884 data.set_connect_data(connect_data); |
887 | 885 |
888 session_deps_.socket_factory->AddSocketDataProvider(&data); | 886 session_deps_.socket_factory->AddSocketDataProvider(&data); |
889 | 887 |
890 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 888 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
891 | 889 |
892 base::WeakPtr<SpdyStream> stream = | 890 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
893 CreateStreamSynchronously( | 891 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
894 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | |
895 ASSERT_TRUE(stream); | 892 ASSERT_TRUE(stream); |
896 | 893 |
897 StreamDelegateWithBody delegate(stream, kPostBodyStringPiece); | 894 StreamDelegateWithBody delegate(stream, kPostBodyStringPiece); |
898 stream->SetDelegate(&delegate); | 895 stream->SetDelegate(&delegate); |
899 | 896 |
900 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 897 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
901 EXPECT_FALSE(stream->send_stalled_by_flow_control()); | 898 EXPECT_FALSE(stream->send_stalled_by_flow_control()); |
902 | 899 |
903 SpdyHeaderBlock headers( | 900 SpdyHeaderBlock headers( |
904 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); | 901 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); |
(...skipping 57 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
962 | 959 |
963 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 960 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
964 GetNumWrites()); | 961 GetNumWrites()); |
965 MockConnect connect_data(SYNCHRONOUS, OK); | 962 MockConnect connect_data(SYNCHRONOUS, OK); |
966 data.set_connect_data(connect_data); | 963 data.set_connect_data(connect_data); |
967 | 964 |
968 session_deps_.socket_factory->AddSocketDataProvider(&data); | 965 session_deps_.socket_factory->AddSocketDataProvider(&data); |
969 | 966 |
970 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 967 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
971 | 968 |
972 base::WeakPtr<SpdyStream> stream = | 969 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
973 CreateStreamSynchronously( | 970 SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, NetLogWithSource()); |
974 SPDY_BIDIRECTIONAL_STREAM, session, url, LOWEST, BoundNetLog()); | |
975 ASSERT_TRUE(stream); | 971 ASSERT_TRUE(stream); |
976 | 972 |
977 StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece); | 973 StreamDelegateSendImmediate delegate(stream, kPostBodyStringPiece); |
978 stream->SetDelegate(&delegate); | 974 stream->SetDelegate(&delegate); |
979 | 975 |
980 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 976 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
981 | 977 |
982 SpdyHeaderBlock headers( | 978 SpdyHeaderBlock headers( |
983 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); | 979 spdy_util_.ConstructPostHeaderBlock(kStreamUrl, kPostBodyLength)); |
984 EXPECT_EQ(ERR_IO_PENDING, | 980 EXPECT_EQ(ERR_IO_PENDING, |
(...skipping 59 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1044 | 1040 |
1045 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), | 1041 SequencedSocketData data(GetReads(), GetNumReads(), GetWrites(), |
1046 GetNumWrites()); | 1042 GetNumWrites()); |
1047 MockConnect connect_data(SYNCHRONOUS, OK); | 1043 MockConnect connect_data(SYNCHRONOUS, OK); |
1048 data.set_connect_data(connect_data); | 1044 data.set_connect_data(connect_data); |
1049 | 1045 |
1050 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1046 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1051 | 1047 |
1052 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); | 1048 base::WeakPtr<SpdySession> session(CreateDefaultSpdySession()); |
1053 | 1049 |
1054 base::WeakPtr<SpdyStream> stream = | 1050 base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously( |
1055 CreateStreamSynchronously( | 1051 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, NetLogWithSource()); |
1056 SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog()); | |
1057 ASSERT_TRUE(stream); | 1052 ASSERT_TRUE(stream); |
1058 | 1053 |
1059 StreamDelegateDoNothing delegate(stream); | 1054 StreamDelegateDoNothing delegate(stream); |
1060 stream->SetDelegate(&delegate); | 1055 stream->SetDelegate(&delegate); |
1061 | 1056 |
1062 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); | 1057 EXPECT_TRUE(stream->GetUrlFromHeaders().is_empty()); |
1063 | 1058 |
1064 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); | 1059 SpdyHeaderBlock headers(spdy_util_.ConstructGetHeaderBlock(kStreamUrl)); |
1065 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), | 1060 EXPECT_EQ(ERR_IO_PENDING, stream->SendRequestHeaders(std::move(headers), |
1066 NO_MORE_DATA_TO_SEND)); | 1061 NO_MORE_DATA_TO_SEND)); |
(...skipping 21 matching lines...) Expand all Loading... |
1088 EXPECT_EQ(response_len, stream->raw_received_bytes()); | 1083 EXPECT_EQ(response_len, stream->raw_received_bytes()); |
1089 | 1084 |
1090 // FIN | 1085 // FIN |
1091 data.Resume(); | 1086 data.Resume(); |
1092 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); | 1087 EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); |
1093 } | 1088 } |
1094 | 1089 |
1095 } // namespace test | 1090 } // namespace test |
1096 | 1091 |
1097 } // namespace net | 1092 } // namespace net |
OLD | NEW |