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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/spdy/spdy_session_unittest.cc

Issue 1153653003: Use SequencedSocketData in SpdySessionTest. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Nit. Created 5 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/spdy/spdy_session_unittest.cc
diff --git a/net/spdy/spdy_session_unittest.cc b/net/spdy/spdy_session_unittest.cc
index a8196e42cacd5af4cb78eeff93cf65d0943a2e20..5ed45ae2e6e657d9d93d312c81a33acf791c433a 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -107,12 +107,12 @@ class SpdySessionTest : public PlatformTest,
HttpNetworkSession::NORMAL_SOCKET_POOL)),
spdy_util_(GetParam()),
session_deps_(GetParam()),
- spdy_session_pool_(NULL),
+ spdy_session_pool_(nullptr),
test_url_(kTestUrl),
test_host_port_pair_(kTestHost, kTestPort),
- key_(test_host_port_pair_, ProxyServer::Direct(),
- PRIVACY_MODE_DISABLED) {
- }
+ key_(test_host_port_pair_,
+ ProxyServer::Direct(),
+ PRIVACY_MODE_DISABLED) {}
virtual ~SpdySessionTest() {
// Important to restore the per-pool limit first, since the pool limit must
@@ -125,12 +125,6 @@ class SpdySessionTest : public PlatformTest,
void SetUp() override { g_time_delta = base::TimeDelta(); }
- void CreateDeterministicNetworkSession() {
- http_session_ =
- SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_);
- spdy_session_pool_ = http_session_->spdy_session_pool();
- }
-
void CreateNetworkSession() {
http_session_ =
SpdySessionDependencies::SpdyCreateSession(&session_deps_);
@@ -189,7 +183,7 @@ INSTANTIATE_TEST_CASE_P(NextProto,
// Try to create a SPDY session that will fail during
// initialization. Nothing should blow up.
TEST_P(SpdySessionTest, InitialReadError) {
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session = TryCreateFakeSpdySessionExpectingFailure(
spdy_session_pool_, key_, ERR_CONNECTION_CLOSED);
@@ -238,12 +232,10 @@ TEST_P(SpdySessionTest, PendingStreamCancellingAnother) {
MockRead reads[] = {MockRead(ASYNC, 0, 0), };
- DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -252,7 +244,7 @@ TEST_P(SpdySessionTest, PendingStreamCancellingAnother) {
for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) {
base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream != NULL);
+ ASSERT_TRUE(spdy_stream != nullptr);
}
SpdyStreamRequest request1;
@@ -288,16 +280,14 @@ TEST_P(SpdySessionTest, PendingStreamCancellingAnother) {
TEST_P(SpdySessionTest, GoAwayWithNoActiveStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
CreateMockRead(*goaway, 0),
};
- DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -307,10 +297,9 @@ TEST_P(SpdySessionTest, GoAwayWithNoActiveStreams) {
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Read and process the GOAWAY frame.
- data.RunFor(1);
- EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
base::RunLoop().RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
+ EXPECT_FALSE(session);
}
// A session receiving a GOAWAY frame immediately with no active
@@ -318,18 +307,14 @@ TEST_P(SpdySessionTest, GoAwayWithNoActiveStreams) {
TEST_P(SpdySessionTest, GoAwayImmediatelyWithNoActiveStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 0, SYNCHRONOUS),
+ CreateMockRead(*goaway, 0, SYNCHRONOUS), MockRead(ASYNC, 0, 1) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
-
- CreateDeterministicNetworkSession();
+ SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- data.StopAfter(1);
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
TryCreateInsecureSpdySessionExpectingFailure(
@@ -338,6 +323,7 @@ TEST_P(SpdySessionTest, GoAwayImmediatelyWithNoActiveStreams) {
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
@@ -345,26 +331,25 @@ TEST_P(SpdySessionTest, GoAwayImmediatelyWithNoActiveStreams) {
TEST_P(SpdySessionTest, GoAwayWithActiveStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 2),
- MockRead(ASYNC, 0, 3) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*goaway, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ MockRead(ASYNC, 0, 5) // EOF
};
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
CreateMockWrite(*req2, 1),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -393,7 +378,7 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreams) {
spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream1->stream_id());
EXPECT_EQ(3u, spdy_stream2->stream_id());
@@ -401,22 +386,25 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreams) {
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Read and process the GOAWAY frame.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
EXPECT_FALSE(session->IsStreamActive(3));
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream2);
EXPECT_TRUE(session->IsStreamActive(1));
EXPECT_TRUE(session->IsGoingAway());
// Should close the session.
spdy_stream1->Close();
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(spdy_stream1);
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Have a session receive two GOAWAY frames, with the last one causing
@@ -425,28 +413,28 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreams) {
TEST_P(SpdySessionTest, GoAwayTwice) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway1(spdy_util_.ConstructSpdyGoAway(1));
scoped_ptr<SpdyFrame> goaway2(spdy_util_.ConstructSpdyGoAway(0));
MockRead reads[] = {
- CreateMockRead(*goaway1, 2),
- CreateMockRead(*goaway2, 3),
- MockRead(ASYNC, 0, 4) // EOF
+ 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
};
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
CreateMockWrite(*req2, 1),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -475,7 +463,7 @@ TEST_P(SpdySessionTest, GoAwayTwice) {
spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream1->stream_id());
EXPECT_EQ(3u, spdy_stream2->stream_id());
@@ -483,20 +471,21 @@ TEST_P(SpdySessionTest, GoAwayTwice) {
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Read and process the first GOAWAY frame.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
EXPECT_FALSE(session->IsStreamActive(3));
- EXPECT_EQ(NULL, spdy_stream2.get());
+ 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.RunFor(1);
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Have a session with active streams receive a GOAWAY frame and then
@@ -505,26 +494,25 @@ TEST_P(SpdySessionTest, GoAwayTwice) {
TEST_P(SpdySessionTest, GoAwayWithActiveStreamsThenClose) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 2),
- MockRead(ASYNC, 0, 3) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*goaway, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ MockRead(ASYNC, 0, 5) // EOF
};
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
CreateMockWrite(*req2, 1),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -553,7 +541,7 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreamsThenClose) {
spdy_stream2->SendRequestHeaders(headers2.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream2->HasUrlFromHeaders());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream1->stream_id());
EXPECT_EQ(3u, spdy_stream2->stream_id());
@@ -561,20 +549,22 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreamsThenClose) {
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Read and process the GOAWAY frame.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
EXPECT_FALSE(session->IsStreamActive(3));
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream2);
EXPECT_TRUE(session->IsStreamActive(1));
EXPECT_TRUE(session->IsGoingAway());
session->CloseSessionOnError(ERR_ABORTED, "Aborting session");
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(spdy_stream1);
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Process a joint read buffer which causes the session to begin draining, and
@@ -584,12 +574,13 @@ TEST_P(SpdySessionTest, GoAwayWhileDraining) {
session_deps_.host_resolver->set_synchronous_mode(true);
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req, 0),
};
- scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
size_t joint_size = goaway->size() * 2 + body->size();
@@ -613,13 +604,10 @@ TEST_P(SpdySessionTest, GoAwayWhileDraining) {
MockRead(ASYNC, 0, 3) // EOF
};
- MockConnect connect_data(SYNCHRONOUS, OK);
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -634,14 +622,13 @@ TEST_P(SpdySessionTest, GoAwayWhileDraining) {
spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
- data.RunFor(3);
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
// Stream and session closed gracefully.
EXPECT_TRUE(delegate.StreamIsClosed());
EXPECT_EQ(OK, delegate.WaitForClose());
EXPECT_EQ(kUploadData, delegate.TakeReceivedData());
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
}
// Try to create a stream after receiving a GOAWAY frame. It should
@@ -649,23 +636,22 @@ TEST_P(SpdySessionTest, GoAwayWhileDraining) {
TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 1),
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*goaway, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ MockRead(ASYNC, 0, 4) // EOF
};
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req, 0),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -684,14 +670,15 @@ TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream->stream_id());
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Read and process the GOAWAY frame.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
EXPECT_TRUE(session->IsStreamActive(1));
@@ -702,10 +689,10 @@ TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
CompletionCallback());
EXPECT_EQ(ERR_FAILED, rv);
- // Read and process EOF.
- data.RunFor(1);
-
- EXPECT_TRUE(session == NULL);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Receiving a SYN_STREAM frame after a GOAWAY frame should result in
@@ -713,29 +700,25 @@ TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
TEST_P(SpdySessionTest, SynStreamAfterGoAway) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
- scoped_ptr<SpdyFrame>
- push(spdy_util_.ConstructSpdyPush(NULL, 0, 2, 1, kDefaultURL));
+ scoped_ptr<SpdyFrame> push(
+ spdy_util_.ConstructSpdyPush(nullptr, 0, 2, 1, kDefaultURL));
MockRead reads[] = {
- CreateMockRead(*goaway, 1),
- CreateMockRead(*push, 2),
- MockRead(ASYNC, 0, 4) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*goaway, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ CreateMockRead(*push, 4),
+ MockRead(ASYNC, 0, 6) // EOF
};
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
- MockWrite writes[] = {
- CreateMockWrite(*req, 0),
- CreateMockWrite(*rst, 3)
- };
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*rst, 5)};
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -754,23 +737,24 @@ TEST_P(SpdySessionTest, SynStreamAfterGoAway) {
spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream->stream_id());
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Read and process the GOAWAY frame.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
EXPECT_TRUE(session->IsStreamActive(1));
// Read and process the SYN_STREAM frame, the subsequent RST_STREAM,
// and EOF.
- data.RunFor(3);
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// A session observing a network change with active streams should close
@@ -778,21 +762,18 @@ TEST_P(SpdySessionTest, SynStreamAfterGoAway) {
TEST_P(SpdySessionTest, NetworkChangeWithActiveStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(ASYNC, 0, 1) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF
};
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -811,7 +792,7 @@ TEST_P(SpdySessionTest, NetworkChangeWithActiveStreams) {
spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream->HasUrlFromHeaders());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream->stream_id());
@@ -835,32 +816,31 @@ TEST_P(SpdySessionTest, NetworkChangeWithActiveStreams) {
// Should close the session.
spdy_stream->Close();
#endif
- EXPECT_EQ(NULL, spdy_stream.get());
+ EXPECT_FALSE(spdy_stream);
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, ClientPing) {
session_deps_.enable_ping = true;
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(1, true));
MockRead reads[] = {
- CreateMockRead(*read_ping, 1),
- MockRead(ASYNC, 0, 0, 2) // EOF
+ CreateMockRead(*read_ping, 1),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ MockRead(ASYNC, 0, 3) // EOF
};
scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1, false));
MockWrite writes[] = {
CreateMockWrite(*write_ping, 0),
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -868,8 +848,8 @@ TEST_P(SpdySessionTest, ClientPing) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
- test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
+ test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr);
spdy_stream1->SetDelegate(&delegate);
base::TimeTicks before_ping_time = base::TimeTicks::Now();
@@ -880,7 +860,7 @@ TEST_P(SpdySessionTest, ClientPing) {
session->SendPrefacePingIfNoneInFlight();
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
session->CheckPingStatus(before_ping_time);
@@ -889,18 +869,18 @@ TEST_P(SpdySessionTest, ClientPing) {
EXPECT_FALSE(session->check_ping_status_pending());
EXPECT_GE(session->last_activity_time(), before_ping_time);
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, ServerPing) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(2, false));
MockRead reads[] = {
CreateMockRead(*read_ping),
@@ -912,7 +892,6 @@ TEST_P(SpdySessionTest, ServerPing) {
};
StaticSocketDataProvider data(
reads, arraysize(reads), writes, arraysize(writes));
- data.set_connect_data(connect_data);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -923,17 +902,17 @@ TEST_P(SpdySessionTest, ServerPing) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
- test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
+ test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr);
spdy_stream1->SetDelegate(&delegate);
// Flush the read completion task.
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
- EXPECT_TRUE(session == NULL);
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(session);
+ EXPECT_FALSE(spdy_stream1);
}
// Cause a ping to be sent out while producing a write. The write loop
@@ -944,27 +923,24 @@ TEST_P(SpdySessionTest, PingAndWriteLoop) {
session_deps_.enable_ping = true;
session_deps_.time_func = TheNearFuture;
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1, false));
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
MockWrite writes[] = {
CreateMockWrite(*req, 0),
CreateMockWrite(*write_ping, 1),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF
};
session_deps_.host_resolver->set_synchronous_mode(true);
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -983,9 +959,12 @@ TEST_P(SpdySessionTest, PingAndWriteLoop) {
// Shift time so that a ping will be sent out.
g_time_delta = base::TimeDelta::FromSeconds(11);
- data.RunFor(2);
-
+ base::RunLoop().RunUntilIdle();
session->CloseSessionOnError(ERR_ABORTED, "Aborting");
+
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, StreamIdSpaceExhausted) {
@@ -1000,18 +979,18 @@ TEST_P(SpdySessionTest, StreamIdSpaceExhausted) {
// at which point the session closes.
scoped_ptr<SpdyFrame> req1(spdy_util_.ConstructSpdyGet(
- NULL, 0, false, kLastStreamId - 2, MEDIUM, true));
- scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, kLastStreamId, MEDIUM, true));
+ nullptr, 0, false, kLastStreamId - 2, MEDIUM, true));
+ scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyGet(
+ nullptr, 0, false, kLastStreamId, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
};
scoped_ptr<SpdyFrame> resp1(
- spdy_util_.ConstructSpdyGetSynReply(NULL, 0, kLastStreamId - 2));
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, kLastStreamId - 2));
scoped_ptr<SpdyFrame> resp2(
- spdy_util_.ConstructSpdyGetSynReply(NULL, 0, kLastStreamId));
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, kLastStreamId));
scoped_ptr<SpdyFrame> body1(
spdy_util_.ConstructSpdyBodyFrame(kLastStreamId - 2, true));
@@ -1019,19 +998,18 @@ TEST_P(SpdySessionTest, StreamIdSpaceExhausted) {
spdy_util_.ConstructSpdyBodyFrame(kLastStreamId, true));
MockRead reads[] = {
- CreateMockRead(*resp1, 2), CreateMockRead(*resp2, 3),
- CreateMockRead(*body1, 4), CreateMockRead(*body2, 5),
- MockRead(ASYNC, 0, 6) // EOF
+ CreateMockRead(*resp1, 2),
+ CreateMockRead(*resp2, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ CreateMockRead(*body1, 5),
+ CreateMockRead(*body2, 6),
+ MockRead(ASYNC, 0, 7) // EOF
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
-
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -1077,7 +1055,7 @@ TEST_P(SpdySessionTest, StreamIdSpaceExhausted) {
scoped_ptr<SpdyHeaderBlock>(
spdy_util_.ConstructGetHeaderBlock(url.spec())),
NO_MORE_DATA_TO_SEND);
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(kLastStreamId - 2u, stream1->stream_id());
EXPECT_EQ(1u, session->num_active_streams());
@@ -1089,7 +1067,7 @@ TEST_P(SpdySessionTest, StreamIdSpaceExhausted) {
scoped_ptr<SpdyHeaderBlock>(
spdy_util_.ConstructGetHeaderBlock(url.spec())),
NO_MORE_DATA_TO_SEND);
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
// Active streams remain active.
EXPECT_EQ(kLastStreamId, stream2->stream_id());
@@ -1103,15 +1081,15 @@ TEST_P(SpdySessionTest, StreamIdSpaceExhausted) {
EXPECT_EQ(0u, session->pending_create_stream_queue_size(MEDIUM));
// Read responses on remaining active streams.
- data.RunFor(4);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(OK, delegate1.WaitForClose());
EXPECT_EQ(kUploadData, delegate1.TakeReceivedData());
EXPECT_EQ(OK, delegate2.WaitForClose());
EXPECT_EQ(kUploadData, delegate2.TakeReceivedData());
// Session was destroyed.
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_FALSE(session.get());
+ EXPECT_FALSE(session);
}
// Verifies that an unstalled pending stream creation racing with a new stream
@@ -1124,10 +1102,7 @@ TEST_P(SpdySessionTest, UnstallRacesWithStreamCreation) {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
-
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -1169,15 +1144,15 @@ TEST_P(SpdySessionTest, UnstallRacesWithStreamCreation) {
EXPECT_EQ(1u, session->num_created_streams());
EXPECT_EQ(0u, session->pending_create_stream_queue_size(MEDIUM));
- // NOW run the message loop. The unstalled stream will re-stall itself.
- base::MessageLoop::current()->RunUntilIdle();
+ // Now run the message loop. The unstalled stream will re-stall itself.
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, session->num_created_streams());
EXPECT_EQ(1u, session->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();
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, session->num_created_streams());
EXPECT_EQ(0u, session->pending_create_stream_queue_size(MEDIUM));
@@ -1189,31 +1164,32 @@ TEST_P(SpdySessionTest, DeleteExpiredPushStreams) {
session_deps_.time_func = TheNearFuture;
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
+ MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*rst, 5)};
scoped_ptr<SpdyFrame> push_a(spdy_util_.ConstructSpdyPush(
- NULL, 0, 2, 1, "http://www.example.org/a.dat"));
+ nullptr, 0, 2, 1, "http://www.example.org/a.dat"));
scoped_ptr<SpdyFrame> push_a_body(
spdy_util_.ConstructSpdyBodyFrame(2, false));
// In ascii "0" < "a". We use it to verify that we properly handle std::map
// iterators inside. See http://crbug.com/443490
scoped_ptr<SpdyFrame> push_b(spdy_util_.ConstructSpdyPush(
- NULL, 0, 4, 1, "http://www.example.org/0.dat"));
- MockWrite writes[] = {CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4)};
+ nullptr, 0, 4, 1, "http://www.example.org/0.dat"));
MockRead reads[] = {
- CreateMockRead(*push_a, 1), CreateMockRead(*push_a_body, 2),
- CreateMockRead(*push_b, 3), MockRead(ASYNC, 0, 5), // EOF
+ CreateMockRead(*push_a, 1),
+ CreateMockRead(*push_a_body, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ CreateMockRead(*push_b, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 6),
+ MockRead(ASYNC, 0, 7) // EOF
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -1228,7 +1204,7 @@ TEST_P(SpdySessionTest, DeleteExpiredPushStreams) {
spdy_util_.ConstructGetHeaderBlock(url.spec()));
spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
- data.RunFor(3);
+ base::RunLoop().RunUntilIdle();
// Verify that there is one unclaimed push stream.
EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
@@ -1249,7 +1225,8 @@ TEST_P(SpdySessionTest, DeleteExpiredPushStreams) {
// Shift time to expire the push stream. Read the second SYN_STREAM,
// and verify a RST_STREAM was written.
g_time_delta = base::TimeDelta::FromSeconds(301);
- data.RunFor(2);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
// Verify that the second pushed stream evicted the first pushed stream.
EXPECT_EQ(1u, session->num_unclaimed_pushed_streams());
@@ -1266,15 +1243,15 @@ TEST_P(SpdySessionTest, DeleteExpiredPushStreams) {
}
// Read and process EOF.
- data.RunFor(1);
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, FailedPing) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
@@ -1282,9 +1259,9 @@ TEST_P(SpdySessionTest, FailedPing) {
scoped_ptr<SpdyFrame> goaway(
spdy_util_.ConstructSpdyGoAway(0, GOAWAY_PROTOCOL_ERROR, "Failed ping."));
MockWrite writes[] = {CreateMockWrite(*write_ping), CreateMockWrite(*goaway)};
+
StaticSocketDataProvider data(
reads, arraysize(reads), writes, arraysize(writes));
- data.set_connect_data(connect_data);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -1295,8 +1272,8 @@ TEST_P(SpdySessionTest, FailedPing) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
- test::StreamDelegateSendImmediate delegate(spdy_stream1, NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
+ test::StreamDelegateSendImmediate delegate(spdy_stream1, nullptr);
spdy_stream1->SetDelegate(&delegate);
session->set_connection_at_risk_of_loss_time(base::TimeDelta::FromSeconds(0));
@@ -1318,11 +1295,11 @@ TEST_P(SpdySessionTest, FailedPing) {
base::TimeTicks now = base::TimeTicks::Now();
session->last_activity_time_ = now - base::TimeDelta::FromSeconds(1);
session->CheckPingStatus(now);
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(spdy_stream1);
}
// Request kInitialMaxConcurrentStreams + 1 streams. Receive a
@@ -1334,6 +1311,13 @@ TEST_P(SpdySessionTest, OnSettings) {
const SpdySettingsIds kSpdySettingsIds = SETTINGS_MAX_CONCURRENT_STREAMS;
+ int seq = 0;
+ std::vector<MockWrite> writes;
+ scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
+ if (GetParam() >= kProtoSPDY4MinimumVersion) {
+ writes.push_back(CreateMockWrite(*settings_ack, ++seq));
+ }
+
SettingsMap new_settings;
const uint32 max_concurrent_streams = kInitialMaxConcurrentStreams + 1;
new_settings[kSpdySettingsIds] =
@@ -1341,22 +1325,16 @@ TEST_P(SpdySessionTest, OnSettings) {
scoped_ptr<SpdyFrame> settings_frame(
spdy_util_.ConstructSpdySettings(new_settings));
MockRead reads[] = {
- CreateMockRead(*settings_frame, 0),
- MockRead(ASYNC, 0, 1),
- };
-
- scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
- MockWrite writes[] = {
- CreateMockWrite(*settings_ack, 2),
+ CreateMockRead(*settings_frame, 0),
+ MockRead(ASYNC, ERR_IO_PENDING, ++seq),
+ MockRead(ASYNC, 0, ++seq),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), vector_as_array(&writes),
+ writes.size());
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -1366,7 +1344,7 @@ TEST_P(SpdySessionTest, OnSettings) {
base::WeakPtr<SpdyStream> spdy_stream =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream != NULL);
+ ASSERT_TRUE(spdy_stream != nullptr);
}
StreamReleaserCallback stream_releaser;
@@ -1377,17 +1355,16 @@ TEST_P(SpdySessionTest, OnSettings) {
BoundNetLog(),
stream_releaser.MakeCallback(&request)));
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(OK, stream_releaser.WaitForResult());
- data.RunFor(1);
- if (spdy_util_.spdy_version() >= SPDY4) {
- // Allow the SETTINGS+ACK to write, so the session finishes draining.
- data.RunFor(1);
- }
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
+
+ EXPECT_TRUE(data.AllWriteDataConsumed());
+ EXPECT_TRUE(data.AllReadDataConsumed());
}
// Start with a persisted value for max concurrent streams. Receive a
@@ -1411,16 +1388,15 @@ TEST_P(SpdySessionTest, ClearSettings) {
uint8 flags = SETTINGS_FLAG_CLEAR_PREVIOUSLY_PERSISTED_SETTINGS;
test::SetFrameFlags(settings_frame.get(), flags, spdy_util_.spdy_version());
MockRead reads[] = {
- CreateMockRead(*settings_frame, 0),
- MockRead(ASYNC, 0, 1),
+ CreateMockRead(*settings_frame, 0),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ MockRead(ASYNC, 0, 2),
};
- DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
// Initialize the SpdySetting with the default.
spdy_session_pool_->http_server_properties()->SetSpdySetting(
@@ -1441,7 +1417,7 @@ TEST_P(SpdySessionTest, ClearSettings) {
base::WeakPtr<SpdyStream> spdy_stream =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream != NULL);
+ ASSERT_TRUE(spdy_stream != nullptr);
}
StreamReleaserCallback stream_releaser;
@@ -1453,7 +1429,7 @@ TEST_P(SpdySessionTest, ClearSettings) {
BoundNetLog(),
stream_releaser.MakeCallback(&request)));
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(OK, stream_releaser.WaitForResult());
@@ -1466,8 +1442,9 @@ TEST_P(SpdySessionTest, ClearSettings) {
EXPECT_EQ(kInitialMaxConcurrentStreams + 1,
session->max_concurrent_streams());
- data.RunFor(1);
- EXPECT_TRUE(session == NULL);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Start with max concurrent streams set to 1. Request two streams.
@@ -1482,10 +1459,7 @@ TEST_P(SpdySessionTest, CancelPendingCreateStream) {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -1505,14 +1479,14 @@ TEST_P(SpdySessionTest, CancelPendingCreateStream) {
base::WeakPtr<SpdyStream> spdy_stream =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream != NULL);
+ ASSERT_TRUE(spdy_stream != nullptr);
}
// Create 2 more streams. First will succeed. Second will be pending.
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
// Use scoped_ptr to let us invalidate the memory when we want to, to trigger
// a valgrind error if the callback is invoked when it's not supposed to be.
@@ -1527,13 +1501,13 @@ TEST_P(SpdySessionTest, CancelPendingCreateStream) {
// Release the first one, this will allow the second to be created.
spdy_stream1->Cancel();
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(spdy_stream1);
request.CancelRequest();
callback.reset();
// Should not crash when running the pending callback.
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
}
TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
@@ -1546,7 +1520,6 @@ TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
SettingsMap settings;
settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> settings_frame(
spdy_util_.ConstructSpdySettings(settings));
std::vector<MockWrite> writes;
@@ -1572,7 +1545,6 @@ TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
StaticSocketDataProvider data(reads, arraysize(reads),
vector_as_array(&writes), writes.size());
- data.set_connect_data(connect_data);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -1589,7 +1561,7 @@ TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
EXPECT_TRUE(data.AllWriteDataConsumed());
}
@@ -1616,13 +1588,11 @@ TEST_P(SpdySessionTest, Initialize) {
session_deps_.net_log = log.bound().net_log();
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(ASYNC, 0, 0) // EOF
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -1632,7 +1602,7 @@ TEST_P(SpdySessionTest, Initialize) {
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Flush the read completion task.
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
TestNetLogEntry::List entries;
log.GetEntries(&entries);
@@ -1654,15 +1624,13 @@ TEST_P(SpdySessionTest, Initialize) {
TEST_P(SpdySessionTest, NetLogOnSessionGoaway) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway());
MockRead reads[] = {
CreateMockRead(*goaway),
MockRead(SYNCHRONOUS, 0, 0) // EOF
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -1673,10 +1641,10 @@ TEST_P(SpdySessionTest, NetLogOnSessionGoaway) {
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Flush the read completion task.
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
// Check that the NetLog was filled reasonably.
TestNetLogEntry::List entries;
@@ -1700,13 +1668,11 @@ TEST_P(SpdySessionTest, NetLogOnSessionGoaway) {
TEST_P(SpdySessionTest, NetLogOnSessionEOF) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(SYNCHRONOUS, 0, 0) // EOF
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -1717,10 +1683,10 @@ TEST_P(SpdySessionTest, NetLogOnSessionEOF) {
EXPECT_TRUE(HasSpdySession(spdy_session_pool_, key_));
// Flush the read completion task.
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
// Check that the NetLog was filled reasonably.
TestNetLogEntry::List entries;
@@ -1745,20 +1711,17 @@ TEST_P(SpdySessionTest, SynCompressionHistograms) {
session_deps_.enable_compression = true;
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, true, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, true, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req, 0),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 1) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -1777,7 +1740,7 @@ TEST_P(SpdySessionTest, SynCompressionHistograms) {
// Write request headers & capture resulting histogram update.
base::HistogramTester histogram_tester;
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
// Regression test of compression performance under the request fixture.
switch (spdy_util_.spdy_version()) {
case SPDY3:
@@ -1793,9 +1756,10 @@ TEST_P(SpdySessionTest, SynCompressionHistograms) {
}
// Read and process EOF.
- data.RunFor(1);
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Queue up a low-priority SYN_STREAM followed by a high-priority
@@ -1803,22 +1767,21 @@ TEST_P(SpdySessionTest, SynCompressionHistograms) {
// first.
TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
// Construct the request.
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> req_highest(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, HIGHEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, HIGHEST, true));
scoped_ptr<SpdyFrame> req_lowest(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, LOWEST, true));
MockWrite writes[] = {
CreateMockWrite(*req_highest, 0),
CreateMockWrite(*req_lowest, 1),
};
scoped_ptr<SpdyFrame> resp_highest(
- spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> body_highest(
spdy_util_.ConstructSpdyBodyFrame(1, true));
scoped_ptr<SpdyFrame> resp_lowest(
- spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 3));
scoped_ptr<SpdyFrame> body_lowest(
spdy_util_.ConstructSpdyBodyFrame(3, true));
MockRead reads[] = {
@@ -1831,12 +1794,10 @@ TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -1873,7 +1834,7 @@ TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
headers_highest.Pass(), NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream_highest->HasUrlFromHeaders());
- data.RunFor(7);
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(spdy_stream_lowest);
EXPECT_FALSE(spdy_stream_highest);
@@ -1882,31 +1843,30 @@ TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
}
TEST_P(SpdySessionTest, CancelStream) {
- MockConnect connect_data(SYNCHRONOUS, OK);
// 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.
scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
MockWrite writes[] = {
CreateMockWrite(*req2, 0),
};
- scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp2(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
MockRead reads[] = {
- CreateMockRead(*resp2, 1),
- CreateMockRead(*body2, 2),
- MockRead(ASYNC, 0, 3) // EOF
+ CreateMockRead(*resp2, 1),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*body2, 3),
+ MockRead(ASYNC, 0, 4) // EOF
};
session_deps_.host_resolver->set_synchronous_mode(true);
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -1915,7 +1875,7 @@ TEST_P(SpdySessionTest, CancelStream) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url1, HIGHEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -1924,7 +1884,7 @@ TEST_P(SpdySessionTest, CancelStream) {
base::WeakPtr<SpdyStream> spdy_stream2 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url2, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream2.get() != NULL);
+ ASSERT_TRUE(spdy_stream2.get() != nullptr);
EXPECT_EQ(0u, spdy_stream2->stream_id());
test::StreamDelegateDoNothing delegate2(spdy_stream2);
spdy_stream2->SetDelegate(&delegate2);
@@ -1942,17 +1902,17 @@ TEST_P(SpdySessionTest, CancelStream) {
EXPECT_EQ(0u, spdy_stream1->stream_id());
spdy_stream1->Cancel();
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(spdy_stream1);
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, delegate1.stream_id());
EXPECT_EQ(1u, delegate2.stream_id());
spdy_stream2->Cancel();
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream2);
}
// Create two streams that are set to re-close themselves on close,
@@ -1961,7 +1921,6 @@ TEST_P(SpdySessionTest, CancelStream) {
TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
// No actual data will be sent.
MockWrite writes[] = {
@@ -1971,12 +1930,10 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
MockRead reads[] = {
MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -1985,14 +1942,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url1, HIGHEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream2 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url2, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream2.get() != NULL);
+ ASSERT_TRUE(spdy_stream2.get() != nullptr);
EXPECT_EQ(0u, spdy_stream2->stream_id());
test::ClosingDelegate delegate1(spdy_stream1);
@@ -2018,14 +1975,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
// Ensure we don't crash while closing the session.
session->CloseSessionOnError(ERR_ABORTED, std::string());
- EXPECT_EQ(NULL, spdy_stream1.get());
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream1);
+ EXPECT_FALSE(spdy_stream2);
EXPECT_TRUE(delegate1.StreamIsClosed());
EXPECT_TRUE(delegate2.StreamIsClosed());
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Create two streams that are set to close each other on close, and
@@ -2033,22 +1990,10 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- // No actual data will be sent.
- MockWrite writes[] = {
- MockWrite(ASYNC, 0, 1) // EOF
- };
-
- MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
- };
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(nullptr, 0, nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2057,14 +2002,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url1, HIGHEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream2 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url2, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream2.get() != NULL);
+ ASSERT_TRUE(spdy_stream2);
EXPECT_EQ(0u, spdy_stream2->stream_id());
// Make |spdy_stream1| close |spdy_stream2|.
@@ -2092,14 +2037,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
// Ensure we don't crash while closing the session.
session->CloseSessionOnError(ERR_ABORTED, std::string());
- EXPECT_EQ(NULL, spdy_stream1.get());
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream1);
+ EXPECT_FALSE(spdy_stream2);
EXPECT_TRUE(delegate1.StreamIsClosed());
EXPECT_TRUE(delegate2.StreamIsClosed());
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Create two streams that are set to re-close themselves on close,
@@ -2107,27 +2052,23 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
CreateMockWrite(*req2, 1),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2136,14 +2077,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url1, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream2 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url2, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream2.get() != NULL);
+ ASSERT_TRUE(spdy_stream2.get() != nullptr);
EXPECT_EQ(0u, spdy_stream2->stream_id());
test::ClosingDelegate delegate1(spdy_stream1);
@@ -2166,7 +2107,7 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
EXPECT_EQ(0u, spdy_stream1->stream_id());
EXPECT_EQ(0u, spdy_stream2->stream_id());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream1->stream_id());
EXPECT_EQ(3u, spdy_stream2->stream_id());
@@ -2174,14 +2115,16 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
// Ensure we don't crash while closing the session.
session->CloseSessionOnError(ERR_ABORTED, std::string());
- EXPECT_EQ(NULL, spdy_stream1.get());
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream1);
+ EXPECT_FALSE(spdy_stream2);
EXPECT_TRUE(delegate1.StreamIsClosed());
EXPECT_TRUE(delegate2.StreamIsClosed());
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Create two streams that are set to close each other on close,
@@ -2189,27 +2132,23 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
CreateMockWrite(*req2, 1),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2218,14 +2157,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url1, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream2 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url2, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream2.get() != NULL);
+ ASSERT_TRUE(spdy_stream2);
EXPECT_EQ(0u, spdy_stream2->stream_id());
// Make |spdy_stream1| close |spdy_stream2|.
@@ -2250,7 +2189,7 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
EXPECT_EQ(0u, spdy_stream1->stream_id());
EXPECT_EQ(0u, spdy_stream2->stream_id());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream1->stream_id());
EXPECT_EQ(3u, spdy_stream2->stream_id());
@@ -2258,14 +2197,16 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
// Ensure we don't crash while closing the session.
session->CloseSessionOnError(ERR_ABORTED, std::string());
- EXPECT_EQ(NULL, spdy_stream1.get());
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream1);
+ EXPECT_FALSE(spdy_stream2);
EXPECT_TRUE(delegate1.StreamIsClosed());
EXPECT_TRUE(delegate2.StreamIsClosed());
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Delegate that closes a given session when the stream is closed.
@@ -2287,14 +2228,12 @@ class SessionClosingDelegate : public test::StreamDelegateDoNothing {
};
// Close an activated stream that closes its session. Nothing should
-// blow up. This is a regression test for http://crbug.com/263691 .
+// blow up. This is a regression test for https://crbug.com/263691.
TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
scoped_ptr<SpdyFrame> goaway(
@@ -2302,19 +2241,18 @@ TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
// 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, 2),
+ CreateMockWrite(*req, 0),
+ CreateMockWrite(*goaway, 1),
+ CreateMockWrite(*rst, 3),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 3) // EOF
+ MockRead(ASYNC, 0, 2) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2323,7 +2261,7 @@ TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
base::WeakPtr<SpdyStream> spdy_stream =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream.get() != NULL);
+ ASSERT_TRUE(spdy_stream.get() != nullptr);
EXPECT_EQ(0u, spdy_stream->stream_id());
SessionClosingDelegate delegate(spdy_stream, session);
@@ -2336,7 +2274,7 @@ TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
EXPECT_EQ(0u, spdy_stream->stream_id());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream->stream_id());
@@ -2344,31 +2282,20 @@ TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
// session).
spdy_stream->Cancel();
- EXPECT_EQ(NULL, spdy_stream.get());
+ EXPECT_FALSE(spdy_stream);
EXPECT_TRUE(delegate.StreamIsClosed());
- data.RunFor(2); // Write the RST_STREAM & GOAWAY.
- base::MessageLoop::current()->RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ // Write the RST_STREAM & GOAWAY.
+ base::RunLoop().RunUntilIdle();
+ EXPECT_TRUE(data.AllWriteDataConsumed());
+ EXPECT_TRUE(data.AllReadDataConsumed());
}
TEST_P(SpdySessionTest, VerifyDomainAuthentication) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- // No actual data will be sent.
- MockWrite writes[] = {
- MockWrite(ASYNC, 0, 1) // EOF
- };
-
- MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
- };
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(nullptr, 0, nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
// Load a cert that is valid for:
// www.example.org
@@ -2377,13 +2304,13 @@ TEST_P(SpdySessionTest, VerifyDomainAuthentication) {
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
ssl.cert = test_cert;
- session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
+ session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateSecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2397,20 +2324,8 @@ TEST_P(SpdySessionTest, VerifyDomainAuthentication) {
TEST_P(SpdySessionTest, ConnectionPooledWithTlsChannelId) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- // No actual data will be sent.
- MockWrite writes[] = {
- MockWrite(ASYNC, 0, 1) // EOF
- };
-
- MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
- };
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(nullptr, 0, nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
// Load a cert that is valid for:
// www.example.org
@@ -2419,14 +2334,14 @@ TEST_P(SpdySessionTest, ConnectionPooledWithTlsChannelId) {
base::FilePath certs_dir = GetTestCertsDirectory();
scoped_refptr<X509Certificate> test_cert(
ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
- ASSERT_NE(static_cast<X509Certificate*>(NULL), test_cert.get());
+ ASSERT_NE(static_cast<X509Certificate*>(nullptr), test_cert.get());
SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
ssl.channel_id_sent = true;
ssl.cert = test_cert;
- session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl);
+ session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateSecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2440,8 +2355,6 @@ TEST_P(SpdySessionTest, ConnectionPooledWithTlsChannelId) {
TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
// TODO(rtenneti): Define a helper class/methods and move the common code in
// this file.
- MockConnect connect_data(SYNCHRONOUS, OK);
-
SettingsMap new_settings;
const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS;
const uint32 max_concurrent_streams = 1;
@@ -2450,11 +2363,11 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, LOWEST, true));
scoped_ptr<SpdyFrame> req3(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 5, LOWEST, true));
MockWrite writes[] = {
CreateMockWrite(*settings_ack, 1),
CreateMockWrite(*req1, 2),
@@ -2467,44 +2380,46 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
scoped_ptr<SpdyFrame> settings_frame(
spdy_util_.ConstructSpdySettings(new_settings));
- scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp1(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
- scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+ scoped_ptr<SpdyFrame> resp2(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 3));
scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true));
- scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5));
+ scoped_ptr<SpdyFrame> resp3(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 5));
scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, true));
MockRead reads[] = {
- CreateMockRead(*settings_frame),
- CreateMockRead(*resp1, 3),
- CreateMockRead(*body1, 4),
- CreateMockRead(*resp2, 6),
- CreateMockRead(*body2, 7),
- CreateMockRead(*resp3, 9),
- CreateMockRead(*body3, 10),
- MockRead(ASYNC, 0, 11) // EOF
+ 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
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
// Read the settings frame.
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
GURL url1(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url1, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -2536,17 +2451,16 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
// Run until 1st stream is activated and then closed.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(4);
- EXPECT_EQ(NULL, spdy_stream1.get());
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(spdy_stream1);
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(0u, session->num_active_streams());
- EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(1u, session->pending_create_stream_queue_size(LOWEST));
// Pump loop for SpdySession::ProcessPendingStreamRequests() to
// create the 2nd stream.
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, session->num_active_streams());
EXPECT_EQ(1u, session->num_created_streams());
@@ -2562,17 +2476,16 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
// Run until 2nd stream is activated and then closed.
EXPECT_EQ(0u, delegate2.stream_id());
- data.RunFor(3);
- EXPECT_EQ(NULL, stream2.get());
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(stream2);
EXPECT_EQ(3u, delegate2.stream_id());
EXPECT_EQ(0u, session->num_active_streams());
- EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
// Pump loop for SpdySession::ProcessPendingStreamRequests() to
// create the 3rd stream.
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(0u, session->num_active_streams());
EXPECT_EQ(1u, session->num_created_streams());
@@ -2588,15 +2501,16 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
// Run until 2nd stream is activated and then closed.
EXPECT_EQ(0u, delegate3.stream_id());
- data.RunFor(3);
- EXPECT_EQ(NULL, stream3.get());
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(stream3);
EXPECT_EQ(5u, delegate3.stream_id());
EXPECT_EQ(0u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
}
TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
@@ -2606,10 +2520,7 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -2622,14 +2533,14 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
base::WeakPtr<SpdyStream> spdy_stream =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream != NULL);
+ ASSERT_TRUE(spdy_stream != nullptr);
}
GURL url1(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url1, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
TestCompletionCallback callback2;
@@ -2653,9 +2564,9 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
EXPECT_EQ(2u, session->pending_create_stream_queue_size(LOWEST));
// Cancel the first stream; this will allow the second stream to be created.
- EXPECT_TRUE(spdy_stream1.get() != NULL);
+ EXPECT_TRUE(spdy_stream1);
spdy_stream1->Cancel();
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(spdy_stream1);
EXPECT_EQ(OK, callback2.WaitForResult());
EXPECT_EQ(0u, session->num_active_streams());
@@ -2665,7 +2576,7 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
// Cancel the second stream; this will allow the third stream to be created.
base::WeakPtr<SpdyStream> spdy_stream2 = request2.ReleaseStream();
spdy_stream2->Cancel();
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream2);
EXPECT_EQ(OK, callback3.WaitForResult());
EXPECT_EQ(0u, session->num_active_streams());
@@ -2675,7 +2586,7 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
// Cancel the third stream.
base::WeakPtr<SpdyStream> spdy_stream3 = request3.ReleaseStream();
spdy_stream3->Cancel();
- EXPECT_EQ(NULL, spdy_stream3.get());
+ EXPECT_FALSE(spdy_stream3);
EXPECT_EQ(0u, session->num_active_streams());
EXPECT_EQ(kInitialMaxConcurrentStreams - 1, session->num_created_streams());
EXPECT_EQ(0u, session->pending_create_stream_queue_size(LOWEST));
@@ -2686,11 +2597,12 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
// on the socket for reading. It then verifies that it has read all
// the available data without yielding.
TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
- MockConnect connect_data(SYNCHRONOUS, OK);
+ session_deps_.host_resolver->set_synchronous_mode(true);
+
BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
};
@@ -2710,27 +2622,26 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
scoped_ptr<SpdyFrame> finish_data_frame(
framer.CreateDataFrame(1, payload_data, kPayloadSize - 1, DATA_FLAG_FIN));
- scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp1(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
// Write 1 byte less than kMaxReadBytes to check that DoRead reads up to 32k
// bytes.
MockRead reads[] = {
- CreateMockRead(*resp1, 1),
- CreateMockRead(*partial_data_frame, 2),
- CreateMockRead(*partial_data_frame, 3, SYNCHRONOUS),
- CreateMockRead(*partial_data_frame, 4, SYNCHRONOUS),
- CreateMockRead(*finish_data_frame, 5, SYNCHRONOUS),
- MockRead(ASYNC, 0, 6) // EOF
+ CreateMockRead(*resp1, 1),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*partial_data_frame, 3),
+ CreateMockRead(*partial_data_frame, 4, SYNCHRONOUS),
+ CreateMockRead(*partial_data_frame, 5, SYNCHRONOUS),
+ CreateMockRead(*finish_data_frame, 6, SYNCHRONOUS),
+ MockRead(ASYNC, 0, 7) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.host_resolver->set_synchronous_mode(true);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2739,7 +2650,7 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url1, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -2755,14 +2666,15 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
// Run until 1st read.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(0u, observer.executed_count());
// Read all the data and verify SpdySession::DoReadLoop has not
// posted a task.
- data.RunFor(4);
- EXPECT_EQ(NULL, spdy_stream1.get());
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(spdy_stream1);
// Verify task observer's executed_count is zero, which indicates DoRead read
// all the available data.
@@ -2777,11 +2689,12 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
// there is data available for it to read (i.e, socket()->Read didn't
// return ERR_IO_PENDING during socket reads).
TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
- MockConnect connect_data(SYNCHRONOUS, OK);
+ session_deps_.host_resolver->set_synchronous_mode(true);
+
BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
};
@@ -2801,27 +2714,26 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
scoped_ptr<SpdyFrame> finish_data_frame(
framer.CreateDataFrame(1, "h", 1, DATA_FLAG_FIN));
- scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp1(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
// Write 1 byte more than kMaxReadBytes to check that DoRead yields.
MockRead reads[] = {
- CreateMockRead(*resp1, 1),
- CreateMockRead(*partial_data_frame, 2),
- CreateMockRead(*partial_data_frame, 3, SYNCHRONOUS),
- CreateMockRead(*partial_data_frame, 4, SYNCHRONOUS),
- CreateMockRead(*partial_data_frame, 5, SYNCHRONOUS),
- CreateMockRead(*finish_data_frame, 6, SYNCHRONOUS),
- MockRead(ASYNC, 0, 7) // EOF
+ CreateMockRead(*resp1, 1),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*partial_data_frame, 3),
+ CreateMockRead(*partial_data_frame, 4, SYNCHRONOUS),
+ CreateMockRead(*partial_data_frame, 5, SYNCHRONOUS),
+ CreateMockRead(*partial_data_frame, 6, SYNCHRONOUS),
+ CreateMockRead(*finish_data_frame, 7, SYNCHRONOUS),
+ MockRead(ASYNC, 0, 8) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.host_resolver->set_synchronous_mode(true);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2830,7 +2742,7 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url1, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -2846,14 +2758,15 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
// Run until 1st read.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(0u, observer.executed_count());
// Read all the data and verify SpdySession::DoReadLoop has posted a
// task.
- data.RunFor(6);
- EXPECT_EQ(NULL, spdy_stream1.get());
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(spdy_stream1);
// Verify task observer's executed_count is 1, which indicates DoRead has
// posted only one task and thus yielded though there is data available for it
@@ -2875,11 +2788,12 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
// yield. When we come back, DoRead() will read the results from the
// async read, and rest of the data synchronously.
TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
- MockConnect connect_data(SYNCHRONOUS, OK);
+ session_deps_.host_resolver->set_synchronous_mode(true);
+
BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
};
@@ -2908,31 +2822,30 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
scoped_ptr<SpdyFrame> finish_data_frame(framer.CreateDataFrame(
1, "h", 1, DATA_FLAG_FIN));
- scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp1(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
MockRead reads[] = {
- CreateMockRead(*resp1, 1),
- CreateMockRead(*eightk_data_frame, 2),
- CreateMockRead(*eightk_data_frame, 3, SYNCHRONOUS),
- CreateMockRead(*eightk_data_frame, 4, SYNCHRONOUS),
- CreateMockRead(*twok_data_frame, 5, SYNCHRONOUS),
- CreateMockRead(*eightk_data_frame, 6, ASYNC),
- CreateMockRead(*eightk_data_frame, 7, SYNCHRONOUS),
- CreateMockRead(*eightk_data_frame, 8, SYNCHRONOUS),
- CreateMockRead(*eightk_data_frame, 9, SYNCHRONOUS),
- CreateMockRead(*twok_data_frame, 10, SYNCHRONOUS),
- CreateMockRead(*finish_data_frame, 11, SYNCHRONOUS),
- MockRead(ASYNC, 0, 12) // EOF
+ CreateMockRead(*resp1, 1),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*eightk_data_frame, 3),
+ CreateMockRead(*eightk_data_frame, 4, SYNCHRONOUS),
+ CreateMockRead(*eightk_data_frame, 5, SYNCHRONOUS),
+ CreateMockRead(*twok_data_frame, 6, SYNCHRONOUS),
+ CreateMockRead(*eightk_data_frame, 7, ASYNC),
+ CreateMockRead(*eightk_data_frame, 8, SYNCHRONOUS),
+ CreateMockRead(*eightk_data_frame, 9, SYNCHRONOUS),
+ CreateMockRead(*eightk_data_frame, 10, SYNCHRONOUS),
+ CreateMockRead(*twok_data_frame, 11, SYNCHRONOUS),
+ CreateMockRead(*finish_data_frame, 12, SYNCHRONOUS),
+ MockRead(ASYNC, 0, 13) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.host_resolver->set_synchronous_mode(true);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -2941,7 +2854,7 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url1, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -2957,14 +2870,15 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
// Run until 1st read.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(0u, observer.executed_count());
// Read all the data and verify SpdySession::DoReadLoop has posted a
// task.
- data.RunFor(12);
- EXPECT_EQ(NULL, spdy_stream1.get());
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(spdy_stream1);
// Verify task observer's executed_count is 1, which indicates DoRead has
// posted only one task and thus yielded though there is data available for
@@ -2977,33 +2891,33 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
// Send a GoAway frame when SpdySession is in DoReadLoop. Make sure
// nothing blows up.
TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
- MockConnect connect_data(SYNCHRONOUS, OK);
+ session_deps_.host_resolver->set_synchronous_mode(true);
+
BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req1, 0),
};
- scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp1(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway());
MockRead reads[] = {
- CreateMockRead(*resp1, 1),
- CreateMockRead(*body1, 2),
- CreateMockRead(*goaway, 3),
+ CreateMockRead(*resp1, 1),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*body1, 3),
+ CreateMockRead(*goaway, 4),
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.host_resolver->set_synchronous_mode(true);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -3014,7 +2928,7 @@ TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
session, url1, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
scoped_ptr<SpdyHeaderBlock> headers1(
@@ -3024,15 +2938,16 @@ TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
// Run until 1st read.
EXPECT_EQ(0u, spdy_stream1->stream_id());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream1->stream_id());
// Run until GoAway.
- data.RunFor(3);
- EXPECT_EQ(NULL, spdy_stream1.get());
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(spdy_stream1);
EXPECT_TRUE(data.AllWriteDataConsumed());
EXPECT_TRUE(data.AllReadDataConsumed());
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
}
// Within this framework, a SpdySession should be initialized with
@@ -3042,12 +2957,10 @@ TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
TEST_P(SpdySessionTest, ProtocolNegotiation) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(SYNCHRONOUS, 0, 0) // EOF
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -3073,12 +2986,10 @@ TEST_P(SpdySessionTest, CloseOneIdleConnection) {
ClientSocketPoolManager::set_max_sockets_per_pool(
HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
session_deps_.socket_factory->AddSocketDataProvider(&data);
@@ -3113,7 +3024,7 @@ TEST_P(SpdySessionTest, CloseOneIdleConnection) {
// new connection.
EXPECT_EQ(OK, callback2.WaitForResult());
EXPECT_FALSE(pool->IsStalled());
- EXPECT_TRUE(session1 == NULL);
+ EXPECT_FALSE(session1);
}
// Tests the case of a non-SPDY request closing an idle SPDY session when no
@@ -3125,12 +3036,10 @@ TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
ClientSocketPoolManager::set_max_sockets_per_pool(
HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
session_deps_.socket_factory->AddSocketDataProvider(&data);
@@ -3163,11 +3072,8 @@ TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
AddressList addresses;
// Pre-populate the DNS cache, since a synchronous resolution is required in
// order to create the alias.
- session_deps_.host_resolver->Resolve(info,
- DEFAULT_PRIORITY,
- &addresses,
- CompletionCallback(),
- NULL,
+ session_deps_.host_resolver->Resolve(info, DEFAULT_PRIORITY, &addresses,
+ CompletionCallback(), nullptr,
BoundNetLog());
// Get a session for |key2|, which should return the session created earlier.
base::WeakPtr<SpdySession> session2 =
@@ -3193,8 +3099,8 @@ TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
// new connection.
EXPECT_EQ(OK, callback3.WaitForResult());
EXPECT_FALSE(pool->IsStalled());
- EXPECT_TRUE(session1 == NULL);
- EXPECT_TRUE(session2 == NULL);
+ EXPECT_FALSE(session1);
+ EXPECT_FALSE(session2);
}
// Tests that when a SPDY session becomes idle, it closes itself if there is
@@ -3205,12 +3111,11 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
ClientSocketPoolManager::set_max_sockets_per_pool(
HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> cancel1(
spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
MockWrite writes[] = {
@@ -3219,15 +3124,13 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
};
StaticSocketDataProvider data(reads, arraysize(reads),
writes, arraysize(writes));
- data.set_connect_data(connect_data);
session_deps_.socket_factory->AddSocketDataProvider(&data);
MockRead http_reads[] = {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
- NULL, 0);
- http_data.set_connect_data(connect_data);
+ StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), nullptr,
+ 0);
session_deps_.socket_factory->AddSocketDataProvider(&http_data);
@@ -3263,7 +3166,7 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
headers1.Pass(), NO_MORE_DATA_TO_SEND));
EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
- base::MessageLoop::current()->RunUntilIdle();
+ base::RunLoop().RunUntilIdle();
// Trying to create a new connection should cause the pool to be stalled, and
// post a task asynchronously to try and close the session.
@@ -3298,7 +3201,7 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
// Verify that SpdySessionKey and therefore SpdySession is different when
// privacy mode is enabled or disabled.
TEST_P(SpdySessionTest, SpdySessionKeyPrivacyMode) {
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
HostPortPair host_port_pair("www.example.org", 443);
SpdySessionKey key_privacy_enabled(host_port_pair, ProxyServer::Direct(),
@@ -3359,10 +3262,8 @@ class StreamCreatingDelegate : public test::StreamDelegateDoNothing {
TEST_P(SpdySessionTest, CreateStreamOnStreamReset) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
-
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
CreateMockWrite(*req, 0),
};
@@ -3370,15 +3271,15 @@ TEST_P(SpdySessionTest, CreateStreamOnStreamReset) {
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_REFUSED_STREAM));
MockRead reads[] = {
- CreateMockRead(*rst, 1),
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*rst, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ MockRead(ASYNC, 0, 4) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -3387,7 +3288,7 @@ TEST_P(SpdySessionTest, CreateStreamOnStreamReset) {
base::WeakPtr<SpdyStream> spdy_stream =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream.get() != NULL);
+ ASSERT_TRUE(spdy_stream.get() != nullptr);
EXPECT_EQ(0u, spdy_stream->stream_id());
StreamCreatingDelegate delegate(spdy_stream, session);
@@ -3400,18 +3301,23 @@ TEST_P(SpdySessionTest, CreateStreamOnStreamReset) {
EXPECT_EQ(0u, spdy_stream->stream_id());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream->stream_id());
// Cause the stream to be reset, which should cause another stream
// to be created.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
- EXPECT_EQ(NULL, spdy_stream.get());
+ EXPECT_FALSE(spdy_stream);
EXPECT_TRUE(delegate.StreamIsClosed());
EXPECT_EQ(0u, session->num_active_streams());
EXPECT_EQ(1u, session->num_created_streams());
+
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// The tests below are only for SPDY/3 and above.
@@ -3426,60 +3332,63 @@ TEST_P(SpdySessionTest, UpdateStreamsSendWindowSize) {
// Set up the socket so we read a SETTINGS frame that sets
// INITIAL_WINDOW_SIZE.
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> settings_frame(
spdy_util_.ConstructSpdySettings(new_settings));
MockRead reads[] = {
- CreateMockRead(*settings_frame, 0),
- MockRead(ASYNC, 0, 1) // EOF
+ CreateMockRead(*settings_frame, 0),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ MockRead(ASYNC, 0, 2) // EOF
};
scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
MockWrite writes[] = {
- CreateMockWrite(*settings_ack, 2),
+ CreateMockWrite(*settings_ack, 3),
};
session_deps_.host_resolver->set_synchronous_mode(true);
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
TestCompletionCallback callback1;
EXPECT_NE(spdy_stream1->send_window_size(), window_size);
- data.RunFor(1); // Process the SETTINGS frame, but not the EOF
- base::MessageLoop::current()->RunUntilIdle();
+ // Process the SETTINGS frame.
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(session->stream_initial_send_window_size(), window_size);
EXPECT_EQ(spdy_stream1->send_window_size(), window_size);
// Release the first one, this will allow the second to be created.
spdy_stream1->Cancel();
- EXPECT_EQ(NULL, spdy_stream1.get());
+ EXPECT_FALSE(spdy_stream1);
base::WeakPtr<SpdyStream> spdy_stream2 =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, test_url_, MEDIUM, BoundNetLog());
- ASSERT_TRUE(spdy_stream2.get() != NULL);
+ ASSERT_TRUE(spdy_stream2.get() != nullptr);
EXPECT_EQ(spdy_stream2->send_window_size(), window_size);
spdy_stream2->Cancel();
- EXPECT_EQ(NULL, spdy_stream2.get());
+ EXPECT_FALSE(spdy_stream2);
+
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// The tests below are only for SPDY/3.1 and above.
// SpdySession::{Increase,Decrease}RecvWindowSize should properly
-// adjust the session receive window size for SPDY 3.1 and higher. In
-// addition, SpdySession::IncreaseRecvWindowSize should trigger
+// adjust the session receive window size. In addition,
+// SpdySession::IncreaseRecvWindowSize should trigger
// sending a WINDOW_UPDATE frame for a large enough delta.
TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
if (GetParam() < kProtoSPDY31)
@@ -3491,21 +3400,18 @@ TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
SpdySession::GetDefaultInitialWindowSize(GetParam());
const int32 delta_window_size = 100;
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(ASYNC, 0, 1) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF
};
scoped_ptr<SpdyFrame> window_update(spdy_util_.ConstructSpdyWindowUpdate(
kSessionFlowControlStreamId, initial_window_size + delta_window_size));
MockWrite writes[] = {
CreateMockWrite(*window_update, 0),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -3525,7 +3431,7 @@ TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
// DecreaseRecvWindowSize() expects |in_io_loop_| to be true.
session->in_io_loop_ = true;
@@ -3534,6 +3440,11 @@ TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
session->in_io_loop_ = false;
EXPECT_EQ(0, session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
+
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// SpdySession::{Increase,Decrease}SendWindowSize should properly
@@ -3545,12 +3456,10 @@ TEST_P(SpdySessionTest, AdjustSendWindowSize) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
MockRead(SYNCHRONOUS, 0, 0) // EOF
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
@@ -3582,17 +3491,16 @@ TEST_P(SpdySessionTest, SessionFlowControlInactiveStream) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyBodyFrame(1, false));
MockRead reads[] = {
- CreateMockRead(*resp, 0),
- MockRead(ASYNC, 0, 1) // EOF
+ CreateMockRead(*resp, 0),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ MockRead(ASYNC, 0, 2) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -3602,13 +3510,16 @@ TEST_P(SpdySessionTest, SessionFlowControlInactiveStream) {
session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()),
session->session_recv_window_size_);
EXPECT_EQ(kUploadDataSize, session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// The frame header is not included in flow control, but frame payload
@@ -3621,17 +3532,17 @@ TEST_P(SpdySessionTest, SessionFlowControlPadding) {
session_deps_.host_resolver->set_synchronous_mode(true);
const int padding_length = 42;
- MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyBodyFrame(
1, kUploadData, kUploadDataSize, false, padding_length));
MockRead reads[] = {
- CreateMockRead(*resp, 0), MockRead(ASYNC, 0, 1) // EOF
+ CreateMockRead(*resp, 0),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ MockRead(ASYNC, 0, 2) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), nullptr, 0);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -3641,14 +3552,16 @@ TEST_P(SpdySessionTest, SessionFlowControlPadding) {
session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()),
session->session_recv_window_size_);
EXPECT_EQ(kUploadDataSize + padding_length,
session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Peer sends more data than stream level receiving flow control window.
@@ -3657,26 +3570,29 @@ TEST_P(SpdySessionTest, StreamFlowControlTooMuchData) {
const int32 data_frame_size = 2 * stream_max_recv_window_size;
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
+ scoped_ptr<SpdyFrame> rst(
+ spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
+ CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
};
- scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
const std::string payload(data_frame_size, 'a');
scoped_ptr<SpdyFrame> data_frame(spdy_util_.ConstructSpdyBodyFrame(
1, payload.data(), data_frame_size, false));
MockRead reads[] = {
CreateMockRead(*resp, 1),
- CreateMockRead(*data_frame, 2),
- MockRead(ASYNC, 0, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*data_frame, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 5),
+ MockRead(ASYNC, 0, 6),
};
- DeterministicSocketData data(reads, arraysize(reads), writes,
- arraysize(writes));
- data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
+ CreateNetworkSession();
SpdySessionPoolPeer pool_peer(spdy_session_pool_);
pool_peer.SetStreamInitialRecvWindowSize(stream_max_recv_window_size);
@@ -3698,12 +3614,18 @@ TEST_P(SpdySessionTest, StreamFlowControlTooMuchData) {
headers.Pass(), NO_MORE_DATA_TO_SEND));
// Request and response.
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, spdy_stream->stream_id());
// Too large data frame causes flow control error, should close stream.
- data.RunFor(1);
- EXPECT_EQ(nullptr, spdy_stream.get());
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(spdy_stream);
+
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Regression test for a bug that was caused by including unsent WINDOW_UPDATE
@@ -3728,6 +3650,14 @@ TEST_P(SpdySessionTest, SessionFlowControlTooMuchDataTwoDataFrames) {
session_deps_.host_resolver->set_synchronous_mode(true);
+ scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
+ 0, GOAWAY_FLOW_CONTROL_ERROR,
+ "delta_window_size is 400 in DecreaseRecvWindowSize, which is larger "
+ "than the receive window size of 500"));
+ MockWrite writes[] = {
+ CreateMockWrite(*goaway, 4),
+ };
+
const std::string first_data_frame(first_data_frame_size, 'a');
scoped_ptr<SpdyFrame> first(spdy_util_.ConstructSpdyBodyFrame(
1, first_data_frame.data(), first_data_frame_size, false));
@@ -3736,14 +3666,14 @@ TEST_P(SpdySessionTest, SessionFlowControlTooMuchDataTwoDataFrames) {
1, second_data_frame.data(), second_data_frame_size, false));
MockRead reads[] = {
CreateMockRead(*first, 0),
- CreateMockRead(*second, 1),
- MockRead(ASYNC, 0, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*second, 2),
+ MockRead(ASYNC, 0, 3),
};
- DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
- data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -3754,13 +3684,14 @@ TEST_P(SpdySessionTest, SessionFlowControlTooMuchDataTwoDataFrames) {
// First data frame is immediately consumed and does not trigger
// WINDOW_UPDATE.
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(first_data_frame_size, session->session_unacked_recv_window_bytes_);
EXPECT_EQ(session_max_recv_window_size, session->session_recv_window_size_);
EXPECT_EQ(SpdySession::STATE_AVAILABLE, session->availability_state_);
// Second data frame overflows receiving window, causes session to close.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(SpdySession::STATE_DRAINING, session->availability_state_);
}
@@ -3784,14 +3715,15 @@ TEST_P(SpdySessionTest, StreamFlowControlTooMuchDataTwoDataFrames) {
first_data_frame_size + second_data_frame_size);
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR));
MockWrite writes[] = {
- CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
+ CreateMockWrite(*req, 0), CreateMockWrite(*rst, 6),
};
- scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
const std::string first_data_frame(first_data_frame_size, 'a');
scoped_ptr<SpdyFrame> first(spdy_util_.ConstructSpdyBodyFrame(
1, first_data_frame.data(), first_data_frame_size, false));
@@ -3800,17 +3732,18 @@ TEST_P(SpdySessionTest, StreamFlowControlTooMuchDataTwoDataFrames) {
1, second_data_frame.data(), second_data_frame_size, false));
MockRead reads[] = {
CreateMockRead(*resp, 1),
- CreateMockRead(*first, 2),
- CreateMockRead(*second, 3),
- MockRead(ASYNC, 0, 5),
+ MockRead(ASYNC, ERR_IO_PENDING, 2),
+ CreateMockRead(*first, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ CreateMockRead(*second, 5),
+ MockRead(ASYNC, ERR_IO_PENDING, 7),
+ MockRead(ASYNC, 0, 8),
};
- DeterministicSocketData data(reads, arraysize(reads), writes,
- arraysize(writes));
- data.set_connect_data(MockConnect(SYNCHRONOUS, OK));
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
SpdySessionPoolPeer pool_peer(spdy_session_pool_);
pool_peer.SetStreamInitialRecvWindowSize(stream_max_recv_window_size);
@@ -3829,12 +3762,13 @@ TEST_P(SpdySessionTest, StreamFlowControlTooMuchDataTwoDataFrames) {
headers.Pass(), NO_MORE_DATA_TO_SEND));
// Request and response.
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_TRUE(spdy_stream->IsLocallyClosed());
EXPECT_EQ(stream_max_recv_window_size, spdy_stream->recv_window_size());
// First data frame.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_TRUE(spdy_stream->IsLocallyClosed());
EXPECT_EQ(stream_max_recv_window_size - first_data_frame_size,
spdy_stream->recv_window_size());
@@ -3845,11 +3779,15 @@ TEST_P(SpdySessionTest, StreamFlowControlTooMuchDataTwoDataFrames) {
EXPECT_EQ(stream_max_recv_window_size, spdy_stream->recv_window_size());
// Second data frame overflows receiving window, causes the stream to close.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_FALSE(spdy_stream.get());
// RST_STREAM
- data.RunFor(1);
+ EXPECT_TRUE(session);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// A delegate that drops any received data.
@@ -3877,11 +3815,8 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
const int32 msg_data_size = 100;
const std::string msg_data(msg_data_size, 'a');
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
+ scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, msg_data_size, MEDIUM, nullptr, 0));
scoped_ptr<SpdyFrame> msg(
spdy_util_.ConstructSpdyBodyFrame(
1, msg_data.data(), msg_data_size, false));
@@ -3890,7 +3825,8 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
CreateMockWrite(*msg, 2),
};
- scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> echo(
spdy_util_.ConstructSpdyBodyFrame(
1, msg_data.data(), msg_data_size, false));
@@ -3898,19 +3834,18 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
spdy_util_.ConstructSpdyWindowUpdate(
kSessionFlowControlStreamId, msg_data_size));
MockRead reads[] = {
- CreateMockRead(*resp, 1),
- CreateMockRead(*echo, 3),
- MockRead(ASYNC, 0, 4) // EOF
+ CreateMockRead(*resp, 1),
+ CreateMockRead(*echo, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ MockRead(ASYNC, 0, 5) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
session_deps_.host_resolver->set_synchronous_mode(true);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -3919,7 +3854,7 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
base::WeakPtr<SpdyStream> stream =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url, MEDIUM, BoundNetLog());
- ASSERT_TRUE(stream.get() != NULL);
+ ASSERT_TRUE(stream.get() != nullptr);
EXPECT_EQ(0u, stream->stream_id());
DropReceivedDataDelegate delegate(stream, msg_data);
@@ -3936,21 +3871,22 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- data.RunFor(4);
-
- EXPECT_TRUE(data.AllWriteDataConsumed());
- EXPECT_TRUE(data.AllReadDataConsumed());
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
stream->Close();
- EXPECT_EQ(NULL, stream.get());
+ EXPECT_FALSE(stream);
EXPECT_EQ(OK, delegate.WaitForClose());
EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
+
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Send data back and forth but close the stream before its data frame
@@ -3965,29 +3901,26 @@ TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
const int32 msg_data_size = 100;
const std::string msg_data(msg_data_size, 'a');
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
+ scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, msg_data_size, MEDIUM, nullptr, 0));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
+ CreateMockWrite(*req, 0),
};
- scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
MockRead reads[] = {
- CreateMockRead(*resp, 1),
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*resp, 2),
+ MockRead(ASYNC, 0, 3) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
session_deps_.host_resolver->set_synchronous_mode(true);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -3996,7 +3929,7 @@ TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
base::WeakPtr<SpdyStream> stream =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url, MEDIUM, BoundNetLog());
- ASSERT_TRUE(stream.get() != NULL);
+ ASSERT_TRUE(stream.get() != nullptr);
EXPECT_EQ(0u, stream->stream_id());
test::StreamDelegateSendImmediate delegate(stream, msg_data);
@@ -4012,25 +3945,31 @@ TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
SpdySession::GetDefaultInitialWindowSize(GetParam());
EXPECT_EQ(initial_window_size, session->session_send_window_size_);
- data.RunFor(1);
+ // Write request.
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(initial_window_size, session->session_send_window_size_);
- data.RunFor(1);
-
- EXPECT_TRUE(data.AllWriteDataConsumed());
- EXPECT_TRUE(data.AllReadDataConsumed());
+ // Read response, but do not run the message loop, so that the body is not
+ // written to the socket.
+ data.CompleteRead();
EXPECT_EQ(initial_window_size - msg_data_size,
session->session_send_window_size_);
// Closing the stream should increase the session's send window.
stream->Close();
- EXPECT_EQ(NULL, stream.get());
+ EXPECT_FALSE(stream);
EXPECT_EQ(initial_window_size, session->session_send_window_size_);
EXPECT_EQ(OK, delegate.WaitForClose());
+
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
+
+ EXPECT_TRUE(data.AllWriteDataConsumed());
+ EXPECT_TRUE(data.AllReadDataConsumed());
}
// Send data back and forth; the send and receive windows should
@@ -4044,11 +3983,8 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
const int32 msg_data_size = 100;
const std::string msg_data(msg_data_size, 'a');
- MockConnect connect_data(SYNCHRONOUS, OK);
-
- scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
+ scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, msg_data_size, MEDIUM, nullptr, 0));
scoped_ptr<SpdyFrame> msg(
spdy_util_.ConstructSpdyBodyFrame(
1, msg_data.data(), msg_data_size, false));
@@ -4057,7 +3993,8 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
CreateMockWrite(*msg, 2),
};
- scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> echo(
spdy_util_.ConstructSpdyBodyFrame(
1, msg_data.data(), msg_data_size, false));
@@ -4065,20 +4002,21 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
spdy_util_.ConstructSpdyWindowUpdate(
kSessionFlowControlStreamId, msg_data_size));
MockRead reads[] = {
- CreateMockRead(*resp, 1),
- CreateMockRead(*echo, 3),
- CreateMockRead(*window_update, 4),
- MockRead(ASYNC, 0, 5) // EOF
+ CreateMockRead(*resp, 1),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ CreateMockRead(*echo, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 5),
+ CreateMockRead(*window_update, 6),
+ MockRead(ASYNC, ERR_IO_PENDING, 7),
+ MockRead(ASYNC, 0, 8) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- data.set_connect_data(connect_data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
session_deps_.host_resolver->set_synchronous_mode(true);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -4087,7 +4025,7 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
base::WeakPtr<SpdyStream> stream =
CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
session, url, MEDIUM, BoundNetLog());
- ASSERT_TRUE(stream.get() != NULL);
+ ASSERT_TRUE(stream.get() != nullptr);
EXPECT_EQ(0u, stream->stream_id());
test::StreamDelegateSendImmediate delegate(stream, msg_data);
@@ -4105,27 +4043,17 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
-
- EXPECT_EQ(initial_window_size, session->session_send_window_size_);
- EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
- EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
-
- data.RunFor(1);
-
- EXPECT_EQ(initial_window_size - msg_data_size,
- session->session_send_window_size_);
- EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
- EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
-
- data.RunFor(1);
+ // Send request and message.
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(initial_window_size - msg_data_size,
session->session_send_window_size_);
EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
+ // Read echo.
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(initial_window_size - msg_data_size,
session->session_send_window_size_);
@@ -4133,16 +4061,15 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- data.RunFor(1);
+ // Read window update.
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(initial_window_size, session->session_send_window_size_);
EXPECT_EQ(initial_window_size - msg_data_size,
session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
- EXPECT_TRUE(data.AllWriteDataConsumed());
- EXPECT_TRUE(data.AllReadDataConsumed());
-
EXPECT_EQ(msg_data, delegate.TakeReceivedData());
// Draining the delegate's read queue should increase the session's
@@ -4152,13 +4079,17 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
stream->Close();
- EXPECT_EQ(NULL, stream.get());
+ EXPECT_FALSE(stream);
EXPECT_EQ(OK, delegate.WaitForClose());
EXPECT_EQ(initial_window_size, session->session_send_window_size_);
EXPECT_EQ(initial_window_size, session->session_recv_window_size_);
EXPECT_EQ(msg_data_size, session->session_unacked_recv_window_bytes_);
+
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
// Given a stall function and an unstall function, runs a test to make
@@ -4172,9 +4103,8 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
session_deps_.host_resolver->set_synchronous_mode(true);
- scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
+ scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, kBodyDataSize, LOWEST, nullptr, 0));
scoped_ptr<SpdyFrame> body(
spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
MockWrite writes[] = {
@@ -4183,22 +4113,17 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
};
scoped_ptr<SpdyFrame> resp(
- spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> echo(
spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
MockRead reads[] = {
- CreateMockRead(*resp, 2),
- MockRead(ASYNC, 0, 0, 3), // EOF
+ CreateMockRead(*resp, 2), MockRead(ASYNC, 0, 3) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
-
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -4207,7 +4132,7 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
base::WeakPtr<SpdyStream> stream =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(stream.get() != NULL);
+ ASSERT_TRUE(stream.get() != nullptr);
test::StreamDelegateWithBody delegate(stream, kBodyDataStringPiece);
stream->SetDelegate(&delegate);
@@ -4224,7 +4149,7 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
stall_function.Run(session.get(), stream.get());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_TRUE(stream->send_stalled_by_flow_control());
@@ -4232,13 +4157,12 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
EXPECT_FALSE(stream->send_stalled_by_flow_control());
- data.RunFor(3);
-
EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate.WaitForClose());
EXPECT_TRUE(delegate.send_headers_completed());
EXPECT_EQ("200", delegate.GetResponseHeaderValue(":status"));
EXPECT_EQ(std::string(), delegate.TakeReceivedData());
+ EXPECT_FALSE(session);
EXPECT_TRUE(data.AllWriteDataConsumed());
}
@@ -4325,12 +4249,10 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
session_deps_.host_resolver->set_synchronous_mode(true);
- scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
- scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 3, kBodyDataSize, MEDIUM, NULL, 0));
+ scoped_ptr<SpdyFrame> req1(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, kBodyDataSize, LOWEST, nullptr, 0));
+ scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 3, kBodyDataSize, MEDIUM, nullptr, 0));
scoped_ptr<SpdyFrame> body1(
spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
scoped_ptr<SpdyFrame> body2(
@@ -4342,22 +4264,20 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
CreateMockWrite(*body1, 3),
};
- scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
- scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+ scoped_ptr<SpdyFrame> resp1(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
+ scoped_ptr<SpdyFrame> resp2(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 3));
MockRead reads[] = {
- CreateMockRead(*resp1, 4),
- CreateMockRead(*resp2, 5),
- MockRead(ASYNC, 0, 0, 6), // EOF
+ CreateMockRead(*resp1, 4),
+ CreateMockRead(*resp2, 5),
+ MockRead(ASYNC, 0, 6) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
-
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -4366,7 +4286,7 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
base::WeakPtr<SpdyStream> stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(stream1.get() != NULL);
+ ASSERT_TRUE(stream1.get() != nullptr);
test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
stream1->SetDelegate(&delegate1);
@@ -4376,7 +4296,7 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
base::WeakPtr<SpdyStream> stream2 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, MEDIUM, BoundNetLog());
- ASSERT_TRUE(stream2.get() != NULL);
+ ASSERT_TRUE(stream2.get() != nullptr);
test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
stream2->SetDelegate(&delegate2);
@@ -4395,7 +4315,7 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
EXPECT_TRUE(stream1->HasUrlFromHeaders());
EXPECT_EQ(kStreamUrl, stream1->GetUrlFromHeaders().spec());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, stream1->stream_id());
EXPECT_TRUE(stream1->send_stalled_by_flow_control());
@@ -4406,7 +4326,7 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
EXPECT_TRUE(stream2->HasUrlFromHeaders());
EXPECT_EQ(kStreamUrl, stream2->GetUrlFromHeaders().spec());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(3u, stream2->stream_id());
EXPECT_TRUE(stream2->send_stalled_by_flow_control());
@@ -4416,7 +4336,7 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
EXPECT_TRUE(stream1->send_stalled_by_flow_control());
EXPECT_FALSE(stream2->send_stalled_by_flow_control());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_TRUE(stream1->send_stalled_by_flow_control());
EXPECT_FALSE(stream2->send_stalled_by_flow_control());
@@ -4427,7 +4347,7 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
EXPECT_FALSE(stream1->send_stalled_by_flow_control());
EXPECT_FALSE(stream2->send_stalled_by_flow_control());
- data.RunFor(4);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
@@ -4440,7 +4360,9 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
EXPECT_EQ("200", delegate2.GetResponseHeaderValue(":status"));
EXPECT_EQ(std::string(), delegate2.TakeReceivedData());
+ EXPECT_FALSE(session);
EXPECT_TRUE(data.AllWriteDataConsumed());
+ EXPECT_TRUE(data.AllReadDataConsumed());
}
// Delegate that closes a given stream after sending its body.
@@ -4460,7 +4382,7 @@ class StreamClosingDelegate : public test::StreamDelegateWithBody {
test::StreamDelegateWithBody::OnDataSent();
if (stream_to_close_.get()) {
stream_to_close_->Close();
- EXPECT_EQ(NULL, stream_to_close_.get());
+ EXPECT_FALSE(stream_to_close_);
}
}
@@ -4479,15 +4401,12 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
session_deps_.host_resolver->set_synchronous_mode(true);
- scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
- scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 3, kBodyDataSize, LOWEST, NULL, 0));
- scoped_ptr<SpdyFrame> req3(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 5, kBodyDataSize, LOWEST, NULL, 0));
+ scoped_ptr<SpdyFrame> req1(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, kBodyDataSize, LOWEST, nullptr, 0));
+ scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 3, kBodyDataSize, LOWEST, nullptr, 0));
+ scoped_ptr<SpdyFrame> req3(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 5, kBodyDataSize, LOWEST, nullptr, 0));
scoped_ptr<SpdyFrame> body2(
spdy_util_.ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
MockWrite writes[] = {
@@ -4497,20 +4416,18 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
CreateMockWrite(*body2, 3),
};
- scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
+ scoped_ptr<SpdyFrame> resp2(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 3));
MockRead reads[] = {
- CreateMockRead(*resp2, 4),
- MockRead(ASYNC, 0, 0, 5), // EOF
+ CreateMockRead(*resp2, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 5),
+ MockRead(ASYNC, 0, 6) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
-
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -4519,7 +4436,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
base::WeakPtr<SpdyStream> stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(stream1.get() != NULL);
+ ASSERT_TRUE(stream1.get() != nullptr);
test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
stream1->SetDelegate(&delegate1);
@@ -4529,7 +4446,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
base::WeakPtr<SpdyStream> stream2 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(stream2.get() != NULL);
+ ASSERT_TRUE(stream2.get() != nullptr);
StreamClosingDelegate delegate2(stream2, kBodyDataStringPiece);
stream2->SetDelegate(&delegate2);
@@ -4539,7 +4456,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
base::WeakPtr<SpdyStream> stream3 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(stream3.get() != NULL);
+ ASSERT_TRUE(stream3.get() != nullptr);
test::StreamDelegateWithBody delegate3(stream3, kBodyDataStringPiece);
stream3->SetDelegate(&delegate3);
@@ -4559,7 +4476,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
EXPECT_TRUE(stream1->HasUrlFromHeaders());
EXPECT_EQ(kStreamUrl, stream1->GetUrlFromHeaders().spec());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, stream1->stream_id());
EXPECT_TRUE(stream1->send_stalled_by_flow_control());
@@ -4570,7 +4487,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
EXPECT_TRUE(stream2->HasUrlFromHeaders());
EXPECT_EQ(kStreamUrl, stream2->GetUrlFromHeaders().spec());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(3u, stream2->stream_id());
EXPECT_TRUE(stream2->send_stalled_by_flow_control());
@@ -4581,7 +4498,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
EXPECT_TRUE(stream3->HasUrlFromHeaders());
EXPECT_EQ(kStreamUrl, stream3->GetUrlFromHeaders().spec());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(5u, stream3->stream_id());
EXPECT_TRUE(stream3->send_stalled_by_flow_control());
@@ -4591,7 +4508,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
// Close stream1 preemptively.
session->CloseActiveStream(stream_id1, ERR_CONNECTION_CLOSED);
- EXPECT_EQ(NULL, stream1.get());
+ EXPECT_FALSE(stream1);
EXPECT_FALSE(session->IsStreamActive(stream_id1));
EXPECT_TRUE(session->IsStreamActive(stream_id2));
@@ -4601,16 +4518,18 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
delegate2.set_stream_to_close(stream3);
UnstallSessionSend(session.get(), kBodyDataSize);
- data.RunFor(1);
- EXPECT_EQ(NULL, stream3.get());
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(stream3);
EXPECT_FALSE(stream2->send_stalled_by_flow_control());
EXPECT_FALSE(session->IsStreamActive(stream_id1));
EXPECT_TRUE(session->IsStreamActive(stream_id2));
EXPECT_FALSE(session->IsStreamActive(stream_id3));
- data.RunFor(2);
- EXPECT_EQ(NULL, stream2.get());
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(stream2);
+ EXPECT_FALSE(session);
EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate1.WaitForClose());
EXPECT_EQ(ERR_CONNECTION_CLOSED, delegate2.WaitForClose());
@@ -4641,12 +4560,10 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
session_deps_.host_resolver->set_synchronous_mode(true);
- scoped_ptr<SpdyFrame> req1(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, kBodyDataSize, LOWEST, NULL, 0));
- scoped_ptr<SpdyFrame> req2(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 3, kBodyDataSize, LOWEST, NULL, 0));
+ scoped_ptr<SpdyFrame> req1(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, kBodyDataSize, LOWEST, nullptr, 0));
+ scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 3, kBodyDataSize, LOWEST, nullptr, 0));
scoped_ptr<SpdyFrame> body1(
spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
MockWrite writes[] = {
@@ -4655,17 +4572,13 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 0, 2), // EOF
+ MockRead(ASYNC, ERR_IO_PENDING, 2), MockRead(ASYNC, 0, 3) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
-
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
@@ -4674,7 +4587,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
base::WeakPtr<SpdyStream> stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(stream1.get() != NULL);
+ ASSERT_TRUE(stream1.get() != nullptr);
test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
stream1->SetDelegate(&delegate1);
@@ -4684,7 +4597,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
base::WeakPtr<SpdyStream> stream2 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(stream2.get() != NULL);
+ ASSERT_TRUE(stream2.get() != nullptr);
test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
stream2->SetDelegate(&delegate2);
@@ -4703,7 +4616,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
EXPECT_TRUE(stream1->HasUrlFromHeaders());
EXPECT_EQ(kStreamUrl, stream1->GetUrlFromHeaders().spec());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, stream1->stream_id());
EXPECT_TRUE(stream1->send_stalled_by_flow_control());
@@ -4714,7 +4627,7 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
EXPECT_TRUE(stream2->HasUrlFromHeaders());
EXPECT_EQ(kStreamUrl, stream2->GetUrlFromHeaders().spec());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(3u, stream2->stream_id());
EXPECT_TRUE(stream2->send_stalled_by_flow_control());
@@ -4726,8 +4639,9 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
// Close the session (since we can't do it from within the delegate
// method, since it's in the stream's loop).
session->CloseSessionOnError(ERR_CONNECTION_CLOSED, "Closing session");
+ data.CompleteRead();
base::RunLoop().RunUntilIdle();
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_));
@@ -4747,31 +4661,29 @@ TEST_P(SpdySessionTest, GoAwayOnSessionFlowControlError) {
if (GetParam() < kProtoSPDY31)
return;
- MockConnect connect_data(SYNCHRONOUS, OK);
-
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
- 0,
- GOAWAY_FLOW_CONTROL_ERROR,
+ 0, GOAWAY_FLOW_CONTROL_ERROR,
"delta_window_size is 6 in DecreaseRecvWindowSize, which is larger than "
"the receive window size of 1"));
MockWrite writes[] = {
- CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 3),
+ CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 4),
};
- scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(
+ spdy_util_.ConstructSpdyGetSynReply(nullptr, 0, 1));
scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
MockRead reads[] = {
- CreateMockRead(*resp, 1), CreateMockRead(*body, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*resp, 2),
+ CreateMockRead(*body, 3),
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -4779,7 +4691,7 @@ TEST_P(SpdySessionTest, GoAwayOnSessionFlowControlError) {
GURL url(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream.get() != NULL);
+ ASSERT_TRUE(spdy_stream.get() != nullptr);
test::StreamDelegateDoNothing delegate(spdy_stream);
spdy_stream->SetDelegate(&delegate);
@@ -4787,18 +4699,19 @@ TEST_P(SpdySessionTest, GoAwayOnSessionFlowControlError) {
spdy_util_.ConstructGetHeaderBlock(url.spec()));
spdy_stream->SendRequestHeaders(headers.Pass(), NO_MORE_DATA_TO_SEND);
- data.RunFor(1); // Write request.
+ // Write request.
+ base::RunLoop().RunUntilIdle();
// Put session on the edge of overflowing it's recv window.
session->session_recv_window_size_ = 1;
// Read response headers & body. Body overflows the session window, and a
// goaway is written.
- data.RunFor(3);
- base::MessageLoop::current()->RunUntilIdle();
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(ERR_SPDY_FLOW_CONTROL_ERROR, delegate.WaitForClose());
- EXPECT_TRUE(session == NULL);
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, SplitHeaders) {
@@ -4832,37 +4745,37 @@ TEST_P(SpdySessionTest, PushedStreamShouldNotCountToClientConcurrencyLimit) {
scoped_ptr<SpdyFrame> settings_frame(
spdy_util_.ConstructSpdySettings(new_settings));
scoped_ptr<SpdyFrame> pushed(spdy_util_.ConstructSpdyPush(
- NULL, 0, 2, 1, "http://www.example.org/a.dat"));
+ nullptr, 0, 2, 1, "http://www.example.org/a.dat"));
MockRead reads[] = {
- CreateMockRead(*settings_frame), CreateMockRead(*pushed, 3),
- MockRead(ASYNC, 0, 4),
+ CreateMockRead(*settings_frame, 0),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ CreateMockRead(*pushed, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 5),
+ MockRead(ASYNC, 0, 6),
};
scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
MockWrite writes[] = {
CreateMockWrite(*settings_ack, 1), CreateMockWrite(*req, 2),
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
// Read the settings frame.
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
GURL url1(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
SPDY_REQUEST_RESPONSE_STREAM, session, url1, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -4879,7 +4792,7 @@ TEST_P(SpdySessionTest, PushedStreamShouldNotCountToClientConcurrencyLimit) {
// Run until 1st stream is activated.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(2);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(1u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
@@ -4887,7 +4800,8 @@ TEST_P(SpdySessionTest, PushedStreamShouldNotCountToClientConcurrencyLimit) {
EXPECT_EQ(0u, session->num_active_pushed_streams());
// Run until pushed stream is created.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(2u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(1u, session->num_pushed_streams());
@@ -4898,41 +4812,44 @@ TEST_P(SpdySessionTest, PushedStreamShouldNotCountToClientConcurrencyLimit) {
// create streams on the client.
base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
SPDY_REQUEST_RESPONSE_STREAM, session, url1, LOWEST, BoundNetLog());
- EXPECT_TRUE(spdy_stream2.get() != NULL);
+ EXPECT_TRUE(spdy_stream2);
EXPECT_EQ(2u, session->num_active_streams());
EXPECT_EQ(1u, session->num_created_streams());
EXPECT_EQ(1u, session->num_pushed_streams());
EXPECT_EQ(1u, session->num_active_pushed_streams());
// Read EOF.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, RejectPushedStreamExceedingConcurrencyLimit) {
scoped_ptr<SpdyFrame> push_a(spdy_util_.ConstructSpdyPush(
- NULL, 0, 2, 1, "http://www.example.org/a.dat"));
+ nullptr, 0, 2, 1, "http://www.example.org/a.dat"));
scoped_ptr<SpdyFrame> push_b(spdy_util_.ConstructSpdyPush(
- NULL, 0, 4, 1, "http://www.example.org/b.dat"));
+ nullptr, 0, 4, 1, "http://www.example.org/b.dat"));
MockRead reads[] = {
- CreateMockRead(*push_a, 1), CreateMockRead(*push_b, 2),
- MockRead(ASYNC, 0, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*push_a, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ CreateMockRead(*push_b, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 6),
+ MockRead(ASYNC, 0, 7),
};
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_REFUSED_STREAM));
MockWrite writes[] = {
- CreateMockWrite(*req, 0), CreateMockWrite(*rst, 3),
+ CreateMockWrite(*req, 0), CreateMockWrite(*rst, 5),
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -4941,7 +4858,7 @@ TEST_P(SpdySessionTest, RejectPushedStreamExceedingConcurrencyLimit) {
GURL url1(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
SPDY_REQUEST_RESPONSE_STREAM, session, url1, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -4958,7 +4875,7 @@ TEST_P(SpdySessionTest, RejectPushedStreamExceedingConcurrencyLimit) {
// Run until 1st stream is activated.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(1u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
@@ -4966,21 +4883,25 @@ TEST_P(SpdySessionTest, RejectPushedStreamExceedingConcurrencyLimit) {
EXPECT_EQ(0u, session->num_active_pushed_streams());
// Run until pushed stream is created.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(2u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(1u, session->num_pushed_streams());
EXPECT_EQ(1u, session->num_active_pushed_streams());
// Reset incoming pushed stream.
- data.RunFor(2);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(2u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(1u, session->num_pushed_streams());
EXPECT_EQ(1u, session->num_active_pushed_streams());
// Read EOF.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, IgnoreReservedRemoteStreamsCount) {
@@ -4989,34 +4910,37 @@ TEST_P(SpdySessionTest, IgnoreReservedRemoteStreamsCount) {
return;
scoped_ptr<SpdyFrame> push_a(spdy_util_.ConstructSpdyPush(
- NULL, 0, 2, 1, "http://www.example.org/a.dat"));
+ nullptr, 0, 2, 1, "http://www.example.org/a.dat"));
scoped_ptr<SpdyHeaderBlock> push_headers(new SpdyHeaderBlock);
spdy_util_.AddUrlToHeaderBlock("http://www.example.org/b.dat",
push_headers.get());
scoped_ptr<SpdyFrame> push_b(
spdy_util_.ConstructInitialSpdyPushFrame(push_headers.Pass(), 4, 1));
scoped_ptr<SpdyFrame> headers_b(
- spdy_util_.ConstructSpdyPushHeaders(4, NULL, 0));
+ spdy_util_.ConstructSpdyPushHeaders(4, nullptr, 0));
MockRead reads[] = {
- CreateMockRead(*push_a, 1), CreateMockRead(*push_b, 2),
- CreateMockRead(*headers_b, 3), MockRead(ASYNC, 0, 5),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*push_a, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ CreateMockRead(*push_b, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 5),
+ CreateMockRead(*headers_b, 6),
+ MockRead(ASYNC, ERR_IO_PENDING, 8),
+ MockRead(ASYNC, 0, 9),
};
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_REFUSED_STREAM));
MockWrite writes[] = {
- CreateMockWrite(*req, 0), CreateMockWrite(*rst, 4),
+ CreateMockWrite(*req, 0), CreateMockWrite(*rst, 7),
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -5025,7 +4949,7 @@ TEST_P(SpdySessionTest, IgnoreReservedRemoteStreamsCount) {
GURL url1(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
SPDY_REQUEST_RESPONSE_STREAM, session, url1, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -5042,7 +4966,7 @@ TEST_P(SpdySessionTest, IgnoreReservedRemoteStreamsCount) {
// Run until 1st stream is activated.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(1u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
@@ -5050,14 +4974,16 @@ TEST_P(SpdySessionTest, IgnoreReservedRemoteStreamsCount) {
EXPECT_EQ(0u, session->num_active_pushed_streams());
// Run until pushed stream is created.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(2u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(1u, session->num_pushed_streams());
EXPECT_EQ(1u, session->num_active_pushed_streams());
// Accept promised stream. It should not count towards pushed stream limit.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(3u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(2u, session->num_pushed_streams());
@@ -5065,14 +4991,17 @@ TEST_P(SpdySessionTest, IgnoreReservedRemoteStreamsCount) {
// Reset last pushed stream upon headers reception as it is going to be 2nd,
// while we accept only one.
- data.RunFor(2);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(2u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(1u, session->num_pushed_streams());
EXPECT_EQ(1u, session->num_active_pushed_streams());
// Read EOF.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(session);
}
TEST_P(SpdySessionTest, CancelReservedStreamOnHeadersReceived) {
@@ -5086,27 +5015,28 @@ TEST_P(SpdySessionTest, CancelReservedStreamOnHeadersReceived) {
scoped_ptr<SpdyFrame> push_promise(
spdy_util_.ConstructInitialSpdyPushFrame(push_headers.Pass(), 2, 1));
scoped_ptr<SpdyFrame> headers_frame(
- spdy_util_.ConstructSpdyPushHeaders(2, NULL, 0));
+ spdy_util_.ConstructSpdyPushHeaders(2, nullptr, 0));
MockRead reads[] = {
- CreateMockRead(*push_promise, 1), CreateMockRead(*headers_frame, 2),
- MockRead(ASYNC, 0, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 1),
+ CreateMockRead(*push_promise, 2),
+ MockRead(ASYNC, ERR_IO_PENDING, 3),
+ CreateMockRead(*headers_frame, 4),
+ MockRead(ASYNC, ERR_IO_PENDING, 6),
+ MockRead(ASYNC, 0, 7),
};
scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
+ spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL));
MockWrite writes[] = {
- CreateMockWrite(*req, 0), CreateMockWrite(*rst, 3),
+ CreateMockWrite(*req, 0), CreateMockWrite(*rst, 5),
};
- DeterministicSocketData data(
- reads, arraysize(reads), writes, arraysize(writes));
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
- session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
+ SequencedSocketData data(reads, arraysize(reads), writes, arraysize(writes));
+ session_deps_.socket_factory->AddSocketDataProvider(&data);
- CreateDeterministicNetworkSession();
+ CreateNetworkSession();
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
@@ -5114,7 +5044,7 @@ TEST_P(SpdySessionTest, CancelReservedStreamOnHeadersReceived) {
GURL url1(kDefaultURL);
base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
SPDY_REQUEST_RESPONSE_STREAM, session, url1, LOWEST, BoundNetLog());
- ASSERT_TRUE(spdy_stream1.get() != NULL);
+ ASSERT_TRUE(spdy_stream1.get() != nullptr);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
@@ -5131,7 +5061,7 @@ TEST_P(SpdySessionTest, CancelReservedStreamOnHeadersReceived) {
// Run until 1st stream is activated.
EXPECT_EQ(0u, delegate1.stream_id());
- data.RunFor(1);
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, delegate1.stream_id());
EXPECT_EQ(1u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
@@ -5139,7 +5069,8 @@ TEST_P(SpdySessionTest, CancelReservedStreamOnHeadersReceived) {
EXPECT_EQ(0u, session->num_active_pushed_streams());
// Run until pushed stream is created.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(2u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(1u, session->num_pushed_streams());
@@ -5149,20 +5080,24 @@ TEST_P(SpdySessionTest, CancelReservedStreamOnHeadersReceived) {
int rv =
session->GetPushStream(GURL(kPushedUrl), &pushed_stream, BoundNetLog());
ASSERT_EQ(OK, rv);
- ASSERT_TRUE(pushed_stream.get() != NULL);
+ ASSERT_TRUE(pushed_stream.get() != nullptr);
test::StreamDelegateCloseOnHeaders delegate2(pushed_stream);
pushed_stream->SetDelegate(&delegate2);
// Receive headers for pushed stream. Delegate will cancel the stream, ensure
// that all our counters are in consistent state.
- data.RunFor(1);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
EXPECT_EQ(1u, session->num_active_streams());
EXPECT_EQ(0u, session->num_created_streams());
EXPECT_EQ(0u, session->num_pushed_streams());
EXPECT_EQ(0u, session->num_active_pushed_streams());
// Read EOF.
- data.RunFor(2);
+ data.CompleteRead();
+ base::RunLoop().RunUntilIdle();
+ EXPECT_TRUE(data.AllWriteDataConsumed());
+ EXPECT_TRUE(data.AllReadDataConsumed());
}
TEST_P(SpdySessionTest, RejectInvalidUnknownFrames) {
@@ -5172,10 +5107,7 @@ TEST_P(SpdySessionTest, RejectInvalidUnknownFrames) {
MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
-
- MockConnect connect_data(SYNCHRONOUS, OK);
- data.set_connect_data(connect_data);
+ StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0);
session_deps_.socket_factory->AddSocketDataProvider(&data);
CreateNetworkSession();
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698