| // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "net/spdy/spdy_session.h" |
| |
| #include <algorithm> |
| #include <string> |
| #include <utility> |
| |
| #include "base/base64.h" |
| #include "base/bind.h" |
| #include "base/callback.h" |
| #include "base/optional.h" |
| #include "base/run_loop.h" |
| #include "base/stl_util.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/test/task_environment.h" |
| #include "net/base/features.h" |
| #include "net/base/hex_utils.h" |
| #include "net/base/host_port_pair.h" |
| #include "net/base/io_buffer.h" |
| #include "net/base/ip_endpoint.h" |
| #include "net/base/network_isolation_key.h" |
| #include "net/base/privacy_mode.h" |
| #include "net/base/proxy_delegate.h" |
| #include "net/base/proxy_server.h" |
| #include "net/base/request_priority.h" |
| #include "net/base/test_data_stream.h" |
| #include "net/cert/ct_policy_status.h" |
| #include "net/http/http_request_info.h" |
| #include "net/http/transport_security_state_test_util.h" |
| #include "net/log/net_log_event_type.h" |
| #include "net/log/net_log_source.h" |
| #include "net/log/test_net_log.h" |
| #include "net/log/test_net_log_util.h" |
| #include "net/nqe/network_quality_estimator_test_util.h" |
| #include "net/socket/client_socket_pool.h" |
| #include "net/socket/client_socket_pool_manager.h" |
| #include "net/socket/socket_tag.h" |
| #include "net/socket/socket_test_util.h" |
| #include "net/socket/transport_connect_job.h" |
| #include "net/spdy/spdy_http_utils.h" |
| #include "net/spdy/spdy_session_pool.h" |
| #include "net/spdy/spdy_session_test_util.h" |
| #include "net/spdy/spdy_stream.h" |
| #include "net/spdy/spdy_stream_test_util.h" |
| #include "net/spdy/spdy_test_util_common.h" |
| #include "net/test/cert_test_util.h" |
| #include "net/test/gtest_util.h" |
| #include "net/test/test_data_directory.h" |
| #include "net/test/test_with_task_environment.h" |
| #include "net/third_party/quiche/src/spdy/core/spdy_test_utils.h" |
| #include "net/traffic_annotation/network_traffic_annotation_test_helper.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/platform_test.h" |
| |
| using net::test::IsError; |
| using net::test::IsOk; |
| using net::test::TestServerPushDelegate; |
| using testing::_; |
| |
| namespace net { |
| |
| namespace { |
| |
| const char kHttpURLFromAnotherOrigin[] = "http://www.example2.org/a.dat"; |
| const char kHttpsURLFromAnotherOrigin[] = "https://www.example2.org/b.dat"; |
| const char kPushedUrl[] = "https://www.example.org/a.dat"; |
| |
| const char kBodyData[] = "Body data"; |
| const size_t kBodyDataSize = base::size(kBodyData); |
| const base::StringPiece kBodyDataStringPiece(kBodyData, kBodyDataSize); |
| |
| static base::TimeDelta g_time_delta; |
| static base::TimeTicks g_time_now; |
| |
| base::TimeTicks TheNearFuture() { |
| return base::TimeTicks::Now() + g_time_delta; |
| } |
| |
| base::TimeTicks SlowReads() { |
| g_time_delta += |
| base::TimeDelta::FromMilliseconds(2 * kYieldAfterDurationMilliseconds); |
| return base::TimeTicks::Now() + g_time_delta; |
| } |
| |
| base::TimeTicks InstantaneousReads() { |
| return g_time_now; |
| } |
| |
| class MockRequireCTDelegate : public TransportSecurityState::RequireCTDelegate { |
| public: |
| MOCK_METHOD3(IsCTRequiredForHost, |
| CTRequirementLevel(const std::string& host, |
| const X509Certificate* chain, |
| const HashValueVector& hashes)); |
| }; |
| |
| // SpdySessionRequest::Delegate implementation that does nothing. The test it's |
| // used in need to create a session request to trigger the creation of a session |
| // alias, but doesn't care about when or if OnSpdySessionAvailable() is invoked. |
| class SpdySessionRequestDelegate |
| : public SpdySessionPool::SpdySessionRequest::Delegate { |
| public: |
| SpdySessionRequestDelegate() = default; |
| ~SpdySessionRequestDelegate() override = default; |
| |
| void OnSpdySessionAvailable( |
| base::WeakPtr<SpdySession> spdy_session) override {} |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(SpdySessionRequestDelegate); |
| }; |
| |
| } // namespace |
| |
| class SpdySessionTest : public PlatformTest, public WithTaskEnvironment { |
| public: |
| // Functions used with RunResumeAfterUnstallTest(). |
| |
| void StallSessionOnly(SpdyStream* stream) { StallSessionSend(); } |
| |
| void StallStreamOnly(SpdyStream* stream) { StallStreamSend(stream); } |
| |
| void StallSessionStream(SpdyStream* stream) { |
| StallSessionSend(); |
| StallStreamSend(stream); |
| } |
| |
| void StallStreamSession(SpdyStream* stream) { |
| StallStreamSend(stream); |
| StallSessionSend(); |
| } |
| |
| void UnstallSessionOnly(SpdyStream* stream, int32_t delta_window_size) { |
| UnstallSessionSend(delta_window_size); |
| } |
| |
| void UnstallStreamOnly(SpdyStream* stream, int32_t delta_window_size) { |
| UnstallStreamSend(stream, delta_window_size); |
| } |
| |
| void UnstallSessionStream(SpdyStream* stream, int32_t delta_window_size) { |
| UnstallSessionSend(delta_window_size); |
| UnstallStreamSend(stream, delta_window_size); |
| } |
| |
| void UnstallStreamSession(SpdyStream* stream, int32_t delta_window_size) { |
| UnstallStreamSend(stream, delta_window_size); |
| UnstallSessionSend(delta_window_size); |
| } |
| |
| protected: |
| explicit SpdySessionTest(base::test::TaskEnvironment::TimeSource time_source = |
| base::test::TaskEnvironment::TimeSource::DEFAULT) |
| : WithTaskEnvironment(time_source), |
| old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group( |
| HttpNetworkSession::NORMAL_SOCKET_POOL)), |
| old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool( |
| HttpNetworkSession::NORMAL_SOCKET_POOL)), |
| test_push_delegate_(nullptr), |
| spdy_session_pool_(nullptr), |
| test_url_(kDefaultUrl), |
| test_server_(test_url_), |
| key_(HostPortPair::FromURL(test_url_), |
| ProxyServer::Direct(), |
| PRIVACY_MODE_DISABLED, |
| SpdySessionKey::IsProxySession::kFalse, |
| SocketTag(), |
| NetworkIsolationKey(), |
| false /* disable_secure_dns */), |
| ssl_(SYNCHRONOUS, OK) {} |
| |
| ~SpdySessionTest() override { |
| // Important to restore the per-pool limit first, since the pool limit must |
| // always be greater than group limit, and the tests reduce both limits. |
| ClientSocketPoolManager::set_max_sockets_per_pool( |
| HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_); |
| ClientSocketPoolManager::set_max_sockets_per_group( |
| HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_); |
| } |
| |
| void SetUp() override { |
| g_time_delta = base::TimeDelta(); |
| g_time_now = base::TimeTicks::Now(); |
| session_deps_.net_log = log_.bound().net_log(); |
| session_deps_.enable_server_push_cancellation = true; |
| } |
| |
| void CreateNetworkSession() { |
| DCHECK(!http_session_); |
| DCHECK(!spdy_session_pool_); |
| http_session_ = |
| SpdySessionDependencies::SpdyCreateSession(&session_deps_); |
| auto test_push_delegate = std::make_unique<TestServerPushDelegate>(); |
| test_push_delegate_ = test_push_delegate.get(); |
| http_session_->SetServerPushDelegate(std::move(test_push_delegate)); |
| spdy_session_pool_ = http_session_->spdy_session_pool(); |
| } |
| |
| void AddSSLSocketData() { |
| ssl_.ssl_info.cert = |
| ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
| ASSERT_TRUE(ssl_.ssl_info.cert); |
| session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl_); |
| } |
| |
| void CreateSpdySession() { |
| DCHECK(!session_); |
| session_ = |
| ::net::CreateSpdySession(http_session_.get(), key_, log_.bound()); |
| } |
| |
| void CreateTrustedSpdySession() { |
| DCHECK(!session_); |
| session_ = ::net::CreateTrustedSpdySession(http_session_.get(), key_, |
| log_.bound()); |
| } |
| |
| void StallSessionSend() { |
| // Reduce the send window size to 0 to stall. |
| while (session_send_window_size() > 0) { |
| DecreaseSendWindowSize( |
| std::min(kMaxSpdyFrameChunkSize, session_send_window_size())); |
| } |
| } |
| |
| void UnstallSessionSend(int32_t delta_window_size) { |
| IncreaseSendWindowSize(delta_window_size); |
| } |
| |
| void StallStreamSend(SpdyStream* stream) { |
| // Reduce the send window size to 0 to stall. |
| while (stream->send_window_size() > 0) { |
| stream->DecreaseSendWindowSize( |
| std::min(kMaxSpdyFrameChunkSize, stream->send_window_size())); |
| } |
| } |
| |
| void UnstallStreamSend(SpdyStream* stream, int32_t delta_window_size) { |
| stream->IncreaseSendWindowSize(delta_window_size); |
| } |
| |
| void RunResumeAfterUnstallTest( |
| base::OnceCallback<void(SpdyStream*)> stall_function, |
| base::OnceCallback<void(SpdyStream*, int32_t)> unstall_function); |
| |
| // SpdySession private methods. |
| |
| void MaybeSendPrefacePing() { session_->MaybeSendPrefacePing(); } |
| |
| void WritePingFrame(spdy::SpdyPingId unique_id, bool is_ack) { |
| session_->WritePingFrame(unique_id, is_ack); |
| } |
| |
| void CheckPingStatus(base::TimeTicks last_check_time) { |
| session_->CheckPingStatus(last_check_time); |
| } |
| |
| bool OnUnknownFrame(spdy::SpdyStreamId stream_id, uint8_t frame_type) { |
| return session_->OnUnknownFrame(stream_id, frame_type); |
| } |
| |
| void IncreaseSendWindowSize(int delta_window_size) { |
| session_->IncreaseSendWindowSize(delta_window_size); |
| } |
| |
| void DecreaseSendWindowSize(int32_t delta_window_size) { |
| session_->DecreaseSendWindowSize(delta_window_size); |
| } |
| |
| void IncreaseRecvWindowSize(int delta_window_size) { |
| session_->IncreaseRecvWindowSize(delta_window_size); |
| } |
| |
| void DecreaseRecvWindowSize(int32_t delta_window_size) { |
| session_->DecreaseRecvWindowSize(delta_window_size); |
| } |
| |
| // Accessors for SpdySession private members. |
| |
| void set_in_io_loop(bool in_io_loop) { session_->in_io_loop_ = in_io_loop; } |
| |
| void set_stream_hi_water_mark(spdy::SpdyStreamId stream_hi_water_mark) { |
| session_->stream_hi_water_mark_ = stream_hi_water_mark; |
| } |
| |
| void set_last_accepted_push_stream_id( |
| spdy::SpdyStreamId last_accepted_push_stream_id) { |
| session_->last_accepted_push_stream_id_ = last_accepted_push_stream_id; |
| } |
| |
| size_t num_pushed_streams() { return session_->num_pushed_streams_; } |
| |
| size_t num_active_pushed_streams() { |
| return session_->num_active_pushed_streams_; |
| } |
| |
| size_t max_concurrent_streams() { return session_->max_concurrent_streams_; } |
| |
| void set_max_concurrent_streams(size_t max_concurrent_streams) { |
| session_->max_concurrent_streams_ = max_concurrent_streams; |
| } |
| |
| void set_max_concurrent_pushed_streams(size_t max_concurrent_pushed_streams) { |
| session_->max_concurrent_pushed_streams_ = max_concurrent_pushed_streams; |
| } |
| |
| bool ping_in_flight() { return session_->ping_in_flight_; } |
| |
| spdy::SpdyPingId next_ping_id() { return session_->next_ping_id_; } |
| |
| base::TimeTicks last_read_time() { return session_->last_read_time_; } |
| |
| bool check_ping_status_pending() { |
| return session_->check_ping_status_pending_; |
| } |
| |
| int32_t session_send_window_size() { |
| return session_->session_send_window_size_; |
| } |
| |
| int32_t session_recv_window_size() { |
| return session_->session_recv_window_size_; |
| } |
| |
| void set_session_recv_window_size(int32_t session_recv_window_size) { |
| session_->session_recv_window_size_ = session_recv_window_size; |
| } |
| |
| int32_t session_unacked_recv_window_bytes() { |
| return session_->session_unacked_recv_window_bytes_; |
| } |
| |
| int32_t stream_initial_send_window_size() { |
| return session_->stream_initial_send_window_size_; |
| } |
| |
| void set_connection_at_risk_of_loss_time(base::TimeDelta duration) { |
| session_->connection_at_risk_of_loss_time_ = duration; |
| } |
| |
| // Quantities derived from SpdySession private members. |
| |
| size_t pending_create_stream_queue_size(RequestPriority priority) { |
| DCHECK_GE(priority, MINIMUM_PRIORITY); |
| DCHECK_LE(priority, MAXIMUM_PRIORITY); |
| return session_->pending_create_stream_queues_[priority].size(); |
| } |
| |
| size_t num_active_streams() { return session_->active_streams_.size(); } |
| |
| size_t num_created_streams() { return session_->created_streams_.size(); } |
| |
| size_t num_unclaimed_pushed_streams() { |
| return spdy_session_pool_->push_promise_index()->CountStreamsForSession( |
| session_.get()); |
| } |
| |
| bool has_unclaimed_pushed_stream_for_url(const GURL& url) { |
| return spdy_session_pool_->push_promise_index()->FindStream( |
| url, session_.get()) != kNoPushedStreamFound; |
| } |
| |
| RecordingBoundTestNetLog log_; |
| |
| // Original socket limits. Some tests set these. Safest to always restore |
| // them once each test has been run. |
| int old_max_group_sockets_; |
| int old_max_pool_sockets_; |
| |
| SpdyTestUtil spdy_util_; |
| SpdySessionDependencies session_deps_; |
| std::unique_ptr<HttpNetworkSession> http_session_; |
| base::WeakPtr<SpdySession> session_; |
| TestServerPushDelegate* test_push_delegate_; |
| SpdySessionPool* spdy_session_pool_; |
| const GURL test_url_; |
| const url::SchemeHostPort test_server_; |
| SpdySessionKey key_; |
| SSLSocketDataProvider ssl_; |
| }; |
| |
| class SpdySessionTestWithMockTime : public SpdySessionTest { |
| protected: |
| SpdySessionTestWithMockTime() |
| : SpdySessionTest(base::test::TaskEnvironment::TimeSource::MOCK_TIME) {} |
| }; |
| |
| // Try to create a SPDY session that will fail during |
| // initialization. Nothing should blow up. |
| TEST_F(SpdySessionTest, InitialReadError) { |
| CreateNetworkSession(); |
| |
| session_ = TryCreateFakeSpdySessionExpectingFailure(spdy_session_pool_, key_, |
| ERR_CONNECTION_CLOSED); |
| EXPECT_TRUE(session_); |
| // Flush the read. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| namespace { |
| |
| // A helper class that vends a callback that, when fired, destroys a |
| // given SpdyStreamRequest. |
| class StreamRequestDestroyingCallback : public TestCompletionCallbackBase { |
| public: |
| StreamRequestDestroyingCallback() = default; |
| |
| ~StreamRequestDestroyingCallback() override = default; |
| |
| void SetRequestToDestroy(std::unique_ptr<SpdyStreamRequest> request) { |
| request_ = std::move(request); |
| } |
| |
| CompletionOnceCallback MakeCallback() { |
| return base::BindOnce(&StreamRequestDestroyingCallback::OnComplete, |
| base::Unretained(this)); |
| } |
| |
| private: |
| void OnComplete(int result) { |
| request_.reset(); |
| SetResult(result); |
| } |
| |
| std::unique_ptr<SpdyStreamRequest> request_; |
| }; |
| |
| } // namespace |
| |
| // Request kInitialMaxConcurrentStreams streams. Request two more |
| // streams, but have the callback for one destroy the second stream |
| // request. Close the session. Nothing should blow up. This is a |
| // regression test for http://crbug.com/250841 . |
| TEST_F(SpdySessionTest, PendingStreamCancellingAnother) { |
| MockRead reads[] = {MockRead(ASYNC, 0, 0), }; |
| |
| SequencedSocketData data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Create the maximum number of concurrent streams. |
| for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) { |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream); |
| } |
| |
| SpdyStreamRequest request1; |
| auto request2 = std::make_unique<SpdyStreamRequest>(); |
| |
| StreamRequestDestroyingCallback callback1; |
| ASSERT_EQ(ERR_IO_PENDING, |
| request1.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, |
| test_url_, false, MEDIUM, SocketTag(), |
| NetLogWithSource(), callback1.MakeCallback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| // |callback2| is never called. |
| TestCompletionCallback callback2; |
| ASSERT_EQ(ERR_IO_PENDING, |
| request2->StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, |
| test_url_, false, MEDIUM, SocketTag(), |
| NetLogWithSource(), callback2.callback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| callback1.SetRequestToDestroy(std::move(request2)); |
| |
| session_->CloseSessionOnError(ERR_ABORTED, "Aborting session"); |
| |
| EXPECT_THAT(callback1.WaitForResult(), IsError(ERR_ABORTED)); |
| } |
| |
| // A session receiving a GOAWAY frame with no active streams should close. |
| TEST_F(SpdySessionTest, GoAwayWithNoActiveStreams) { |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
| MockRead reads[] = { |
| CreateMockRead(goaway, 0), |
| }; |
| SequencedSocketData data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Read and process the GOAWAY frame. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_FALSE(session_); |
| } |
| |
| // A session receiving a GOAWAY frame immediately with no active |
| // streams should then close. |
| TEST_F(SpdySessionTest, GoAwayImmediatelyWithNoActiveStreams) { |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
| MockRead reads[] = { |
| CreateMockRead(goaway, 0, SYNCHRONOUS), MockRead(ASYNC, 0, 1) // EOF |
| }; |
| SequencedSocketData data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(session_); |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_FALSE(data.AllReadDataConsumed()); |
| } |
| |
| // A session receiving a GOAWAY frame with active streams should close |
| // when the last active stream is closed. |
| TEST_F(SpdySessionTest, GoAwayWithActiveStreams) { |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 2), CreateMockRead(goaway, 3), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), MockRead(ASYNC, 0, 5) // EOF |
| }; |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate2(spdy_stream2); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy::SpdyHeaderBlock headers2(headers.Clone()); |
| |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream1->stream_id()); |
| EXPECT_EQ(3u, spdy_stream2->stream_id()); |
| |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Read and process the GOAWAY frame. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| EXPECT_FALSE(session_->IsStreamActive(3)); |
| EXPECT_FALSE(spdy_stream2); |
| EXPECT_TRUE(session_->IsStreamActive(1)); |
| |
| EXPECT_TRUE(session_->IsGoingAway()); |
| |
| // Should close the session. |
| spdy_stream1->Close(); |
| EXPECT_FALSE(spdy_stream1); |
| |
| EXPECT_TRUE(session_); |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Regression test for https://crbug.com/547130. |
| TEST_F(SpdySessionTest, GoAwayWithActiveAndCreatedStream) { |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(0)); |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(goaway, 2), |
| }; |
| |
| // No |req2|, because the second stream will never get activated. |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| spdy::SpdyHeaderBlock headers1( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
| |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| |
| // Active stream 1. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_EQ(1u, spdy_stream1->stream_id()); |
| EXPECT_TRUE(session_->IsStreamActive(1)); |
| |
| // Create stream corresponding to the next request. |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| // Read and process the GOAWAY frame before the second stream could be |
| // activated. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(session_); |
| |
| EXPECT_TRUE(data.AllWriteDataConsumed()); |
| EXPECT_TRUE(data.AllReadDataConsumed()); |
| } |
| |
| // Have a session receive two GOAWAY frames, with the last one causing |
| // the last active stream to be closed. The session should then be |
| // closed after the second GOAWAY frame. |
| TEST_F(SpdySessionTest, GoAwayTwice) { |
| spdy::SpdySerializedFrame goaway1(spdy_util_.ConstructSpdyGoAway(1)); |
| spdy::SpdySerializedFrame goaway2(spdy_util_.ConstructSpdyGoAway(0)); |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 2), CreateMockRead(goaway1, 3), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(goaway2, 5), |
| MockRead(ASYNC, ERR_IO_PENDING, 6), MockRead(ASYNC, 0, 7) // EOF |
| }; |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate2(spdy_stream2); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy::SpdyHeaderBlock headers2(headers.Clone()); |
| |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream1->stream_id()); |
| EXPECT_EQ(3u, spdy_stream2->stream_id()); |
| |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Read and process the first GOAWAY frame. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| EXPECT_FALSE(session_->IsStreamActive(3)); |
| EXPECT_FALSE(spdy_stream2); |
| EXPECT_TRUE(session_->IsStreamActive(1)); |
| EXPECT_TRUE(session_->IsGoingAway()); |
| |
| // Read and process the second GOAWAY frame, which should close the |
| // session. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Have a session with active streams receive a GOAWAY frame and then |
| // close it. It should handle the close properly (i.e., not try to |
| // make itself unavailable in its pool twice). |
| TEST_F(SpdySessionTest, GoAwayWithActiveStreamsThenClose) { |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 2), CreateMockRead(goaway, 3), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), MockRead(ASYNC, 0, 5) // EOF |
| }; |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate2(spdy_stream2); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy::SpdyHeaderBlock headers2(headers.Clone()); |
| |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream1->stream_id()); |
| EXPECT_EQ(3u, spdy_stream2->stream_id()); |
| |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Read and process the GOAWAY frame. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| EXPECT_FALSE(session_->IsStreamActive(3)); |
| EXPECT_FALSE(spdy_stream2); |
| EXPECT_TRUE(session_->IsStreamActive(1)); |
| EXPECT_TRUE(session_->IsGoingAway()); |
| |
| session_->CloseSessionOnError(ERR_ABORTED, "Aborting session"); |
| EXPECT_FALSE(spdy_stream1); |
| |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Process a joint read buffer which causes the session to begin draining, and |
| // then processes a GOAWAY. The session should gracefully drain. Regression test |
| // for crbug.com/379469 |
| TEST_F(SpdySessionTest, GoAwayWhileDraining) { |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req, 0), |
| }; |
| |
| spdy::SpdySerializedFrame resp( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1)); |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
| spdy::SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true)); |
| size_t joint_size = goaway.size() * 2 + body.size(); |
| |
| // Compose interleaved |goaway| and |body| frames into a single read. |
| auto buffer = std::make_unique<char[]>(joint_size); |
| { |
| size_t out = 0; |
| memcpy(&buffer[out], goaway.data(), goaway.size()); |
| out += goaway.size(); |
| memcpy(&buffer[out], body.data(), body.size()); |
| out += body.size(); |
| memcpy(&buffer[out], goaway.data(), goaway.size()); |
| out += goaway.size(); |
| ASSERT_EQ(out, joint_size); |
| } |
| spdy::SpdySerializedFrame joint_frames(buffer.get(), joint_size, false); |
| |
| MockRead reads[] = { |
| CreateMockRead(resp, 1), CreateMockRead(joint_frames, 2), |
| MockRead(ASYNC, 0, 3) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| // Stream and session closed gracefully. |
| EXPECT_TRUE(delegate.StreamIsClosed()); |
| EXPECT_THAT(delegate.WaitForClose(), IsOk()); |
| EXPECT_EQ(kUploadData, delegate.TakeReceivedData()); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Try to create a stream after receiving a GOAWAY frame. It should |
| // fail. |
| TEST_F(SpdySessionTest, CreateStreamAfterGoAway) { |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(goaway, 2), |
| MockRead(ASYNC, ERR_IO_PENDING, 3), MockRead(ASYNC, 0, 4) // EOF |
| }; |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req, 0), |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream->stream_id()); |
| |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Read and process the GOAWAY frame. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_TRUE(session_->IsStreamActive(1)); |
| |
| SpdyStreamRequest stream_request; |
| int rv = stream_request.StartRequest( |
| SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, false, MEDIUM, |
| SocketTag(), NetLogWithSource(), CompletionOnceCallback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS); |
| EXPECT_THAT(rv, IsError(ERR_FAILED)); |
| |
| EXPECT_TRUE(session_); |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Receiving a HEADERS frame after a GOAWAY frame should result in |
| // the stream being refused. |
| TEST_F(SpdySessionTest, HeadersAfterGoAway) { |
| base::HistogramTester histogram_tester; |
| |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway(1)); |
| spdy::SpdySerializedFrame push( |
| spdy_util_.ConstructSpdyPush(nullptr, 0, 2, 1, kDefaultUrl)); |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(goaway, 2), |
| MockRead(ASYNC, ERR_IO_PENDING, 3), CreateMockRead(push, 4), |
| MockRead(ASYNC, 0, 6) // EOF |
| }; |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame rst( |
| spdy_util_.ConstructSpdyRstStream(2, spdy::ERROR_CODE_REFUSED_STREAM)); |
| MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(rst, 5)}; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream->stream_id()); |
| |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Read and process the GOAWAY frame. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_TRUE(session_->IsStreamActive(1)); |
| |
| // Read and process the HEADERS frame, the subsequent RST_STREAM, |
| // and EOF. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| |
| histogram_tester.ExpectBucketCount( |
| "Net.SpdyPushedStreamFate", |
| static_cast<int>(SpdyPushedStreamFate::kGoingAway), 1); |
| histogram_tester.ExpectTotalCount("Net.SpdyPushedStreamFate", 1); |
| } |
| |
| // Regression test for https://crbug.com/903737: pushed response with status |
| // code different from 2xx or 3xx or 416 should be rejected. |
| TEST_F(SpdySessionTest, UnsupportedPushedStatusCode) { |
| base::HistogramTester histogram_tester; |
| |
| spdy::SpdyHeaderBlock push_promise_header_block; |
| push_promise_header_block[spdy::kHttp2MethodHeader] = "GET"; |
| spdy_util_.AddUrlToHeaderBlock(kPushedUrl, &push_promise_header_block); |
| spdy::SpdySerializedFrame push_promise_frame( |
| spdy_util_.ConstructSpdyPushPromise( |
| 1, 2, std::move(push_promise_header_block))); |
| |
| spdy::SpdyHeaderBlock response_header_block; |
| response_header_block[spdy::kHttp2StatusHeader] = "401"; |
| spdy::SpdySerializedFrame response_headers_frame( |
| spdy_util_.ConstructSpdyResponseHeaders( |
| 2, std::move(response_header_block), false)); |
| |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 1), CreateMockRead(push_promise_frame, 2), |
| CreateMockRead(response_headers_frame, 4), MockRead(ASYNC, 0, 6)}; |
| |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame priority( |
| spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true)); |
| spdy::SpdySerializedFrame rst( |
| spdy_util_.ConstructSpdyRstStream(2, spdy::ERROR_CODE_REFUSED_STREAM)); |
| |
| MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(priority, 3), |
| CreateMockWrite(rst, 5)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream->stream_id()); |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Read the PUSH_PROMISE and HEADERS frames. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| histogram_tester.ExpectBucketCount( |
| "Net.SpdyPushedStreamFate", |
| static_cast<int>(SpdyPushedStreamFate::kUnsupportedStatusCode), 1); |
| histogram_tester.ExpectTotalCount("Net.SpdyPushedStreamFate", 1); |
| } |
| |
| // A session observing a network change with active streams should close |
| // when the last active stream is closed. |
| TEST_F(SpdySessionTest, NetworkChangeWithActiveStreams) { |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF |
| }; |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream->stream_id()); |
| |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| spdy_session_pool_->OnIPAddressChanged(); |
| |
| // The SpdySessionPool behavior differs based on how the OSs reacts to |
| // network changes; see comment in SpdySessionPool::OnIPAddressChanged(). |
| #if defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS) |
| // For OSs where the TCP connections will close upon relevant network |
| // changes, SpdySessionPool doesn't need to force them to close, so in these |
| // cases verify the session has become unavailable but remains open and the |
| // pre-existing stream is still active. |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| EXPECT_TRUE(session_->IsGoingAway()); |
| |
| EXPECT_TRUE(session_->IsStreamActive(1)); |
| |
| // Should close the session. |
| spdy_stream->Close(); |
| #endif |
| EXPECT_FALSE(spdy_stream); |
| |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| TEST_F(SpdySessionTestWithMockTime, ClientPing) { |
| session_deps_.enable_ping = true; |
| |
| spdy::SpdySerializedFrame read_ping(spdy_util_.ConstructSpdyPing(1, true)); |
| MockRead reads[] = { |
| CreateMockRead(read_ping, 1), MockRead(ASYNC, ERR_IO_PENDING, 2), |
| MockRead(ASYNC, 0, 3) // EOF |
| }; |
| spdy::SpdySerializedFrame write_ping(spdy_util_.ConstructSpdyPing(1, false)); |
| MockWrite writes[] = { |
| CreateMockWrite(write_ping, 0), |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| TestNetworkQualityEstimator estimator; |
| |
| spdy_session_pool_->set_network_quality_estimator(&estimator); |
| |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| test::StreamDelegateSendImmediate delegate(spdy_stream1, ""); |
| spdy_stream1->SetDelegate(&delegate); |
| |
| base::TimeTicks before_ping_time = base::TimeTicks::Now(); |
| |
| // Negative value means a preface ping will always be sent. |
| set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(-1)); |
| |
| // Send a PING frame. This posts CheckPingStatus() with delay. |
| MaybeSendPrefacePing(); |
| |
| EXPECT_TRUE(ping_in_flight()); |
| EXPECT_EQ(2u, next_ping_id()); |
| EXPECT_TRUE(check_ping_status_pending()); |
| |
| // MaybeSendPrefacePing() should not send another PING frame if there is |
| // already one in flight. |
| MaybeSendPrefacePing(); |
| |
| EXPECT_TRUE(ping_in_flight()); |
| EXPECT_EQ(2u, next_ping_id()); |
| EXPECT_TRUE(check_ping_status_pending()); |
| |
| // Run posted CheckPingStatus() task. |
| FastForwardUntilNoTasksRemain(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(ping_in_flight()); |
| EXPECT_EQ(2u, next_ping_id()); |
| EXPECT_FALSE(check_ping_status_pending()); |
| EXPECT_GE(last_read_time(), before_ping_time); |
| |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); |
| |
| EXPECT_TRUE(MainThreadIsIdle()); |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_FALSE(session_); |
| EXPECT_FALSE(spdy_stream1); |
| |
| EXPECT_TRUE(data.AllWriteDataConsumed()); |
| EXPECT_TRUE(data.AllReadDataConsumed()); |
| |
| EXPECT_LE(1u, estimator.ping_rtt_received_count()); |
| } |
| |
| TEST_F(SpdySessionTest, ServerPing) { |
| spdy::SpdySerializedFrame read_ping(spdy_util_.ConstructSpdyPing(2, false)); |
| MockRead reads[] = { |
| CreateMockRead(read_ping), MockRead(SYNCHRONOUS, 0, 0) // EOF |
| }; |
| spdy::SpdySerializedFrame write_ping(spdy_util_.ConstructSpdyPing(2, true)); |
| MockWrite writes[] = { |
| CreateMockWrite(write_ping), |
| }; |
| StaticSocketDataProvider data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| test::StreamDelegateSendImmediate delegate(spdy_stream1, ""); |
| spdy_stream1->SetDelegate(&delegate); |
| |
| // Flush the read completion task. |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| EXPECT_FALSE(session_); |
| EXPECT_FALSE(spdy_stream1); |
| } |
| |
| // Cause a ping to be sent out while producing a write. The write loop |
| // should handle this properly, i.e. another DoWriteLoop task should |
| // not be posted. This is a regression test for |
| // http://crbug.com/261043 . |
| TEST_F(SpdySessionTest, PingAndWriteLoop) { |
| session_deps_.enable_ping = true; |
| session_deps_.time_func = TheNearFuture; |
| |
| spdy::SpdySerializedFrame write_ping(spdy_util_.ConstructSpdyPing(1, false)); |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST)); |
| MockWrite writes[] = { |
| CreateMockWrite(req, 0), CreateMockWrite(write_ping, 1), |
| }; |
| |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, LOWEST, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| // Shift time so that a ping will be sent out. |
| g_time_delta = base::TimeDelta::FromSeconds(11); |
| |
| base::RunLoop().RunUntilIdle(); |
| session_->CloseSessionOnError(ERR_ABORTED, "Aborting"); |
| |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| TEST_F(SpdySessionTest, StreamIdSpaceExhausted) { |
| const spdy::SpdyStreamId kLastStreamId = 0x7fffffff; |
| |
| // Test setup: |stream_hi_water_mark_| and |max_concurrent_streams_| are |
| // fixed to allow for two stream ID assignments, and three concurrent |
| // streams. Four streams are started, and two are activated. Verify the |
| // session goes away, and that the created (but not activated) and |
| // stalled streams are aborted. Also verify the activated streams complete, |
| // at which point the session closes. |
| |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, kLastStreamId - 2, MEDIUM)); |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, kLastStreamId, MEDIUM)); |
| |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
| }; |
| |
| spdy::SpdySerializedFrame resp1( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, kLastStreamId - 2)); |
| spdy::SpdySerializedFrame resp2( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, kLastStreamId)); |
| |
| spdy::SpdySerializedFrame body1( |
| spdy_util_.ConstructSpdyDataFrame(kLastStreamId - 2, true)); |
| spdy::SpdySerializedFrame body2( |
| spdy_util_.ConstructSpdyDataFrame(kLastStreamId, true)); |
| |
| MockRead reads[] = { |
| CreateMockRead(resp1, 2), CreateMockRead(resp2, 3), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), CreateMockRead(body1, 5), |
| CreateMockRead(body2, 6), MockRead(ASYNC, 0, 7) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Fix stream_hi_water_mark_ to allow for two stream activations. |
| set_stream_hi_water_mark(kLastStreamId - 2); |
| // Fix max_concurrent_streams to allow for three stream creations. |
| set_max_concurrent_streams(3); |
| |
| // Create three streams synchronously, and begin a fourth (which is stalled). |
| base::WeakPtr<SpdyStream> stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate1(stream1); |
| stream1->SetDelegate(&delegate1); |
| |
| base::WeakPtr<SpdyStream> stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate2(stream2); |
| stream2->SetDelegate(&delegate2); |
| |
| base::WeakPtr<SpdyStream> stream3 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate3(stream3); |
| stream3->SetDelegate(&delegate3); |
| |
| SpdyStreamRequest request4; |
| TestCompletionCallback callback4; |
| EXPECT_EQ(ERR_IO_PENDING, |
| request4.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, false, MEDIUM, SocketTag(), |
| NetLogWithSource(), callback4.callback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| // Streams 1-3 were created. 4th is stalled. No streams are active yet. |
| EXPECT_EQ(0u, num_active_streams()); |
| EXPECT_EQ(3u, num_created_streams()); |
| EXPECT_EQ(1u, pending_create_stream_queue_size(MEDIUM)); |
| |
| // Activate stream 1. One ID remains available. |
| stream1->SendRequestHeaders(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl), |
| NO_MORE_DATA_TO_SEND); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(kLastStreamId - 2u, stream1->stream_id()); |
| EXPECT_EQ(1u, num_active_streams()); |
| EXPECT_EQ(2u, num_created_streams()); |
| EXPECT_EQ(1u, pending_create_stream_queue_size(MEDIUM)); |
| |
| // Activate stream 2. ID space is exhausted. |
| stream2->SendRequestHeaders(spdy_util_.ConstructGetHeaderBlock(kDefaultUrl), |
| NO_MORE_DATA_TO_SEND); |
| base::RunLoop().RunUntilIdle(); |
| |
| // Active streams remain active. |
| EXPECT_EQ(kLastStreamId, stream2->stream_id()); |
| EXPECT_EQ(2u, num_active_streams()); |
| |
| // Session is going away. Created and stalled streams were aborted. |
| EXPECT_TRUE(session_->IsGoingAway()); |
| EXPECT_THAT(delegate3.WaitForClose(), IsError(ERR_HTTP2_PROTOCOL_ERROR)); |
| EXPECT_THAT(callback4.WaitForResult(), IsError(ERR_HTTP2_PROTOCOL_ERROR)); |
| EXPECT_EQ(0u, num_created_streams()); |
| EXPECT_EQ(0u, pending_create_stream_queue_size(MEDIUM)); |
| |
| // Read responses on remaining active streams. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_THAT(delegate1.WaitForClose(), IsOk()); |
| EXPECT_EQ(kUploadData, delegate1.TakeReceivedData()); |
| EXPECT_THAT(delegate2.WaitForClose(), IsOk()); |
| EXPECT_EQ(kUploadData, delegate2.TakeReceivedData()); |
| |
| // Session was destroyed. |
| EXPECT_FALSE(session_); |
| } |
| |
| // Regression test for https://crbug.com/481009. |
| TEST_F(SpdySessionTest, MaxConcurrentStreamsZero) { |
| |
| // Receive SETTINGS frame that sets max_concurrent_streams to zero. |
| spdy::SettingsMap settings_zero; |
| settings_zero[spdy::SETTINGS_MAX_CONCURRENT_STREAMS] = 0; |
| spdy::SpdySerializedFrame settings_frame_zero( |
| spdy_util_.ConstructSpdySettings(settings_zero)); |
| |
| // Acknowledge it. |
| spdy::SpdySerializedFrame settings_ack0( |
| spdy_util_.ConstructSpdySettingsAck()); |
| |
| // Receive SETTINGS frame that sets max_concurrent_streams to one. |
| spdy::SettingsMap settings_one; |
| settings_one[spdy::SETTINGS_MAX_CONCURRENT_STREAMS] = 1; |
| spdy::SpdySerializedFrame settings_frame_one( |
| spdy_util_.ConstructSpdySettings(settings_one)); |
| |
| // Acknowledge it. |
| spdy::SpdySerializedFrame settings_ack1( |
| spdy_util_.ConstructSpdySettingsAck()); |
| |
| // Request and response. |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| |
| spdy::SpdySerializedFrame resp( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1)); |
| |
| spdy::SpdySerializedFrame body(spdy_util_.ConstructSpdyDataFrame(1, true)); |
| |
| MockRead reads[] = {CreateMockRead(settings_frame_zero, 0), |
| MockRead(ASYNC, ERR_IO_PENDING, 2), |
| CreateMockRead(settings_frame_one, 3), |
| CreateMockRead(resp, 6), |
| CreateMockRead(body, 7), |
| MockRead(ASYNC, 0, 8)}; |
| |
| MockWrite writes[] = {CreateMockWrite(settings_ack0, 1), |
| CreateMockWrite(settings_ack1, 4), |
| CreateMockWrite(req, 5)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| // Create session. |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Receive SETTINGS frame that sets max_concurrent_streams to zero. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_EQ(0u, max_concurrent_streams()); |
| |
| // Start request. |
| SpdyStreamRequest request; |
| TestCompletionCallback callback; |
| int rv = |
| request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, test_url_, |
| false, MEDIUM, SocketTag(), NetLogWithSource(), |
| callback.callback(), TRAFFIC_ANNOTATION_FOR_TESTS); |
| EXPECT_THAT(rv, IsError(ERR_IO_PENDING)); |
| |
| // Stream is stalled. |
| EXPECT_EQ(1u, pending_create_stream_queue_size(MEDIUM)); |
| EXPECT_EQ(0u, num_created_streams()); |
| |
| // Receive SETTINGS frame that sets max_concurrent_streams to one. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_EQ(1u, max_concurrent_streams()); |
| |
| // Stream is created. |
| EXPECT_EQ(0u, pending_create_stream_queue_size(MEDIUM)); |
| EXPECT_EQ(1u, num_created_streams()); |
| |
| EXPECT_THAT(callback.WaitForResult(), IsOk()); |
| |
| // Send request. |
| base::WeakPtr<SpdyStream> stream = request.ReleaseStream(); |
| test::StreamDelegateDoNothing delegate(stream); |
| stream->SetDelegate(&delegate); |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| EXPECT_THAT(delegate.WaitForClose(), IsOk()); |
| EXPECT_EQ("hello!", delegate.TakeReceivedData()); |
| |
| // Finish async network reads/writes. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_TRUE(data.AllWriteDataConsumed()); |
| EXPECT_TRUE(data.AllReadDataConsumed()); |
| |
| // Session is destroyed. |
| EXPECT_FALSE(session_); |
| } |
| |
| // Verifies that an unstalled pending stream creation racing with a new stream |
| // creation doesn't violate the maximum stream concurrency. Regression test for |
| // crbug.com/373858. |
| TEST_F(SpdySessionTest, UnstallRacesWithStreamCreation) { |
| MockRead reads[] = { |
| MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever. |
| }; |
| |
| StaticSocketDataProvider data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Fix max_concurrent_streams to allow for one open stream. |
| set_max_concurrent_streams(1); |
| |
| // Create two streams: one synchronously, and one which stalls. |
| base::WeakPtr<SpdyStream> stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| |
| SpdyStreamRequest request2; |
| TestCompletionCallback callback2; |
| EXPECT_EQ(ERR_IO_PENDING, |
| request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, false, MEDIUM, SocketTag(), |
| NetLogWithSource(), callback2.callback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| EXPECT_EQ(1u, num_created_streams()); |
| EXPECT_EQ(1u, pending_create_stream_queue_size(MEDIUM)); |
| |
| // Cancel the first stream. A callback to unstall the second stream was |
| // posted. Don't run it yet. |
| stream1->Cancel(ERR_ABORTED); |
| |
| EXPECT_EQ(0u, num_created_streams()); |
| EXPECT_EQ(0u, pending_create_stream_queue_size(MEDIUM)); |
| |
| // Create a third stream prior to the second stream's callback. |
| base::WeakPtr<SpdyStream> stream3 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| |
| EXPECT_EQ(1u, num_created_streams()); |
| EXPECT_EQ(0u, pending_create_stream_queue_size(MEDIUM)); |
| |
| // Now run the message loop. The unstalled stream will re-stall itself. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_EQ(1u, num_created_streams()); |
| EXPECT_EQ(1u, pending_create_stream_queue_size(MEDIUM)); |
| |
| // Cancel the third stream and run the message loop. Verify that the second |
| // stream creation now completes. |
| stream3->Cancel(ERR_ABORTED); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, num_created_streams()); |
| EXPECT_EQ(0u, pending_create_stream_queue_size(MEDIUM)); |
| EXPECT_THAT(callback2.WaitForResult(), IsOk()); |
| } |
| |
| TEST_F(SpdySessionTest, CancelPushAfterSessionGoesAway) { |
| base::HistogramTester histogram_tester; |
| |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame priority( |
| spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true)); |
| MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(priority, 2)}; |
| |
| spdy::SpdySerializedFrame push( |
| spdy_util_.ConstructSpdyPush(nullptr, 0, 2, 1, kPushedUrl)); |
| spdy::SpdySerializedFrame push_body( |
| spdy_util_.ConstructSpdyDataFrame(2, false)); |
| MockRead reads[] = {CreateMockRead(push, 1), CreateMockRead(push_body, 3), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), |
| MockRead(ASYNC, 0, 5)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| // Verify that there is one unclaimed push stream. |
| const GURL pushed_url(kPushedUrl); |
| EXPECT_EQ(1u, num_unclaimed_pushed_streams()); |
| EXPECT_TRUE(has_unclaimed_pushed_stream_for_url(pushed_url)); |
| |
| // Unclaimed push body consumes bytes from the session window. |
| EXPECT_EQ(kDefaultInitialWindowSize - kUploadDataSize, |
| session_recv_window_size()); |
| EXPECT_EQ(0, session_unacked_recv_window_bytes()); |
| |
| // Read and process EOF. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| |
| // Cancel the push after session goes away. The test must not crash. |
| EXPECT_FALSE(session_); |
| EXPECT_TRUE(test_push_delegate_->CancelPush(pushed_url)); |
| |
| histogram_tester.ExpectBucketCount("Net.SpdyStreamsPushedPerSession", 1, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedBytes", 6, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedAndUnclaimedBytes", |
| 6, 1); |
| } |
| |
| TEST_F(SpdySessionTestWithMockTime, CancelPushAfterExpired) { |
| base::HistogramTester histogram_tester; |
| |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame priority( |
| spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true)); |
| spdy::SpdySerializedFrame rst( |
| spdy_util_.ConstructSpdyRstStream(2, spdy::ERROR_CODE_REFUSED_STREAM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req, 0), CreateMockWrite(priority, 3), |
| CreateMockWrite(rst, 5), |
| }; |
| |
| spdy::SpdySerializedFrame push( |
| spdy_util_.ConstructSpdyPush(nullptr, 0, 2, 1, kPushedUrl)); |
| spdy::SpdySerializedFrame push_body( |
| spdy_util_.ConstructSpdyDataFrame(2, false)); |
| MockRead reads[] = {CreateMockRead(push, 1), CreateMockRead(push_body, 2), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), |
| MockRead(ASYNC, 0, 6)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| RunUntilIdle(); |
| |
| // Verify that there is one unclaimed push stream. |
| const GURL pushed_url(kPushedUrl); |
| EXPECT_EQ(1u, num_unclaimed_pushed_streams()); |
| EXPECT_TRUE(has_unclaimed_pushed_stream_for_url(pushed_url)); |
| |
| // Unclaimed push body consumes bytes from the session window. |
| EXPECT_EQ(kDefaultInitialWindowSize - kUploadDataSize, |
| session_recv_window_size()); |
| EXPECT_EQ(0, session_unacked_recv_window_bytes()); |
| |
| // Fast forward to CancelPushedStreamIfUnclaimed() that was posted with a |
| // delay. |
| FastForwardUntilNoTasksRemain(); |
| RunUntilIdle(); |
| |
| // Verify that pushed stream is cancelled. |
| EXPECT_EQ(0u, num_unclaimed_pushed_streams()); |
| |
| // Verify that the session window reclaimed the evicted stream body. |
| EXPECT_EQ(kDefaultInitialWindowSize, session_recv_window_size()); |
| EXPECT_EQ(kUploadDataSize, session_unacked_recv_window_bytes()); |
| |
| // Try to cancel the expired push after its expiration: must not crash. |
| EXPECT_TRUE(session_); |
| EXPECT_TRUE(test_push_delegate_->CancelPush(pushed_url)); |
| EXPECT_EQ(0u, num_unclaimed_pushed_streams()); |
| |
| // Read and process EOF. |
| data.Resume(); |
| RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| |
| histogram_tester.ExpectBucketCount("Net.SpdyStreamsPushedPerSession", 1, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedBytes", 6, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedAndUnclaimedBytes", |
| 6, 1); |
| |
| histogram_tester.ExpectBucketCount( |
| "Net.SpdyPushedStreamFate", |
| static_cast<int>(SpdyPushedStreamFate::kTimeout), 1); |
| histogram_tester.ExpectTotalCount("Net.SpdyPushedStreamFate", 1); |
| } |
| |
| TEST_F(SpdySessionTestWithMockTime, ClaimPushedStreamBeforeExpires) { |
| base::HistogramTester histogram_tester; |
| |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame priority( |
| spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true)); |
| MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(priority, 3)}; |
| |
| spdy::SpdySerializedFrame push( |
| spdy_util_.ConstructSpdyPush(nullptr, 0, 2, 1, kPushedUrl)); |
| spdy::SpdySerializedFrame push_body( |
| spdy_util_.ConstructSpdyDataFrame(2, false)); |
| MockRead reads[] = {CreateMockRead(push, 1), CreateMockRead(push_body, 2), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), |
| MockRead(ASYNC, 0, 5)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| spdy::SpdyHeaderBlock headers1( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers1), NO_MORE_DATA_TO_SEND); |
| |
| RunUntilIdle(); |
| |
| // Verify that there is one unclaimed push stream. |
| const GURL pushed_url(kPushedUrl); |
| EXPECT_EQ(1u, num_unclaimed_pushed_streams()); |
| EXPECT_TRUE(has_unclaimed_pushed_stream_for_url(pushed_url)); |
| |
| // Unclaimed push body consumes bytes from the session window. |
| EXPECT_EQ(kDefaultInitialWindowSize - kUploadDataSize, |
| session_recv_window_size()); |
| EXPECT_EQ(0, session_unacked_recv_window_bytes()); |
| |
| // Claim pushed stream from Http2PushPromiseIndex. |
| HttpRequestInfo push_request; |
| push_request.url = pushed_url; |
| push_request.method = "GET"; |
| base::WeakPtr<SpdySession> session_with_pushed_stream; |
| spdy::SpdyStreamId pushed_stream_id; |
| spdy_session_pool_->push_promise_index()->ClaimPushedStream( |
| key_, pushed_url, push_request, &session_with_pushed_stream, |
| &pushed_stream_id); |
| EXPECT_EQ(session_.get(), session_with_pushed_stream.get()); |
| EXPECT_EQ(2u, pushed_stream_id); |
| |
| // Verify that pushed stream is claimed. |
| EXPECT_EQ(0u, num_unclaimed_pushed_streams()); |
| |
| SpdyStream* spdy_stream2; |
| int rv = session_->GetPushedStream(pushed_url, pushed_stream_id, MEDIUM, |
| &spdy_stream2); |
| ASSERT_THAT(rv, IsOk()); |
| ASSERT_TRUE(spdy_stream2); |
| |
| test::StreamDelegateDoNothing delegate2(spdy_stream2->GetWeakPtr()); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| // Fast forward to CancelPushedStreamIfUnclaimed() that was posted with a |
| // delay. CancelPushedStreamIfUnclaimed() must be a no-op. |
| FastForwardUntilNoTasksRemain(); |
| RunUntilIdle(); |
| EXPECT_TRUE(session_); |
| |
| // Read and process EOF. |
| data.Resume(); |
| RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| |
| histogram_tester.ExpectBucketCount("Net.SpdyStreamsPushedPerSession", 1, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedBytes", 6, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedAndUnclaimedBytes", |
| 0, 1); |
| } |
| |
| TEST_F(SpdySessionTest, CancelPushBeforeClaimed) { |
| base::HistogramTester histogram_tester; |
| |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame priority( |
| spdy_util_.ConstructSpdyPriority(2, 1, IDLE, true)); |
| spdy::SpdySerializedFrame rst( |
| spdy_util_.ConstructSpdyRstStream(2, spdy::ERROR_CODE_CANCEL)); |
| MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(priority, 3), |
| CreateMockWrite(rst, 5)}; |
| |
| spdy::SpdySerializedFrame push( |
| spdy_util_.ConstructSpdyPush(nullptr, 0, 2, 1, kPushedUrl)); |
| spdy::SpdySerializedFrame push_body( |
| spdy_util_.ConstructSpdyDataFrame(2, false)); |
| MockRead reads[] = {CreateMockRead(push, 1), CreateMockRead(push_body, 2), |
| MockRead(ASYNC, ERR_IO_PENDING, 4), |
| MockRead(ASYNC, 0, 6)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| // Verify that there is one unclaimed push stream. |
| const GURL pushed_url(kPushedUrl); |
| EXPECT_EQ(1u, num_unclaimed_pushed_streams()); |
| EXPECT_TRUE(has_unclaimed_pushed_stream_for_url(pushed_url)); |
| |
| // Unclaimed push body consumes bytes from the session window. |
| EXPECT_EQ(kDefaultInitialWindowSize - kUploadDataSize, |
| session_recv_window_size()); |
| EXPECT_EQ(0, session_unacked_recv_window_bytes()); |
| |
| // Cancel the push before it is claimed. This normally happens because |
| // resource is found in cache. |
| EXPECT_TRUE(test_push_delegate_->CancelPush(pushed_url)); |
| EXPECT_EQ(0u, num_unclaimed_pushed_streams()); |
| EXPECT_FALSE(has_unclaimed_pushed_stream_for_url(pushed_url)); |
| |
| // Verify that the session window reclaimed the evicted stream body. |
| EXPECT_EQ(kDefaultInitialWindowSize, session_recv_window_size()); |
| EXPECT_EQ(kUploadDataSize, session_unacked_recv_window_bytes()); |
| |
| EXPECT_TRUE(session_); |
| |
| // Read and process EOF. |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| |
| histogram_tester.ExpectBucketCount("Net.SpdyStreamsPushedPerSession", 1, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedBytes", 6, 1); |
| histogram_tester.ExpectBucketCount("Net.SpdySession.PushedAndUnclaimedBytes", |
| 6, 1); |
| |
| histogram_tester.ExpectBucketCount( |
| "Net.SpdyPushedStreamFate", |
| static_cast<int>(SpdyPushedStreamFate::kAlreadyInCache), 1); |
| histogram_tester.ExpectTotalCount("Net.SpdyPushedStreamFate", 1); |
| } |
| |
| TEST_F(SpdySessionTestWithMockTime, FailedPing) { |
| session_deps_.enable_ping = true; |
| session_deps_.time_func = TheNearFuture; |
| |
| MockRead reads[] = {MockRead(SYNCHRONOUS, ERR_IO_PENDING)}; // Stall forever. |
| spdy::SpdySerializedFrame write_ping(spdy_util_.ConstructSpdyPing(1, false)); |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway( |
| 0, spdy::ERROR_CODE_PROTOCOL_ERROR, "Failed ping.")); |
| MockWrite writes[] = {CreateMockWrite(write_ping), CreateMockWrite(goaway)}; |
| |
| StaticSocketDataProvider data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| test::StreamDelegateSendImmediate delegate(spdy_stream1, ""); |
| spdy_stream1->SetDelegate(&delegate); |
| |
| // Negative value means a preface ping will always be sent. |
| set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(-1)); |
| |
| // Send a PING frame. This posts CheckPingStatus() with delay. |
| MaybeSendPrefacePing(); |
| EXPECT_TRUE(ping_in_flight()); |
| EXPECT_EQ(2u, next_ping_id()); |
| EXPECT_TRUE(check_ping_status_pending()); |
| |
| // Assert session is not closed. |
| EXPECT_TRUE(session_->IsAvailable()); |
| EXPECT_LT(0u, num_active_streams() + num_created_streams()); |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Run CheckPingStatus() and make it believe hung_interval has passed. |
| g_time_delta = base::TimeDelta::FromSeconds(15); |
| FastForwardUntilNoTasksRemain(); |
| base::RunLoop().RunUntilIdle(); |
| |
| // Since no response to PING has been received, |
| // CheckPingStatus() closes the connection. |
| EXPECT_TRUE(MainThreadIsIdle()); |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_FALSE(session_); |
| EXPECT_FALSE(spdy_stream1); |
| |
| EXPECT_TRUE(data.AllWriteDataConsumed()); |
| EXPECT_TRUE(data.AllReadDataConsumed()); |
| } |
| |
| // Regression test for https://crbug.com/784975. |
| TEST_F(SpdySessionTestWithMockTime, NoPingSentWhenCheckPingPending) { |
| session_deps_.enable_ping = true; |
| session_deps_.time_func = TheNearFuture; |
| |
| spdy::SpdySerializedFrame read_ping(spdy_util_.ConstructSpdyPing(1, true)); |
| MockRead reads[] = {CreateMockRead(read_ping, 1), |
| MockRead(ASYNC, ERR_IO_PENDING, 2), |
| MockRead(ASYNC, 0, 3)}; |
| |
| spdy::SpdySerializedFrame write_ping0(spdy_util_.ConstructSpdyPing(1, false)); |
| MockWrite writes[] = {CreateMockWrite(write_ping0, 0)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Negative value means a preface ping will always be sent. |
| set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(-1)); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| test::StreamDelegateSendImmediate delegate(spdy_stream1, ""); |
| spdy_stream1->SetDelegate(&delegate); |
| |
| EXPECT_FALSE(ping_in_flight()); |
| EXPECT_EQ(1u, next_ping_id()); |
| EXPECT_FALSE(check_ping_status_pending()); |
| |
| // Send preface ping and post CheckPingStatus() task with delay. |
| MaybeSendPrefacePing(); |
| |
| EXPECT_TRUE(ping_in_flight()); |
| EXPECT_EQ(2u, next_ping_id()); |
| EXPECT_TRUE(check_ping_status_pending()); |
| |
| // Read PING ACK. |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(ping_in_flight()); |
| EXPECT_TRUE(check_ping_status_pending()); |
| |
| // Fast forward mock time so that normally another ping would be sent out. |
| // However, since CheckPingStatus() is still pending, no new ping is sent. |
| g_time_delta = base::TimeDelta::FromSeconds(15); |
| MaybeSendPrefacePing(); |
| |
| EXPECT_FALSE(ping_in_flight()); |
| EXPECT_EQ(2u, next_ping_id()); |
| EXPECT_TRUE(check_ping_status_pending()); |
| |
| // Run CheckPingStatus(). |
| FastForwardUntilNoTasksRemain(); |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(check_ping_status_pending()); |
| |
| // Read EOF. |
| data.Resume(); |
| EXPECT_THAT(delegate.WaitForClose(), IsError(ERR_CONNECTION_CLOSED)); |
| |
| // Finish going away. |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_FALSE(session_); |
| |
| EXPECT_TRUE(data.AllWriteDataConsumed()); |
| EXPECT_TRUE(data.AllReadDataConsumed()); |
| } |
| |
| // Request kInitialMaxConcurrentStreams + 1 streams. Receive a |
| // settings frame increasing the max concurrent streams by 1. Make |
| // sure nothing blows up. This is a regression test for |
| // http://crbug.com/57331 . |
| TEST_F(SpdySessionTest, OnSettings) { |
| const spdy::SpdySettingsId kSpdySettingsId = |
| spdy::SETTINGS_MAX_CONCURRENT_STREAMS; |
| |
| spdy::SettingsMap new_settings; |
| const uint32_t max_concurrent_streams = kInitialMaxConcurrentStreams + 1; |
| new_settings[kSpdySettingsId] = max_concurrent_streams; |
| spdy::SpdySerializedFrame settings_frame( |
| spdy_util_.ConstructSpdySettings(new_settings)); |
| MockRead reads[] = { |
| CreateMockRead(settings_frame, 0), MockRead(ASYNC, ERR_IO_PENDING, 2), |
| MockRead(ASYNC, 0, 3), |
| }; |
| |
| spdy::SpdySerializedFrame settings_ack(spdy_util_.ConstructSpdySettingsAck()); |
| MockWrite writes[] = {CreateMockWrite(settings_ack, 1)}; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Create the maximum number of concurrent streams. |
| for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) { |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream); |
| } |
| |
| StreamReleaserCallback stream_releaser; |
| SpdyStreamRequest request; |
| ASSERT_EQ(ERR_IO_PENDING, |
| request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| false, MEDIUM, SocketTag(), NetLogWithSource(), |
| stream_releaser.MakeCallback(&request), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_THAT(stream_releaser.WaitForResult(), IsOk()); |
| |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| |
| EXPECT_TRUE(data.AllWriteDataConsumed()); |
| EXPECT_TRUE(data.AllReadDataConsumed()); |
| } |
| |
| // Create one more stream than maximum number of concurrent streams, |
| // so that one of them is pending. Cancel one stream, which should trigger the |
| // creation of the pending stream. Then cancel that one immediately as well, |
| // and make sure this does not lead to a crash. |
| // This is a regression test for https://crbug.com/63532. |
| TEST_F(SpdySessionTest, CancelPendingCreateStream) { |
| MockRead reads[] = { |
| MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever. |
| }; |
| |
| StaticSocketDataProvider data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Leave room for only one more stream to be created. |
| for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) { |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream); |
| } |
| |
| // Create 2 more streams. First will succeed. Second will be pending. |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| |
| // Use unique_ptr to let us invalidate the memory when we want to, to trigger |
| // an error in memory corruption detectors if the callback is invoked when |
| // it's not supposed to be. |
| auto callback = std::make_unique<TestCompletionCallback>(); |
| |
| SpdyStreamRequest request; |
| ASSERT_THAT( |
| request.StartRequest(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| false, MEDIUM, SocketTag(), NetLogWithSource(), |
| callback->callback(), TRAFFIC_ANNOTATION_FOR_TESTS), |
| IsError(ERR_IO_PENDING)); |
| |
| // Release the first one, this will allow the second to be created. |
| spdy_stream1->Cancel(ERR_ABORTED); |
| EXPECT_FALSE(spdy_stream1); |
| |
| request.CancelRequest(); |
| callback.reset(); |
| |
| // Should not crash when running the pending callback. |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| TEST_F(SpdySessionTest, ChangeStreamRequestPriority) { |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING) // Stall forever. |
| }; |
| |
| StaticSocketDataProvider data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| set_max_concurrent_streams(1); |
| |
| TestCompletionCallback callback1; |
| SpdyStreamRequest request1; |
| ASSERT_EQ(OK, request1.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, false, LOWEST, SocketTag(), |
| NetLogWithSource(), callback1.callback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| TestCompletionCallback callback2; |
| SpdyStreamRequest request2; |
| ASSERT_EQ(ERR_IO_PENDING, |
| request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, false, LOWEST, SocketTag(), |
| NetLogWithSource(), callback2.callback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| request1.SetPriority(HIGHEST); |
| request2.SetPriority(MEDIUM); |
| |
| ASSERT_EQ(0u, pending_create_stream_queue_size(HIGHEST)); |
| // Priority of queued request is changed. |
| ASSERT_EQ(1u, pending_create_stream_queue_size(MEDIUM)); |
| ASSERT_EQ(0u, pending_create_stream_queue_size(LOWEST)); |
| |
| base::WeakPtr<SpdyStream> stream1 = request1.ReleaseStream(); |
| // Priority of stream is updated if request has been fulfilled. |
| ASSERT_EQ(HIGHEST, stream1->priority()); |
| } |
| |
| // Attempts to extract a NetLogSource from a set of event parameters. Returns |
| // true and writes the result to |source| on success. Returns false and |
| // makes |source| an invalid source on failure. |
| bool NetLogSourceFromEventParameters(const base::Value* event_params, |
| NetLogSource* source) { |
| const base::Value* source_dict = nullptr; |
| int source_id = -1; |
| int source_type = static_cast<int>(NetLogSourceType::COUNT); |
| if (!event_params) { |
| *source = NetLogSource(); |
| return false; |
| } |
| source_dict = event_params->FindDictKey("source_dependency"); |
| if (!source_dict) { |
| *source = NetLogSource(); |
| return false; |
| } |
| base::Optional<int> opt_int; |
| opt_int = source_dict->FindIntKey("id"); |
| if (!opt_int) { |
| *source = NetLogSource(); |
| return false; |
| } |
| source_id = opt_int.value(); |
| opt_int = source_dict->FindIntKey("type"); |
| if (!opt_int) { |
| *source = NetLogSource(); |
| return false; |
| } |
| source_type = opt_int.value(); |
| |
| DCHECK_GE(source_id, 0); |
| DCHECK_LT(source_type, static_cast<int>(NetLogSourceType::COUNT)); |
| *source = NetLogSource(static_cast<NetLogSourceType>(source_type), source_id); |
| return true; |
| } |
| |
| TEST_F(SpdySessionTest, Initialize) { |
| MockRead reads[] = { |
| MockRead(ASYNC, 0, 0) // EOF |
| }; |
| |
| StaticSocketDataProvider data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Flush the read completion task. |
| base::RunLoop().RunUntilIdle(); |
| |
| auto entries = log_.GetEntries(); |
| EXPECT_LT(0u, entries.size()); |
| |
| // Check that we logged HTTP2_SESSION_INITIALIZED correctly. |
| int pos = ExpectLogContainsSomewhere( |
| entries, 0, NetLogEventType::HTTP2_SESSION_INITIALIZED, |
| NetLogEventPhase::NONE); |
| EXPECT_LT(0, pos); |
| |
| NetLogSource socket_source; |
| EXPECT_TRUE( |
| NetLogSourceFromEventParameters(&entries[pos].params, &socket_source)); |
| EXPECT_TRUE(socket_source.IsValid()); |
| EXPECT_NE(log_.bound().source().id, socket_source.id); |
| } |
| |
| TEST_F(SpdySessionTest, NetLogOnSessionGoaway) { |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway( |
| 42, spdy::ERROR_CODE_ENHANCE_YOUR_CALM, "foo")); |
| MockRead reads[] = { |
| CreateMockRead(goaway), MockRead(SYNCHRONOUS, 0, 0) // EOF |
| }; |
| |
| StaticSocketDataProvider data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Flush the read completion task. |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_FALSE(session_); |
| |
| // Check that the NetLog was filled reasonably. |
| auto entries = log_.GetEntries(); |
| EXPECT_LT(0u, entries.size()); |
| |
| int pos = ExpectLogContainsSomewhere( |
| entries, 0, NetLogEventType::HTTP2_SESSION_RECV_GOAWAY, |
| NetLogEventPhase::NONE); |
| ASSERT_EQ(42, |
| GetIntegerValueFromParams(entries[pos], "last_accepted_stream_id")); |
| ASSERT_EQ(0, GetIntegerValueFromParams(entries[pos], "active_streams")); |
| ASSERT_EQ(0, GetIntegerValueFromParams(entries[pos], "unclaimed_streams")); |
| ASSERT_EQ("11 (ENHANCE_YOUR_CALM)", |
| GetStringValueFromParams(entries[pos], "error_code")); |
| ASSERT_EQ("foo", GetStringValueFromParams(entries[pos], "debug_data")); |
| |
| // Check that we logged SPDY_SESSION_CLOSE correctly. |
| pos = ExpectLogContainsSomewhere( |
| entries, 0, NetLogEventType::HTTP2_SESSION_CLOSE, NetLogEventPhase::NONE); |
| EXPECT_THAT(GetNetErrorCodeFromParams(entries[pos]), IsOk()); |
| } |
| |
| TEST_F(SpdySessionTest, NetLogOnSessionEOF) { |
| MockRead reads[] = { |
| MockRead(SYNCHRONOUS, 0, 0) // EOF |
| }; |
| |
| StaticSocketDataProvider data(reads, base::span<MockWrite>()); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_)); |
| |
| // Flush the read completion task. |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
| EXPECT_FALSE(session_); |
| |
| // Check that the NetLog was filled reasonably. |
| auto entries = log_.GetEntries(); |
| EXPECT_LT(0u, entries.size()); |
| |
| // Check that we logged SPDY_SESSION_CLOSE correctly. |
| int pos = ExpectLogContainsSomewhere( |
| entries, 0, NetLogEventType::HTTP2_SESSION_CLOSE, NetLogEventPhase::NONE); |
| |
| if (pos < static_cast<int>(entries.size())) { |
| ASSERT_THAT(GetNetErrorCodeFromParams(entries[pos]), |
| IsError(ERR_CONNECTION_CLOSED)); |
| } else { |
| ADD_FAILURE(); |
| } |
| } |
| |
| TEST_F(SpdySessionTest, HeadersCompressionHistograms) { |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req, 0), |
| }; |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| test::StreamDelegateDoNothing delegate(spdy_stream); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| // Write request headers & capture resulting histogram update. |
| base::HistogramTester histogram_tester; |
| |
| base::RunLoop().RunUntilIdle(); |
| // Regression test of compression performance under the request fixture. |
| histogram_tester.ExpectBucketCount("Net.SpdyHeadersCompressionPercentage", 76, |
| 1); |
| |
| // Read and process EOF. |
| EXPECT_TRUE(session_); |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Queue up a low-priority HEADERS followed by a high-priority |
| // one. The high priority one should still send first and receive |
| // first. |
| TEST_F(SpdySessionTest, OutOfOrderHeaders) { |
| // Construct the request. |
| spdy::SpdySerializedFrame req_highest( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, HIGHEST)); |
| spdy::SpdySerializedFrame req_lowest( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 3, LOWEST)); |
| MockWrite writes[] = { |
| CreateMockWrite(req_highest, 0), CreateMockWrite(req_lowest, 1), |
| }; |
| |
| spdy::SpdySerializedFrame resp_highest( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1)); |
| spdy::SpdySerializedFrame body_highest( |
| spdy_util_.ConstructSpdyDataFrame(1, true)); |
| spdy::SpdySerializedFrame resp_lowest( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 3)); |
| spdy::SpdySerializedFrame body_lowest( |
| spdy_util_.ConstructSpdyDataFrame(3, true)); |
| MockRead reads[] = { |
| CreateMockRead(resp_highest, 2), CreateMockRead(body_highest, 3), |
| CreateMockRead(resp_lowest, 4), CreateMockRead(body_lowest, 5), |
| MockRead(ASYNC, 0, 6) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream_lowest = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, LOWEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream_lowest); |
| EXPECT_EQ(0u, spdy_stream_lowest->stream_id()); |
| test::StreamDelegateDoNothing delegate_lowest(spdy_stream_lowest); |
| spdy_stream_lowest->SetDelegate(&delegate_lowest); |
| |
| base::WeakPtr<SpdyStream> spdy_stream_highest = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, HIGHEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream_highest); |
| EXPECT_EQ(0u, spdy_stream_highest->stream_id()); |
| test::StreamDelegateDoNothing delegate_highest(spdy_stream_highest); |
| spdy_stream_highest->SetDelegate(&delegate_highest); |
| |
| // Queue the lower priority one first. |
| |
| spdy::SpdyHeaderBlock headers_lowest( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream_lowest->SendRequestHeaders(std::move(headers_lowest), |
| NO_MORE_DATA_TO_SEND); |
| |
| spdy::SpdyHeaderBlock headers_highest( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream_highest->SendRequestHeaders(std::move(headers_highest), |
| NO_MORE_DATA_TO_SEND); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_FALSE(spdy_stream_lowest); |
| EXPECT_FALSE(spdy_stream_highest); |
| EXPECT_EQ(3u, delegate_lowest.stream_id()); |
| EXPECT_EQ(1u, delegate_highest.stream_id()); |
| } |
| |
| TEST_F(SpdySessionTest, CancelStream) { |
| // Request 1, at HIGHEST priority, will be cancelled before it writes data. |
| // Request 2, at LOWEST priority, will be a full request and will be id 1. |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST)); |
| MockWrite writes[] = { |
| CreateMockWrite(req2, 0), |
| }; |
| |
| spdy::SpdySerializedFrame resp2( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1)); |
| spdy::SpdySerializedFrame body2(spdy_util_.ConstructSpdyDataFrame(1, true)); |
| MockRead reads[] = { |
| CreateMockRead(resp2, 1), MockRead(ASYNC, ERR_IO_PENDING, 2), |
| CreateMockRead(body2, 3), MockRead(ASYNC, 0, 4) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, HIGHEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| test::StreamDelegateDoNothing delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, LOWEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream2); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| test::StreamDelegateDoNothing delegate2(spdy_stream2); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| spdy::SpdyHeaderBlock headers2( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| |
| spdy_stream1->Cancel(ERR_ABORTED); |
| EXPECT_FALSE(spdy_stream1); |
| |
| EXPECT_EQ(0u, delegate1.stream_id()); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(0u, delegate1.stream_id()); |
| EXPECT_EQ(1u, delegate2.stream_id()); |
| |
| spdy_stream2->Cancel(ERR_ABORTED); |
| EXPECT_FALSE(spdy_stream2); |
| } |
| |
| // Create two streams that are set to re-close themselves on close, |
| // and then close the session. Nothing should blow up. Also a |
| // regression test for http://crbug.com/139518 . |
| TEST_F(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) { |
| // No actual data will be sent. |
| MockWrite writes[] = { |
| MockWrite(ASYNC, 0, 1) // EOF |
| }; |
| |
| MockRead reads[] = { |
| MockRead(ASYNC, 0, 0) // EOF |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| HIGHEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| LOWEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream2); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| test::ClosingDelegate delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| test::ClosingDelegate delegate2(spdy_stream2); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| spdy::SpdyHeaderBlock headers2( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| // Ensure that the streams have not yet been activated and assigned an id. |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| // Ensure we don't crash while closing the session. |
| session_->CloseSessionOnError(ERR_ABORTED, std::string()); |
| |
| EXPECT_FALSE(spdy_stream1); |
| EXPECT_FALSE(spdy_stream2); |
| |
| EXPECT_TRUE(delegate1.StreamIsClosed()); |
| EXPECT_TRUE(delegate2.StreamIsClosed()); |
| |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Create two streams that are set to close each other on close, and |
| // then close the session. Nothing should blow up. |
| TEST_F(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) { |
| SequencedSocketData data; |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| HIGHEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM, session_, test_url_, |
| LOWEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream2); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| // Make |spdy_stream1| close |spdy_stream2|. |
| test::ClosingDelegate delegate1(spdy_stream2); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| // Make |spdy_stream2| close |spdy_stream1|. |
| test::ClosingDelegate delegate2(spdy_stream1); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| spdy::SpdyHeaderBlock headers2( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| // Ensure that the streams have not yet been activated and assigned an id. |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| // Ensure we don't crash while closing the session. |
| session_->CloseSessionOnError(ERR_ABORTED, std::string()); |
| |
| EXPECT_FALSE(spdy_stream1); |
| EXPECT_FALSE(spdy_stream2); |
| |
| EXPECT_TRUE(delegate1.StreamIsClosed()); |
| EXPECT_TRUE(delegate2.StreamIsClosed()); |
| |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Create two streams that are set to re-close themselves on close, |
| // activate them, and then close the session. Nothing should blow up. |
| TEST_F(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) { |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
| }; |
| |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream2); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| test::ClosingDelegate delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| test::ClosingDelegate delegate2(spdy_stream2); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| spdy::SpdyHeaderBlock headers2( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| // Ensure that the streams have not yet been activated and assigned an id. |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream1->stream_id()); |
| EXPECT_EQ(3u, spdy_stream2->stream_id()); |
| |
| // Ensure we don't crash while closing the session. |
| session_->CloseSessionOnError(ERR_ABORTED, std::string()); |
| |
| EXPECT_FALSE(spdy_stream1); |
| EXPECT_FALSE(spdy_stream2); |
| |
| EXPECT_TRUE(delegate1.StreamIsClosed()); |
| EXPECT_TRUE(delegate2.StreamIsClosed()); |
| |
| EXPECT_TRUE(session_); |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Create two streams that are set to close each other on close, |
| // activate them, and then close the session. Nothing should blow up. |
| TEST_F(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) { |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 3, MEDIUM)); |
| MockWrite writes[] = { |
| CreateMockWrite(req1, 0), CreateMockWrite(req2, 1), |
| }; |
| |
| MockRead reads[] = { |
| MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| |
| base::WeakPtr<SpdyStream> spdy_stream2 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream2); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| // Make |spdy_stream1| close |spdy_stream2|. |
| test::ClosingDelegate delegate1(spdy_stream2); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| // Make |spdy_stream2| close |spdy_stream1|. |
| test::ClosingDelegate delegate2(spdy_stream1); |
| spdy_stream2->SetDelegate(&delegate2); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| spdy::SpdyHeaderBlock headers2( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| // Ensure that the streams have not yet been activated and assigned an id. |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| EXPECT_EQ(0u, spdy_stream2->stream_id()); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream1->stream_id()); |
| EXPECT_EQ(3u, spdy_stream2->stream_id()); |
| |
| // Ensure we don't crash while closing the session. |
| session_->CloseSessionOnError(ERR_ABORTED, std::string()); |
| |
| EXPECT_FALSE(spdy_stream1); |
| EXPECT_FALSE(spdy_stream2); |
| |
| EXPECT_TRUE(delegate1.StreamIsClosed()); |
| EXPECT_TRUE(delegate2.StreamIsClosed()); |
| |
| EXPECT_TRUE(session_); |
| data.Resume(); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(session_); |
| } |
| |
| // Delegate that closes a given session when the stream is closed. |
| class SessionClosingDelegate : public test::StreamDelegateDoNothing { |
| public: |
| SessionClosingDelegate(const base::WeakPtr<SpdyStream>& stream, |
| const base::WeakPtr<SpdySession>& session_to_close) |
| : StreamDelegateDoNothing(stream), |
| session_to_close_(session_to_close) {} |
| |
| ~SessionClosingDelegate() override = default; |
| |
| void OnClose(int status) override { |
| session_to_close_->CloseSessionOnError(ERR_HTTP2_PROTOCOL_ERROR, "Error"); |
| } |
| |
| private: |
| base::WeakPtr<SpdySession> session_to_close_; |
| }; |
| |
| // Close an activated stream that closes its session. Nothing should |
| // blow up. This is a regression test for https://crbug.com/263691. |
| TEST_F(SpdySessionTest, CloseActivatedStreamThatClosesSession) { |
| spdy::SpdySerializedFrame req( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, MEDIUM)); |
| spdy::SpdySerializedFrame rst( |
| spdy_util_.ConstructSpdyRstStream(1, spdy::ERROR_CODE_CANCEL)); |
| spdy::SpdySerializedFrame goaway(spdy_util_.ConstructSpdyGoAway( |
| 0, spdy::ERROR_CODE_PROTOCOL_ERROR, "Error")); |
| // The GOAWAY has higher-priority than the RST_STREAM, and is written first |
| // despite being queued second. |
| MockWrite writes[] = { |
| CreateMockWrite(req, 0), CreateMockWrite(goaway, 1), |
| CreateMockWrite(rst, 3), |
| }; |
| |
| MockRead reads[] = { |
| MockRead(ASYNC, 0, 2) // EOF |
| }; |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, MEDIUM, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream); |
| EXPECT_EQ(0u, spdy_stream->stream_id()); |
| |
| SessionClosingDelegate delegate(spdy_stream, session_); |
| spdy_stream->SetDelegate(&delegate); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| EXPECT_EQ(0u, spdy_stream->stream_id()); |
| |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(1u, spdy_stream->stream_id()); |
| |
| // Ensure we don't crash while closing the stream (which closes the |
| // session). |
| spdy_stream->Cancel(ERR_ABORTED); |
| |
| EXPECT_FALSE(spdy_stream); |
| EXPECT_TRUE(delegate.StreamIsClosed()); |
| |
| // Write the RST_STREAM & GOAWAY. |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_TRUE(data.AllWriteDataConsumed()); |
| EXPECT_TRUE(data.AllReadDataConsumed()); |
| } |
| |
| TEST_F(SpdySessionTest, VerifyDomainAuthentication) { |
| SequencedSocketData data; |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("www.example.org")); |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("mail.example.org")); |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("mail.example.com")); |
| EXPECT_FALSE(session_->VerifyDomainAuthentication("mail.google.com")); |
| } |
| |
| // Check that VerifyDomainAuthentication respects Expect-CT failures, and uses |
| // the correct NetworkIsolationKey. |
| TEST_F(SpdySessionTest, VerifyDomainAuthenticationExpectCT) { |
| base::test::ScopedFeatureList feature_list; |
| feature_list.InitWithFeatures( |
| /* enabled_features */ |
| {TransportSecurityState::kDynamicExpectCTFeature, |
| features::kPartitionExpectCTStateByNetworkIsolationKey, |
| features::kPartitionConnectionsByNetworkIsolationKey, |
| features::kPartitionSSLSessionsByNetworkIsolationKey}, |
| /* disabled_features */ |
| {}); |
| |
| key_ = SpdySessionKey(HostPortPair::FromURL(test_url_), ProxyServer::Direct(), |
| PRIVACY_MODE_DISABLED, |
| SpdySessionKey::IsProxySession::kFalse, SocketTag(), |
| NetworkIsolationKey::CreateTransient(), |
| false /* disable_secure_dns */); |
| ssl_.ssl_info.ct_policy_compliance = |
| ct::CTPolicyCompliance::CT_POLICY_NOT_ENOUGH_SCTS; |
| ssl_.ssl_info.is_issued_by_known_root = true; |
| |
| // Need to create this after enabling features. |
| session_deps_.transport_security_state = |
| std::make_unique<TransportSecurityState>(); |
| |
| SequencedSocketData data; |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("www.example.org")); |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("mail.example.org")); |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("mail.example.com")); |
| EXPECT_FALSE(session_->VerifyDomainAuthentication("mail.google.com")); |
| |
| // Add Expect-CT data for all three hosts that passed the above checks, using |
| // different NetworkIsolationKeys. |
| const base::Time expiry = base::Time::Now() + base::TimeDelta::FromDays(1); |
| session_deps_.transport_security_state->AddExpectCT( |
| "www.example.org", expiry, true, GURL(), NetworkIsolationKey()); |
| session_deps_.transport_security_state->AddExpectCT( |
| "mail.example.org", expiry, true, GURL(), key_.network_isolation_key()); |
| session_deps_.transport_security_state->AddExpectCT( |
| "mail.example.com", expiry, true, GURL(), |
| NetworkIsolationKey::CreateTransient()); |
| |
| // The host with the Expect-CT data that matches the SpdySession's should fail |
| // the check now. |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("www.example.org")); |
| EXPECT_FALSE(session_->VerifyDomainAuthentication("mail.example.org")); |
| EXPECT_TRUE(session_->VerifyDomainAuthentication("mail.example.com")); |
| } |
| |
| TEST_F(SpdySessionTest, CloseTwoStalledCreateStream) { |
| // TODO(rtenneti): Define a helper class/methods and move the common code in |
| // this file. |
| spdy::SettingsMap new_settings; |
| const spdy::SpdySettingsId kSpdySettingsId1 = |
| spdy::SETTINGS_MAX_CONCURRENT_STREAMS; |
| const uint32_t max_concurrent_streams = 1; |
| new_settings[kSpdySettingsId1] = max_concurrent_streams; |
| |
| spdy::SpdySerializedFrame settings_ack(spdy_util_.ConstructSpdySettingsAck()); |
| spdy::SpdySerializedFrame req1( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 1, LOWEST)); |
| spdy_util_.UpdateWithStreamDestruction(1); |
| spdy::SpdySerializedFrame req2( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 3, LOWEST)); |
| spdy_util_.UpdateWithStreamDestruction(3); |
| spdy::SpdySerializedFrame req3( |
| spdy_util_.ConstructSpdyGet(nullptr, 0, 5, LOWEST)); |
| MockWrite writes[] = { |
| CreateMockWrite(settings_ack, 1), CreateMockWrite(req1, 2), |
| CreateMockWrite(req2, 5), CreateMockWrite(req3, 8), |
| }; |
| |
| // Set up the socket so we read a SETTINGS frame that sets max concurrent |
| // streams to 1. |
| spdy::SpdySerializedFrame settings_frame( |
| spdy_util_.ConstructSpdySettings(new_settings)); |
| |
| spdy::SpdySerializedFrame resp1( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1)); |
| spdy::SpdySerializedFrame body1(spdy_util_.ConstructSpdyDataFrame(1, true)); |
| |
| spdy::SpdySerializedFrame resp2( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 3)); |
| spdy::SpdySerializedFrame body2(spdy_util_.ConstructSpdyDataFrame(3, true)); |
| |
| spdy::SpdySerializedFrame resp3( |
| spdy_util_.ConstructSpdyGetReply(nullptr, 0, 5)); |
| spdy::SpdySerializedFrame body3(spdy_util_.ConstructSpdyDataFrame(5, true)); |
| |
| MockRead reads[] = { |
| CreateMockRead(settings_frame, 0), |
| CreateMockRead(resp1, 3), |
| CreateMockRead(body1, 4), |
| CreateMockRead(resp2, 6), |
| CreateMockRead(body2, 7), |
| CreateMockRead(resp3, 9), |
| CreateMockRead(body3, 10), |
| MockRead(ASYNC, ERR_IO_PENDING, 11), |
| MockRead(ASYNC, 0, 12) // EOF |
| }; |
| |
| SequencedSocketData data(reads, writes); |
| session_deps_.socket_factory->AddSocketDataProvider(&data); |
| |
| AddSSLSocketData(); |
| |
| CreateNetworkSession(); |
| CreateSpdySession(); |
| |
| // Read the settings frame. |
| base::RunLoop().RunUntilIdle(); |
| |
| base::WeakPtr<SpdyStream> spdy_stream1 = |
| CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, LOWEST, NetLogWithSource()); |
| ASSERT_TRUE(spdy_stream1); |
| EXPECT_EQ(0u, spdy_stream1->stream_id()); |
| test::StreamDelegateDoNothing delegate1(spdy_stream1); |
| spdy_stream1->SetDelegate(&delegate1); |
| |
| TestCompletionCallback callback2; |
| SpdyStreamRequest request2; |
| ASSERT_EQ(ERR_IO_PENDING, |
| request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, false, LOWEST, SocketTag(), |
| NetLogWithSource(), callback2.callback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| TestCompletionCallback callback3; |
| SpdyStreamRequest request3; |
| ASSERT_EQ(ERR_IO_PENDING, |
| request3.StartRequest(SPDY_REQUEST_RESPONSE_STREAM, session_, |
| test_url_, false, LOWEST, SocketTag(), |
| NetLogWithSource(), callback3.callback(), |
| TRAFFIC_ANNOTATION_FOR_TESTS)); |
| |
| EXPECT_EQ(0u, num_active_streams()); |
| EXPECT_EQ(1u, num_created_streams()); |
| EXPECT_EQ(2u, pending_create_stream_queue_size(LOWEST)); |
| |
| spdy::SpdyHeaderBlock headers( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| spdy_stream1->SendRequestHeaders(std::move(headers), NO_MORE_DATA_TO_SEND); |
| |
| // Run until 1st stream is activated and then closed. |
| EXPECT_EQ(0u, delegate1.stream_id()); |
| base::RunLoop().RunUntilIdle(); |
| EXPECT_FALSE(spdy_stream1); |
| EXPECT_EQ(1u, delegate1.stream_id()); |
| |
| EXPECT_EQ(0u, num_active_streams()); |
| EXPECT_EQ(1u, pending_create_stream_queue_size(LOWEST)); |
| |
| // Pump loop for SpdySession::ProcessPendingStreamRequests() to |
| // create the 2nd stream. |
| base::RunLoop().RunUntilIdle(); |
| |
| EXPECT_EQ(0u, num_active_streams()); |
| EXPECT_EQ(1u, num_created_streams()); |
| EXPECT_EQ(1u, pending_create_stream_queue_size(LOWEST)); |
| |
| base::WeakPtr<SpdyStream> stream2 = request2.ReleaseStream(); |
| test::StreamDelegateDoNothing delegate2(stream2); |
| stream2->SetDelegate(&delegate2); |
| spdy::SpdyHeaderBlock headers2( |
| spdy_util_.ConstructGetHeaderBlock(kDefaultUrl)); |
| stream2->SendRequestHeaders(std::move(headers2), NO_MORE_DATA_TO_SEND); |
| |
| // Run until 2nd stream is activated and then closed. |
| EXPECT_EQ(0u, delegate2.stream_id()); |
|