blob: baabba7ad3d40c46437167073447788a6c353520 [file] [log] [blame]
// 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/scoped_task_environment.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/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_entry.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_scoped_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 WithScopedTaskEnvironment {
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:
SpdySessionTest()
: SpdySessionTest(base::test::ScopedTaskEnvironment::MainThreadType::IO) {
}
explicit SpdySessionTest(
base::test::ScopedTaskEnvironment::MainThreadType type)
: WithScopedTaskEnvironment(type),
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()),
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(
const base::Callback<void(SpdyStream*)>& stall_function,
const base::Callback<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;
}
// 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_;
BoundTestNetLog log_;
};
class SpdySessionTestWithMockTime : public SpdySessionTest {
protected:
SpdySessionTestWithMockTime()
: SpdySessionTest(
base::test::ScopedTaskEnvironment::MainThreadType::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, nullptr);
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, nullptr);
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_ABORTED));
EXPECT_THAT(callback4.WaitForResult(), IsError(ERR_ABORTED));
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, nullptr);
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, nullptr);
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());
}
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();
TestNetLogEntry::List entries;
log_.GetEntries(&entries);
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);
TestNetLogEntry entry = entries[pos];
NetLogSource socket_source;
EXPECT_TRUE(
NetLogSource::FromEventParameters(entry.params.get(), &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.
TestNetLogEntry::List entries;
log_.GetEntries(&entries);
EXPECT_LT(0u, entries.size());
int pos = ExpectLogContainsSomewhere(
entries, 0, NetLogEventType::HTTP2_SESSION_RECV_GOAWAY,
NetLogEventPhase::NONE);
TestNetLogEntry entry = entries[pos];
int last_accepted_stream_id;
ASSERT_TRUE(entry.GetIntegerValue("last_accepted_stream_id",
&last_accepted_stream_id));
EXPECT_EQ(42, last_accepted_stream_id);
int active_streams;
ASSERT_TRUE(entry.GetIntegerValue("active_streams", &active_streams));
EXPECT_EQ(0, active_streams);
int unclaimed_streams;
ASSERT_TRUE(entry.GetIntegerValue("unclaimed_streams", &unclaimed_streams));
EXPECT_EQ(0, unclaimed_streams);
std::string error_code;
ASSERT_TRUE(entry.GetStringValue("error_code", &error_code));
EXPECT_EQ("11 (ENHANCE_YOUR_CALM)", error_code);
std::string debug_data;
ASSERT_TRUE(entry.GetStringValue("debug_data", &debug_data));
EXPECT_EQ("foo", debug_data);
// Check that we logged SPDY_SESSION_CLOSE correctly.
pos = ExpectLogContainsSomewhere(
entries, 0, NetLogEventType::HTTP2_SESSION_CLOSE, NetLogEventPhase::NONE);
entry = entries[pos];
int net_error_code = 0;
ASSERT_TRUE(entry.GetNetErrorCode(&net_error_code));
EXPECT_THAT(net_error_code, 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.
TestNetLogEntry::List entries;
log_.GetEntries(&entries);
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())) {
TestNetLogEntry entry = entries[pos];
int error_code = 0;
ASSERT_TRUE(entry.GetNetErrorCode(&error_code));
EXPECT_THAT(error_code, 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