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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/spdy/spdy_session_unittest.cc

Issue 266243004: Clang format slam. Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 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
« net/base/mime_util_unittest.cc ('K') | « net/spdy/spdy_session_test_util.cc ('k') | net/spdy/spdy_stream.h » ('j') | 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 5978f9384d9520b0eadd7ebad9f2036e0aa0fcf4..7dbe198a383b610d76dea82932521c9c1a325270 100644
--- a/net/spdy/spdy_session_unittest.cc
+++ b/net/spdy/spdy_session_unittest.cc
@@ -106,9 +106,9 @@ class SpdySessionTest : public PlatformTest,
spdy_session_pool_(NULL),
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
@@ -119,9 +119,7 @@ class SpdySessionTest : public PlatformTest,
HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_);
}
- virtual void SetUp() OVERRIDE {
- g_time_delta = base::TimeDelta();
- }
+ virtual void SetUp() OVERRIDE { g_time_delta = base::TimeDelta(); }
void CreateDeterministicNetworkSession() {
http_session_ =
@@ -130,8 +128,7 @@ class SpdySessionTest : public PlatformTest,
}
void CreateNetworkSession() {
- http_session_ =
- SpdySessionDependencies::SpdyCreateSession(&session_deps_);
+ http_session_ = SpdySessionDependencies::SpdyCreateSession(&session_deps_);
spdy_session_pool_ = http_session_->spdy_session_pool();
}
@@ -178,11 +175,12 @@ class SpdySessionTest : public PlatformTest,
SpdySessionKey key_;
};
-INSTANTIATE_TEST_CASE_P(
- NextProto,
- SpdySessionTest,
- testing::Values(kProtoDeprecatedSPDY2,
- kProtoSPDY3, kProtoSPDY31, kProtoSPDY4));
+INSTANTIATE_TEST_CASE_P(NextProto,
+ SpdySessionTest,
+ testing::Values(kProtoDeprecatedSPDY2,
+ kProtoSPDY3,
+ kProtoSPDY31,
+ kProtoSPDY4));
// Try to create a SPDY session that will fail during
// initialization. Nothing should blow up.
@@ -234,7 +232,9 @@ class StreamRequestDestroyingCallback : public TestCompletionCallbackBase {
TEST_P(SpdySessionTest, PendingStreamCancellingAnother) {
session_deps_.host_resolver->set_synchronous_mode(true);
- MockRead reads[] = {MockRead(ASYNC, 0, 0), };
+ MockRead reads[] = {
+ MockRead(ASYNC, 0, 0),
+ };
DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
MockConnect connect_data(SYNCHRONOUS, OK);
@@ -290,7 +290,7 @@ TEST_P(SpdySessionTest, GoAwayWithNoActiveStreams) {
MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 0),
+ CreateMockRead(*goaway, 0),
};
DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
data.set_connect_data(connect_data);
@@ -321,7 +321,7 @@ TEST_P(SpdySessionTest, GoAwayImmediatelyWithNoActiveStreams) {
MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 0, SYNCHRONOUS),
+ CreateMockRead(*goaway, 0, SYNCHRONOUS),
};
DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
data.set_connect_data(connect_data);
@@ -348,19 +348,17 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreams) {
MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 2),
- MockRead(ASYNC, 0, 3) // EOF
+ CreateMockRead(*goaway, 2), MockRead(ASYNC, 0, 3) // EOF
};
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -372,15 +370,13 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreams) {
EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate2(spdy_stream2);
spdy_stream2->SetDelegate(&delegate2);
@@ -428,20 +424,18 @@ TEST_P(SpdySessionTest, GoAwayTwice) {
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
+ CreateMockRead(*goaway1, 2), CreateMockRead(*goaway2, 3),
+ MockRead(ASYNC, 0, 4) // EOF
};
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -453,15 +447,13 @@ TEST_P(SpdySessionTest, GoAwayTwice) {
EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate2(spdy_stream2);
spdy_stream2->SetDelegate(&delegate2);
@@ -508,19 +500,17 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreamsThenClose) {
MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 2),
- MockRead(ASYNC, 0, 3) // EOF
+ CreateMockRead(*goaway, 2), MockRead(ASYNC, 0, 3) // EOF
};
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
scoped_ptr<SpdyFrame> req2(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -532,15 +522,13 @@ TEST_P(SpdySessionTest, GoAwayWithActiveStreamsThenClose) {
EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate2(spdy_stream2);
spdy_stream2->SetDelegate(&delegate2);
@@ -585,16 +573,15 @@ TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(1));
MockRead reads[] = {
- CreateMockRead(*goaway, 1),
- MockRead(ASYNC, 0, 2) // EOF
+ CreateMockRead(*goaway, 1), MockRead(ASYNC, 0, 2) // EOF
};
scoped_ptr<SpdyFrame> req(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
+ CreateMockWrite(*req, 0),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -606,9 +593,8 @@ TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate(spdy_stream);
spdy_stream->SetDelegate(&delegate);
@@ -630,9 +616,12 @@ TEST_P(SpdySessionTest, CreateStreamAfterGoAway) {
EXPECT_TRUE(session->IsStreamActive(1));
SpdyStreamRequest stream_request;
- int rv = stream_request.StartRequest(
- SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog(),
- CompletionCallback());
+ int rv = stream_request.StartRequest(SPDY_REQUEST_RESPONSE_STREAM,
+ session,
+ url,
+ MEDIUM,
+ BoundNetLog(),
+ CompletionCallback());
EXPECT_EQ(ERR_FAILED, rv);
// Read and process EOF.
@@ -648,23 +637,19 @@ TEST_P(SpdySessionTest, SynStreamAfterGoAway) {
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(NULL, 0, 2, 1, kDefaultURL));
MockRead reads[] = {
- CreateMockRead(*goaway, 1),
- CreateMockRead(*push, 2),
- MockRead(ASYNC, 0, 4) // EOF
+ CreateMockRead(*goaway, 1), CreateMockRead(*push, 2),
+ MockRead(ASYNC, 0, 4) // EOF
};
scoped_ptr<SpdyFrame> req(
spdy_util_.ConstructSpdyGet(NULL, 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));
+ 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);
@@ -676,9 +661,8 @@ TEST_P(SpdySessionTest, SynStreamAfterGoAway) {
EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate(spdy_stream);
spdy_stream->SetDelegate(&delegate);
@@ -713,15 +697,15 @@ TEST_P(SpdySessionTest, NetworkChangeWithActiveStreams) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(ASYNC, 0, 1) // EOF
+ MockRead(ASYNC, 0, 1) // EOF
};
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
+ CreateMockWrite(*req1, 0),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -733,8 +717,11 @@ TEST_P(SpdySessionTest, NetworkChangeWithActiveStreams) {
EXPECT_EQ(spdy_util_.spdy_version(), session->GetProtocolVersion());
base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM, session,
- GURL(kDefaultURL), MEDIUM, BoundNetLog());
+ CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
+ session,
+ GURL(kDefaultURL),
+ MEDIUM,
+ BoundNetLog());
test::StreamDelegateDoNothing delegate(spdy_stream);
spdy_stream->SetDelegate(&delegate);
@@ -752,8 +739,8 @@ TEST_P(SpdySessionTest, NetworkChangeWithActiveStreams) {
spdy_session_pool_->OnIPAddressChanged();
- // The SpdySessionPool behavior differs based on how the OSs reacts to
- // network changes; see comment in SpdySessionPool::OnIPAddressChanged().
+// The SpdySessionPool behavior differs based on how the OSs reacts to
+// network changes; see comment in SpdySessionPool::OnIPAddressChanged().
#if defined(OS_ANDROID) || defined(OS_WIN) || defined(OS_IOS)
// For OSs where the TCP connections will close upon relevant network
// changes, SpdySessionPool doesn't need to force them to close, so in these
@@ -780,12 +767,11 @@ TEST_P(SpdySessionTest, ClientPing) {
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, 0, 0, 2) // EOF
};
scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1, false));
MockWrite writes[] = {
- CreateMockWrite(*write_ping, 0),
+ CreateMockWrite(*write_ping, 0),
};
DeterministicSocketData data(
reads, arraysize(reads), writes, arraysize(writes));
@@ -797,9 +783,8 @@ TEST_P(SpdySessionTest, ClientPing) {
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ 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);
spdy_stream1->SetDelegate(&delegate);
@@ -835,12 +820,11 @@ TEST_P(SpdySessionTest, ServerPing) {
MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> read_ping(spdy_util_.ConstructSpdyPing(2, false));
MockRead reads[] = {
- CreateMockRead(*read_ping),
- MockRead(SYNCHRONOUS, 0, 0) // EOF
+ CreateMockRead(*read_ping), MockRead(SYNCHRONOUS, 0, 0) // EOF
};
scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(2, true));
MockWrite writes[] = {
- CreateMockWrite(*write_ping),
+ CreateMockWrite(*write_ping),
};
StaticSocketDataProvider data(
reads, arraysize(reads), writes, arraysize(writes));
@@ -852,9 +836,8 @@ TEST_P(SpdySessionTest, ServerPing) {
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ 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);
spdy_stream1->SetDelegate(&delegate);
@@ -881,18 +864,17 @@ TEST_P(SpdySessionTest, PingAndWriteLoop) {
scoped_ptr<SpdyFrame> req(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
- CreateMockWrite(*write_ping, 1),
+ CreateMockWrite(*req, 0), CreateMockWrite(*write_ping, 1),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, 0, 2) // EOF
};
session_deps_.host_resolver->set_synchronous_mode(true);
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -902,9 +884,8 @@ TEST_P(SpdySessionTest, PingAndWriteLoop) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
test::StreamDelegateDoNothing delegate(spdy_stream);
spdy_stream->SetDelegate(&delegate);
@@ -1008,7 +989,7 @@ TEST_P(SpdySessionTest, FailedPing) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(ASYNC, 0, 0, 0) // EOF
+ MockRead(ASYNC, 0, 0, 0) // EOF
};
scoped_ptr<SpdyFrame> write_ping(spdy_util_.ConstructSpdyPing(1, false));
DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
@@ -1020,9 +1001,8 @@ TEST_P(SpdySessionTest, FailedPing) {
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ 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);
spdy_stream1->SetDelegate(&delegate);
@@ -1068,8 +1048,7 @@ TEST_P(SpdySessionTest, OnSettings) {
scoped_ptr<SpdyFrame> settings_frame(
spdy_util_.ConstructSpdySettings(new_settings));
MockRead reads[] = {
- CreateMockRead(*settings_frame, 0),
- MockRead(ASYNC, 0, 1),
+ CreateMockRead(*settings_frame, 0), MockRead(ASYNC, 0, 1),
};
DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
@@ -1084,19 +1063,20 @@ TEST_P(SpdySessionTest, OnSettings) {
// Create the maximum number of concurrent streams.
for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) {
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream != NULL);
}
StreamReleaserCallback stream_releaser;
SpdyStreamRequest request;
ASSERT_EQ(ERR_IO_PENDING,
- request.StartRequest(
- SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
- BoundNetLog(),
- stream_releaser.MakeCallback(&request)));
+ request.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
+ session,
+ test_url_,
+ MEDIUM,
+ BoundNetLog(),
+ stream_releaser.MakeCallback(&request)));
data.RunFor(1);
@@ -1127,8 +1107,7 @@ 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, 0, 1),
};
DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
@@ -1145,18 +1124,17 @@ TEST_P(SpdySessionTest, ClearSettings) {
SETTINGS_FLAG_PLEASE_PERSIST,
kInitialMaxConcurrentStreams);
- EXPECT_FALSE(
- spdy_session_pool_->http_server_properties()->GetSpdySettings(
- test_host_port_pair_).empty());
+ EXPECT_FALSE(spdy_session_pool_->http_server_properties()
+ ->GetSpdySettings(test_host_port_pair_)
+ .empty());
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
// Create the maximum number of concurrent streams.
for (size_t i = 0; i < kInitialMaxConcurrentStreams; ++i) {
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream != NULL);
}
@@ -1164,19 +1142,21 @@ TEST_P(SpdySessionTest, ClearSettings) {
SpdyStreamRequest request;
ASSERT_EQ(ERR_IO_PENDING,
- request.StartRequest(
- SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
- BoundNetLog(),
- stream_releaser.MakeCallback(&request)));
+ request.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
+ session,
+ test_url_,
+ MEDIUM,
+ BoundNetLog(),
+ stream_releaser.MakeCallback(&request)));
data.RunFor(1);
EXPECT_EQ(OK, stream_releaser.WaitForResult());
// Make sure that persisted data is cleared.
- EXPECT_TRUE(
- spdy_session_pool_->http_server_properties()->GetSpdySettings(
- test_host_port_pair_).empty());
+ EXPECT_TRUE(spdy_session_pool_->http_server_properties()
+ ->GetSpdySettings(test_host_port_pair_)
+ .empty());
// Make sure session's max_concurrent_streams is correct.
EXPECT_EQ(kInitialMaxConcurrentStreams + 1,
@@ -1195,7 +1175,7 @@ TEST_P(SpdySessionTest, CancelPendingCreateStream) {
session_deps_.host_resolver->set_synchronous_mode(true);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
+ MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ -1218,16 +1198,14 @@ TEST_P(SpdySessionTest, CancelPendingCreateStream) {
// Leave room for only one more stream to be created.
for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) {
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream != NULL);
}
// 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());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
// Use scoped_ptr to let us invalidate the memory when we want to, to trigger
@@ -1236,10 +1214,12 @@ TEST_P(SpdySessionTest, CancelPendingCreateStream) {
SpdyStreamRequest request;
ASSERT_EQ(ERR_IO_PENDING,
- request.StartRequest(
- SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM,
- BoundNetLog(),
- callback->callback()));
+ request.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
+ session,
+ test_url_,
+ MEDIUM,
+ BoundNetLog(),
+ callback->callback()));
// Release the first one, this will allow the second to be created.
spdy_stream1->Cancel();
@@ -1256,7 +1236,7 @@ TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
session_deps_.host_resolver->set_synchronous_mode(true);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
+ MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
SettingsMap settings;
@@ -1278,10 +1258,8 @@ TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
kDefaultInitialRecvWindowSize - kSpdySessionInitialWindowSize));
std::vector<MockWrite> writes;
if (GetParam() == kProtoSPDY4) {
- writes.push_back(
- MockWrite(ASYNC,
- kHttp2ConnectionHeaderPrefix,
- kHttp2ConnectionHeaderPrefixSize));
+ writes.push_back(MockWrite(
+ ASYNC, kHttp2ConnectionHeaderPrefix, kHttp2ConnectionHeaderPrefixSize));
}
writes.push_back(CreateMockWrite(*settings_frame));
if (GetParam() >= kProtoSPDY31) {
@@ -1290,17 +1268,16 @@ TEST_P(SpdySessionTest, SendInitialDataOnNewSession) {
SettingsMap server_settings;
const uint32 initial_max_concurrent_streams = 1;
- server_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
- SettingsFlagsAndValue(SETTINGS_FLAG_PERSISTED,
- initial_max_concurrent_streams);
+ server_settings[SETTINGS_MAX_CONCURRENT_STREAMS] = SettingsFlagsAndValue(
+ SETTINGS_FLAG_PERSISTED, initial_max_concurrent_streams);
scoped_ptr<SpdyFrame> server_settings_frame(
spdy_util_.ConstructSpdySettings(server_settings));
writes.push_back(CreateMockWrite(*server_settings_frame));
session_deps_.stream_initial_recv_window_size = kInitialRecvWindowSize;
- StaticSocketDataProvider data(reads, arraysize(reads),
- vector_as_array(&writes), writes.size());
+ StaticSocketDataProvider data(
+ reads, arraysize(reads), vector_as_array(&writes), writes.size());
data.set_connect_data(connect_data);
session_deps_.socket_factory->AddSocketDataProvider(&data);
@@ -1328,16 +1305,17 @@ TEST_P(SpdySessionTest, ClearSettingsStorageOnIPAddressChanged) {
base::WeakPtr<HttpServerProperties> test_http_server_properties =
spdy_session_pool_->http_server_properties();
SettingsFlagsAndValue flags_and_value1(SETTINGS_FLAG_PLEASE_PERSIST, 2);
- test_http_server_properties->SetSpdySetting(
- test_host_port_pair_,
- SETTINGS_MAX_CONCURRENT_STREAMS,
- SETTINGS_FLAG_PLEASE_PERSIST,
- 2);
- EXPECT_NE(0u, test_http_server_properties->GetSpdySettings(
- test_host_port_pair_).size());
+ test_http_server_properties->SetSpdySetting(test_host_port_pair_,
+ SETTINGS_MAX_CONCURRENT_STREAMS,
+ SETTINGS_FLAG_PLEASE_PERSIST,
+ 2);
+ EXPECT_NE(0u,
+ test_http_server_properties->GetSpdySettings(test_host_port_pair_)
+ .size());
spdy_session_pool_->OnIPAddressChanged();
- EXPECT_EQ(0u, test_http_server_properties->GetSpdySettings(
- test_host_port_pair_).size());
+ EXPECT_EQ(0u,
+ test_http_server_properties->GetSpdySettings(test_host_port_pair_)
+ .size());
}
TEST_P(SpdySessionTest, Initialize) {
@@ -1347,7 +1325,7 @@ TEST_P(SpdySessionTest, Initialize) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
+ MockRead(ASYNC, 0, 0) // EOF
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ -1369,15 +1347,16 @@ TEST_P(SpdySessionTest, Initialize) {
// Check that we logged TYPE_SPDY_SESSION_INITIALIZED correctly.
int pos = net::ExpectLogContainsSomewhere(
- entries, 0,
+ entries,
+ 0,
net::NetLog::TYPE_SPDY_SESSION_INITIALIZED,
net::NetLog::PHASE_NONE);
EXPECT_LT(0, pos);
CapturingNetLog::CapturedEntry entry = entries[pos];
NetLog::Source socket_source;
- EXPECT_TRUE(NetLog::Source::FromEventParameters(entry.params.get(),
- &socket_source));
+ EXPECT_TRUE(
+ NetLog::Source::FromEventParameters(entry.params.get(), &socket_source));
EXPECT_TRUE(socket_source.IsValid());
EXPECT_NE(log.bound().source().id, socket_source.id);
}
@@ -1388,8 +1367,7 @@ TEST_P(SpdySessionTest, CloseSessionOnError) {
MockConnect connect_data(SYNCHRONOUS, OK);
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway());
MockRead reads[] = {
- CreateMockRead(*goaway),
- MockRead(SYNCHRONOUS, 0, 0) // EOF
+ CreateMockRead(*goaway), MockRead(SYNCHRONOUS, 0, 0) // EOF
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ -1415,10 +1393,11 @@ TEST_P(SpdySessionTest, CloseSessionOnError) {
EXPECT_LT(0u, entries.size());
// Check that we logged SPDY_SESSION_CLOSE correctly.
- int pos = net::ExpectLogContainsSomewhere(
- entries, 0,
- net::NetLog::TYPE_SPDY_SESSION_CLOSE,
- net::NetLog::PHASE_NONE);
+ int pos =
+ net::ExpectLogContainsSomewhere(entries,
+ 0,
+ net::NetLog::TYPE_SPDY_SESSION_CLOSE,
+ net::NetLog::PHASE_NONE);
if (pos < static_cast<int>(entries.size())) {
CapturingNetLog::CapturedEntry entry = entries[pos];
@@ -1441,8 +1420,7 @@ TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
scoped_ptr<SpdyFrame> req_lowest(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
MockWrite writes[] = {
- CreateMockWrite(*req_highest, 0),
- CreateMockWrite(*req_lowest, 1),
+ CreateMockWrite(*req_highest, 0), CreateMockWrite(*req_lowest, 1),
};
scoped_ptr<SpdyFrame> resp_highest(
@@ -1451,20 +1429,17 @@ TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
spdy_util_.ConstructSpdyBodyFrame(1, true));
scoped_ptr<SpdyFrame> resp_lowest(
spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
- scoped_ptr<SpdyFrame> body_lowest(
- spdy_util_.ConstructSpdyBodyFrame(3, true));
+ scoped_ptr<SpdyFrame> body_lowest(spdy_util_.ConstructSpdyBodyFrame(3, true));
MockRead reads[] = {
- CreateMockRead(*resp_highest, 2),
- CreateMockRead(*body_highest, 3),
- CreateMockRead(*resp_lowest, 4),
- CreateMockRead(*body_lowest, 5),
- MockRead(ASYNC, 0, 6) // EOF
+ CreateMockRead(*resp_highest, 2), CreateMockRead(*body_highest, 3),
+ CreateMockRead(*resp_lowest, 4), CreateMockRead(*body_lowest, 5),
+ MockRead(ASYNC, 0, 6) // EOF
};
session_deps_.host_resolver->set_synchronous_mode(true);
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -1475,17 +1450,15 @@ TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream_lowest =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream_lowest = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(spdy_stream_lowest);
EXPECT_EQ(0u, spdy_stream_lowest->stream_id());
test::StreamDelegateDoNothing delegate_lowest(spdy_stream_lowest);
spdy_stream_lowest->SetDelegate(&delegate_lowest);
- base::WeakPtr<SpdyStream> spdy_stream_highest =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, HIGHEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream_highest = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, HIGHEST, BoundNetLog());
ASSERT_TRUE(spdy_stream_highest);
EXPECT_EQ(0u, spdy_stream_highest->stream_id());
test::StreamDelegateDoNothing delegate_highest(spdy_stream_highest);
@@ -1495,14 +1468,14 @@ TEST_P(SpdySessionTest, OutOfOrderSynStreams) {
scoped_ptr<SpdyHeaderBlock> headers_lowest(
spdy_util_.ConstructGetHeaderBlock(url.spec()));
- spdy_stream_lowest->SendRequestHeaders(
- headers_lowest.Pass(), NO_MORE_DATA_TO_SEND);
+ spdy_stream_lowest->SendRequestHeaders(headers_lowest.Pass(),
+ NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream_lowest->HasUrlFromHeaders());
scoped_ptr<SpdyHeaderBlock> headers_highest(
spdy_util_.ConstructGetHeaderBlock(url.spec()));
- spdy_stream_highest->SendRequestHeaders(
- headers_highest.Pass(), NO_MORE_DATA_TO_SEND);
+ spdy_stream_highest->SendRequestHeaders(headers_highest.Pass(),
+ NO_MORE_DATA_TO_SEND);
EXPECT_TRUE(spdy_stream_highest->HasUrlFromHeaders());
data.RunFor(7);
@@ -1520,21 +1493,20 @@ TEST_P(SpdySessionTest, CancelStream) {
scoped_ptr<SpdyFrame> req2(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
MockWrite writes[] = {
- CreateMockWrite(*req2, 0),
+ CreateMockWrite(*req2, 0),
};
scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 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), CreateMockRead(*body2, 2),
+ MockRead(ASYNC, 0, 3) // EOF
};
session_deps_.host_resolver->set_synchronous_mode(true);
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -1544,18 +1516,16 @@ TEST_P(SpdySessionTest, CancelStream) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, HIGHEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, HIGHEST, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
GURL url2(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url2, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url2, LOWEST, BoundNetLog());
ASSERT_TRUE(spdy_stream2.get() != NULL);
EXPECT_EQ(0u, spdy_stream2->stream_id());
test::StreamDelegateDoNothing delegate2(spdy_stream2);
@@ -1597,14 +1567,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
// No actual data will be sent.
MockWrite writes[] = {
- MockWrite(ASYNC, 0, 1) // EOF
+ MockWrite(ASYNC, 0, 1) // EOF
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
+ MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -1614,16 +1584,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedSelfClosingStreams) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url1, HIGHEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url1, HIGHEST, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url2, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url2, LOWEST, BoundNetLog());
ASSERT_TRUE(spdy_stream2.get() != NULL);
EXPECT_EQ(0u, spdy_stream2->stream_id());
@@ -1668,14 +1636,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
// No actual data will be sent.
MockWrite writes[] = {
- MockWrite(ASYNC, 0, 1) // EOF
+ MockWrite(ASYNC, 0, 1) // EOF
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
+ MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -1685,16 +1653,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoCreatedMutuallyClosingStreams) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url1, HIGHEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url1, HIGHEST, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url2, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url2, LOWEST, BoundNetLog());
ASSERT_TRUE(spdy_stream2.get() != NULL);
EXPECT_EQ(0u, spdy_stream2->stream_id());
@@ -1744,16 +1710,15 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
scoped_ptr<SpdyFrame> req2(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, 0, 2) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -1763,16 +1728,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedSelfClosingStreams) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url2, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url2, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream2.get() != NULL);
EXPECT_EQ(0u, spdy_stream2->stream_id());
@@ -1825,16 +1788,15 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
scoped_ptr<SpdyFrame> req2(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 2) // EOF
+ MockRead(ASYNC, 0, 2) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -1844,16 +1806,14 @@ TEST_P(SpdySessionTest, CloseSessionWithTwoActivatedMutuallyClosingStreams) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
GURL url2(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url2, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url2, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream2.get() != NULL);
EXPECT_EQ(0u, spdy_stream2->stream_id());
@@ -1901,8 +1861,7 @@ class SessionClosingDelegate : public test::StreamDelegateDoNothing {
public:
SessionClosingDelegate(const base::WeakPtr<SpdyStream>& stream,
const base::WeakPtr<SpdySession>& session_to_close)
- : StreamDelegateDoNothing(stream),
- session_to_close_(session_to_close) {}
+ : StreamDelegateDoNothing(stream), session_to_close_(session_to_close) {}
virtual ~SessionClosingDelegate() {}
@@ -1924,14 +1883,14 @@ TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
scoped_ptr<SpdyFrame> req(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
+ CreateMockWrite(*req, 0),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 1) // EOF
+ MockRead(ASYNC, 0, 1) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -1941,9 +1900,8 @@ TEST_P(SpdySessionTest, CloseActivatedStreamThatClosesSession) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream.get() != NULL);
EXPECT_EQ(0u, spdy_stream->stream_id());
@@ -1977,14 +1935,14 @@ TEST_P(SpdySessionTest, VerifyDomainAuthentication) {
// No actual data will be sent.
MockWrite writes[] = {
- MockWrite(ASYNC, 0, 1) // EOF
+ MockWrite(ASYNC, 0, 1) // EOF
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
+ MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -2019,14 +1977,14 @@ TEST_P(SpdySessionTest, ConnectionPooledWithTlsChannelId) {
// No actual data will be sent.
MockWrite writes[] = {
- MockWrite(ASYNC, 0, 1) // EOF
+ MockWrite(ASYNC, 0, 1) // EOF
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 0) // EOF
+ MockRead(ASYNC, 0, 0) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -2073,9 +2031,8 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
scoped_ptr<SpdyFrame> req3(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, LOWEST, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 1),
- CreateMockWrite(*req2, 4),
- CreateMockWrite(*req3, 7),
+ CreateMockWrite(*req1, 1), CreateMockWrite(*req2, 4),
+ CreateMockWrite(*req3, 7),
};
// Set up the socket so we read a SETTINGS frame that sets max concurrent
@@ -2093,18 +2050,14 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, true));
MockRead reads[] = {
- CreateMockRead(*settings_frame),
- CreateMockRead(*resp1, 2),
- CreateMockRead(*body1, 3),
- CreateMockRead(*resp2, 5),
- CreateMockRead(*body2, 6),
- CreateMockRead(*resp3, 8),
- CreateMockRead(*body3, 9),
- MockRead(ASYNC, 0, 10) // EOF
+ CreateMockRead(*settings_frame), CreateMockRead(*resp1, 2),
+ CreateMockRead(*body1, 3), CreateMockRead(*resp2, 5),
+ CreateMockRead(*body2, 6), CreateMockRead(*resp3, 8),
+ CreateMockRead(*body3, 9), MockRead(ASYNC, 0, 10) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -2117,9 +2070,8 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
data.RunFor(1);
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, LOWEST, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
@@ -2129,17 +2081,23 @@ TEST_P(SpdySessionTest, CloseTwoStalledCreateStream) {
GURL url2(kDefaultURL);
SpdyStreamRequest request2;
ASSERT_EQ(ERR_IO_PENDING,
- request2.StartRequest(
- SPDY_REQUEST_RESPONSE_STREAM,
- session, url2, LOWEST, BoundNetLog(), callback2.callback()));
+ request2.StartRequest(SPDY_REQUEST_RESPONSE_STREAM,
+ session,
+ url2,
+ LOWEST,
+ BoundNetLog(),
+ callback2.callback()));
TestCompletionCallback callback3;
GURL url3(kDefaultURL);
SpdyStreamRequest request3;
ASSERT_EQ(ERR_IO_PENDING,
- request3.StartRequest(
- SPDY_REQUEST_RESPONSE_STREAM,
- session, url3, LOWEST, BoundNetLog(), callback3.callback()));
+ request3.StartRequest(SPDY_REQUEST_RESPONSE_STREAM,
+ session,
+ url3,
+ LOWEST,
+ BoundNetLog(),
+ callback3.callback()));
EXPECT_EQ(0u, session->num_active_streams());
EXPECT_EQ(1u, session->num_created_streams());
@@ -2219,7 +2177,7 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
session_deps_.host_resolver->set_synchronous_mode(true);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
+ MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
@@ -2235,16 +2193,14 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
// Leave room for only one more stream to be created.
for (size_t i = 0; i < kInitialMaxConcurrentStreams - 1; ++i) {
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream != NULL);
}
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url1, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url1, LOWEST, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
@@ -2252,17 +2208,23 @@ TEST_P(SpdySessionTest, CancelTwoStalledCreateStream) {
GURL url2(kDefaultURL);
SpdyStreamRequest request2;
ASSERT_EQ(ERR_IO_PENDING,
- request2.StartRequest(
- SPDY_BIDIRECTIONAL_STREAM, session, url2, LOWEST, BoundNetLog(),
- callback2.callback()));
+ request2.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
+ session,
+ url2,
+ LOWEST,
+ BoundNetLog(),
+ callback2.callback()));
TestCompletionCallback callback3;
GURL url3(kDefaultURL);
SpdyStreamRequest request3;
ASSERT_EQ(ERR_IO_PENDING,
- request3.StartRequest(
- SPDY_BIDIRECTIONAL_STREAM, session, url3, LOWEST, BoundNetLog(),
- callback3.callback()));
+ request3.StartRequest(SPDY_BIDIRECTIONAL_STREAM,
+ session,
+ url3,
+ LOWEST,
+ BoundNetLog(),
+ callback3.callback()));
EXPECT_EQ(0u, session->num_active_streams());
EXPECT_EQ(kInitialMaxConcurrentStreams, session->num_created_streams());
@@ -2308,7 +2270,7 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
+ CreateMockWrite(*req1, 0),
};
// Build buffer of size kMaxReadBytesWithoutYielding / 4
@@ -2331,17 +2293,16 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
// 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), 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
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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);
@@ -2352,9 +2313,8 @@ TEST_P(SpdySessionTest, ReadDataWithoutYielding) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
@@ -2399,7 +2359,7 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
+ CreateMockWrite(*req1, 0),
};
// Build buffer of size kMaxReadBytesWithoutYielding / 4
@@ -2421,18 +2381,17 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
// 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), 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
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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);
@@ -2443,9 +2402,8 @@ TEST_P(SpdySessionTest, TestYieldingDuringReadData) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
@@ -2497,7 +2455,7 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
+ CreateMockWrite(*req1, 0),
};
// Build buffer of size kMaxReadBytesWithoutYielding / 4
@@ -2523,29 +2481,28 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
1, eightk_payload_data, kEightKPayloadSize, DATA_FLAG_NONE));
scoped_ptr<SpdyFrame> twok_data_frame(framer.CreateDataFrame(
1, twok_payload_data, kTwoKPayloadSize, DATA_FLAG_NONE));
- scoped_ptr<SpdyFrame> finish_data_frame(framer.CreateDataFrame(
- 1, "h", 1, DATA_FLAG_FIN));
+ scoped_ptr<SpdyFrame> finish_data_frame(
+ framer.CreateDataFrame(1, "h", 1, DATA_FLAG_FIN));
scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 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), 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
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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);
@@ -2556,9 +2513,8 @@ TEST_P(SpdySessionTest, TestYieldingDuringAsyncReadData) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
EXPECT_EQ(0u, spdy_stream1->stream_id());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
@@ -2601,7 +2557,7 @@ TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
+ CreateMockWrite(*req1, 0),
};
scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
@@ -2609,14 +2565,13 @@ TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway());
MockRead reads[] = {
- CreateMockRead(*resp1, 1),
- CreateMockRead(*body1, 2),
- CreateMockRead(*goaway, 3),
+ CreateMockRead(*resp1, 1), CreateMockRead(*body1, 2),
+ CreateMockRead(*goaway, 3),
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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);
@@ -2627,9 +2582,8 @@ TEST_P(SpdySessionTest, GoAwayWhileInDoReadLoop) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url1(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url1, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url1, MEDIUM, BoundNetLog());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
spdy_stream1->SetDelegate(&delegate1);
ASSERT_TRUE(spdy_stream1.get() != NULL);
@@ -2662,7 +2616,7 @@ TEST_P(SpdySessionTest, ProtocolNegotiation) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, 0, 0) // EOF
+ MockRead(SYNCHRONOUS, 0, 0) // EOF
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
data.set_connect_data(connect_data);
@@ -2703,7 +2657,7 @@ TEST_P(SpdySessionTest, CloseOneIdleConnection) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
+ MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
data.set_connect_data(connect_data);
@@ -2712,13 +2666,12 @@ TEST_P(SpdySessionTest, CloseOneIdleConnection) {
CreateNetworkSession();
- TransportClientSocketPool* pool =
- http_session_->GetTransportSocketPool(
- HttpNetworkSession::NORMAL_SOCKET_POOL);
+ TransportClientSocketPool* pool = http_session_->GetTransportSocketPool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
// Create an idle SPDY session.
- SpdySessionKey key1(HostPortPair("1.com", 80), ProxyServer::Direct(),
- PRIVACY_MODE_DISABLED);
+ SpdySessionKey key1(
+ HostPortPair("1.com", 80), ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
base::WeakPtr<SpdySession> session1 =
CreateInsecureSpdySession(http_session_, key1, BoundNetLog());
EXPECT_FALSE(pool->IsStalled());
@@ -2727,13 +2680,16 @@ TEST_P(SpdySessionTest, CloseOneIdleConnection) {
// post a task asynchronously to try and close the session.
TestCompletionCallback callback2;
HostPortPair host_port2("2.com", 80);
- scoped_refptr<TransportSocketParams> params2(
- new TransportSocketParams(host_port2, false, false,
- OnHostResolutionCallback()));
+ scoped_refptr<TransportSocketParams> params2(new TransportSocketParams(
+ host_port2, false, false, OnHostResolutionCallback()));
scoped_ptr<ClientSocketHandle> connection2(new ClientSocketHandle);
EXPECT_EQ(ERR_IO_PENDING,
- connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY,
- callback2.callback(), pool, BoundNetLog()));
+ connection2->Init(host_port2.ToString(),
+ params2,
+ DEFAULT_PRIORITY,
+ callback2.callback(),
+ pool,
+ BoundNetLog()));
EXPECT_TRUE(pool->IsStalled());
// The socket pool should close the connection asynchronously and establish a
@@ -2754,7 +2710,7 @@ TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
+ MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
data.set_connect_data(connect_data);
@@ -2772,20 +2728,19 @@ TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
CreateNetworkSession();
- TransportClientSocketPool* pool =
- http_session_->GetTransportSocketPool(
- HttpNetworkSession::NORMAL_SOCKET_POOL);
+ TransportClientSocketPool* pool = http_session_->GetTransportSocketPool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
// Create an idle SPDY session.
- SpdySessionKey key1(HostPortPair("1.com", 80), ProxyServer::Direct(),
- PRIVACY_MODE_DISABLED);
+ SpdySessionKey key1(
+ HostPortPair("1.com", 80), ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
base::WeakPtr<SpdySession> session1 =
CreateInsecureSpdySession(http_session_, key1, BoundNetLog());
EXPECT_FALSE(pool->IsStalled());
// Set up an alias for the idle SPDY session, increasing its ref count to 2.
- SpdySessionKey key2(HostPortPair("2.com", 80), ProxyServer::Direct(),
- PRIVACY_MODE_DISABLED);
+ SpdySessionKey key2(
+ HostPortPair("2.com", 80), ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
HostResolver::RequestInfo info(key2.host_port_pair());
AddressList addresses;
// Pre-populate the DNS cache, since a synchronous resolution is required in
@@ -2806,13 +2761,16 @@ TEST_P(SpdySessionTest, CloseOneIdleConnectionWithAlias) {
// post a task asynchronously to try and close the session.
TestCompletionCallback callback3;
HostPortPair host_port3("3.com", 80);
- scoped_refptr<TransportSocketParams> params3(
- new TransportSocketParams(host_port3, false, false,
- OnHostResolutionCallback()));
+ scoped_refptr<TransportSocketParams> params3(new TransportSocketParams(
+ host_port3, false, false, OnHostResolutionCallback()));
scoped_ptr<ClientSocketHandle> connection3(new ClientSocketHandle);
EXPECT_EQ(ERR_IO_PENDING,
- connection3->Init(host_port3.ToString(), params3, DEFAULT_PRIORITY,
- callback3.callback(), pool, BoundNetLog()));
+ connection3->Init(host_port3.ToString(),
+ params3,
+ DEFAULT_PRIORITY,
+ callback3.callback(),
+ pool,
+ BoundNetLog()));
EXPECT_TRUE(pool->IsStalled());
// The socket pool should close the connection asynchronously and establish a
@@ -2833,40 +2791,38 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
+ MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
scoped_ptr<SpdyFrame> req1(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
scoped_ptr<SpdyFrame> cancel1(
spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
MockWrite writes[] = {
- CreateMockWrite(*req1, 1),
- CreateMockWrite(*cancel1, 1),
+ CreateMockWrite(*req1, 1), CreateMockWrite(*cancel1, 1),
};
- StaticSocketDataProvider data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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.
+ MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever.
};
- StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
- NULL, 0);
+ StaticSocketDataProvider http_data(
+ http_reads, arraysize(http_reads), NULL, 0);
http_data.set_connect_data(connect_data);
session_deps_.socket_factory->AddSocketDataProvider(&http_data);
-
CreateNetworkSession();
- TransportClientSocketPool* pool =
- http_session_->GetTransportSocketPool(
- HttpNetworkSession::NORMAL_SOCKET_POOL);
+ TransportClientSocketPool* pool = http_session_->GetTransportSocketPool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
// Create a SPDY session.
GURL url1(kDefaultURL);
SpdySessionKey key1(HostPortPair(url1.host(), 80),
- ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
+ ProxyServer::Direct(),
+ PRIVACY_MODE_DISABLED);
base::WeakPtr<SpdySession> session1 =
CreateInsecureSpdySession(http_session_, key1, BoundNetLog());
EXPECT_FALSE(pool->IsStalled());
@@ -2876,7 +2832,9 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
TestCompletionCallback callback1;
base::WeakPtr<SpdyStream> spdy_stream1 =
CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session1, url1, DEFAULT_PRIORITY,
+ session1,
+ url1,
+ DEFAULT_PRIORITY,
BoundNetLog());
ASSERT_TRUE(spdy_stream1.get());
test::StreamDelegateDoNothing delegate1(spdy_stream1);
@@ -2884,9 +2842,9 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
scoped_ptr<SpdyHeaderBlock> headers1(
spdy_util_.ConstructGetHeaderBlock(url1.spec()));
- EXPECT_EQ(ERR_IO_PENDING,
- spdy_stream1->SendRequestHeaders(
- headers1.Pass(), NO_MORE_DATA_TO_SEND));
+ EXPECT_EQ(
+ ERR_IO_PENDING,
+ spdy_stream1->SendRequestHeaders(headers1.Pass(), NO_MORE_DATA_TO_SEND));
EXPECT_TRUE(spdy_stream1->HasUrlFromHeaders());
base::MessageLoop::current()->RunUntilIdle();
@@ -2895,13 +2853,16 @@ TEST_P(SpdySessionTest, CloseSessionOnIdleWhenPoolStalled) {
// post a task asynchronously to try and close the session.
TestCompletionCallback callback2;
HostPortPair host_port2("2.com", 80);
- scoped_refptr<TransportSocketParams> params2(
- new TransportSocketParams(host_port2, false, false,
- OnHostResolutionCallback()));
+ scoped_refptr<TransportSocketParams> params2(new TransportSocketParams(
+ host_port2, false, false, OnHostResolutionCallback()));
scoped_ptr<ClientSocketHandle> connection2(new ClientSocketHandle);
EXPECT_EQ(ERR_IO_PENDING,
- connection2->Init(host_port2.ToString(), params2, DEFAULT_PRIORITY,
- callback2.callback(), pool, BoundNetLog()));
+ connection2->Init(host_port2.ToString(),
+ params2,
+ DEFAULT_PRIORITY,
+ callback2.callback(),
+ pool,
+ BoundNetLog()));
EXPECT_TRUE(pool->IsStalled());
// Running the message loop should cause the socket pool to ask the SPDY
@@ -2926,10 +2887,10 @@ TEST_P(SpdySessionTest, SpdySessionKeyPrivacyMode) {
CreateDeterministicNetworkSession();
HostPortPair host_port_pair("www.google.com", 443);
- SpdySessionKey key_privacy_enabled(host_port_pair, ProxyServer::Direct(),
- PRIVACY_MODE_ENABLED);
- SpdySessionKey key_privacy_disabled(host_port_pair, ProxyServer::Direct(),
- PRIVACY_MODE_DISABLED);
+ SpdySessionKey key_privacy_enabled(
+ host_port_pair, ProxyServer::Direct(), PRIVACY_MODE_ENABLED);
+ SpdySessionKey key_privacy_disabled(
+ host_port_pair, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_enabled));
EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_privacy_disabled));
@@ -2962,16 +2923,14 @@ class StreamCreatingDelegate : public test::StreamDelegateDoNothing {
public:
StreamCreatingDelegate(const base::WeakPtr<SpdyStream>& stream,
const base::WeakPtr<SpdySession>& session)
- : StreamDelegateDoNothing(stream),
- session_(session) {}
+ : StreamDelegateDoNothing(stream), session_(session) {}
virtual ~StreamCreatingDelegate() {}
virtual void OnClose(int status) OVERRIDE {
GURL url(kDefaultURL);
- ignore_result(
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session_, url, MEDIUM, BoundNetLog()));
+ ignore_result(CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session_, url, MEDIUM, BoundNetLog()));
}
private:
@@ -2989,17 +2948,16 @@ TEST_P(SpdySessionTest, CreateStreamOnStreamReset) {
scoped_ptr<SpdyFrame> req(
spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, MEDIUM, true));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
+ CreateMockWrite(*req, 0),
};
scoped_ptr<SpdyFrame> rst(
spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_REFUSED_STREAM));
MockRead reads[] = {
- CreateMockRead(*rst, 1),
- MockRead(ASYNC, 0, 2) // EOF
+ CreateMockRead(*rst, 1), MockRead(ASYNC, 0, 2) // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -3009,9 +2967,8 @@ TEST_P(SpdySessionTest, CreateStreamOnStreamReset) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url(kDefaultURL);
- base::WeakPtr<SpdyStream> spdy_stream =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream.get() != NULL);
EXPECT_EQ(0u, spdy_stream->stream_id());
@@ -3058,8 +3015,7 @@ TEST_P(SpdySessionTest, UpdateStreamsSendWindowSize) {
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, 0, 1) // EOF
};
session_deps_.host_resolver->set_synchronous_mode(true);
@@ -3073,9 +3029,8 @@ TEST_P(SpdySessionTest, UpdateStreamsSendWindowSize) {
base::WeakPtr<SpdySession> session =
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
- base::WeakPtr<SpdyStream> spdy_stream1 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream1 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream1.get() != NULL);
TestCompletionCallback callback1;
EXPECT_NE(spdy_stream1->send_window_size(), window_size);
@@ -3089,9 +3044,8 @@ TEST_P(SpdySessionTest, UpdateStreamsSendWindowSize) {
spdy_stream1->Cancel();
EXPECT_EQ(NULL, spdy_stream1.get());
- base::WeakPtr<SpdyStream> spdy_stream2 =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, test_url_, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> spdy_stream2 = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, test_url_, MEDIUM, BoundNetLog());
ASSERT_TRUE(spdy_stream2.get() != NULL);
EXPECT_EQ(spdy_stream2->send_window_size(), window_size);
spdy_stream2->Cancel();
@@ -3114,17 +3068,16 @@ TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(ASYNC, 0, 1) // EOF
+ MockRead(ASYNC, 0, 1) // EOF
};
- scoped_ptr<SpdyFrame> window_update(
- spdy_util_.ConstructSpdyWindowUpdate(
- kSessionFlowControlStreamId,
- kSpdySessionInitialWindowSize + delta_window_size));
+ scoped_ptr<SpdyFrame> window_update(spdy_util_.ConstructSpdyWindowUpdate(
+ kSessionFlowControlStreamId,
+ kSpdySessionInitialWindowSize + delta_window_size));
MockWrite writes[] = {
- CreateMockWrite(*window_update, 0),
+ CreateMockWrite(*window_update, 0),
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
data.set_connect_data(connect_data);
session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data);
@@ -3145,7 +3098,7 @@ TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
// Should trigger sending a WINDOW_UPDATE frame.
session->IncreaseRecvWindowSize(kSpdySessionInitialWindowSize);
EXPECT_EQ(kSpdySessionInitialWindowSize + delta_window_size +
- kSpdySessionInitialWindowSize,
+ kSpdySessionInitialWindowSize,
session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
@@ -3153,9 +3106,9 @@ TEST_P(SpdySessionTest, AdjustRecvWindowSize) {
// DecreaseRecvWindowSize() expects |in_io_loop_| to be true.
session->in_io_loop_ = true;
- session->DecreaseRecvWindowSize(
- kSpdySessionInitialWindowSize + delta_window_size +
- kSpdySessionInitialWindowSize);
+ session->DecreaseRecvWindowSize(kSpdySessionInitialWindowSize +
+ delta_window_size +
+ kSpdySessionInitialWindowSize);
session->in_io_loop_ = false;
EXPECT_EQ(0, session->session_recv_window_size_);
EXPECT_EQ(0, session->session_unacked_recv_window_bytes_);
@@ -3172,7 +3125,7 @@ TEST_P(SpdySessionTest, AdjustSendWindowSize) {
MockConnect connect_data(SYNCHRONOUS, OK);
MockRead reads[] = {
- MockRead(SYNCHRONOUS, 0, 0) // EOF
+ MockRead(SYNCHRONOUS, 0, 0) // EOF
};
StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
data.set_connect_data(connect_data);
@@ -3208,8 +3161,7 @@ TEST_P(SpdySessionTest, SessionFlowControlInactiveStream) {
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, 0, 1) // EOF
};
DeterministicSocketData data(reads, arraysize(reads), NULL, 0);
data.set_connect_data(connect_data);
@@ -3259,33 +3211,27 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
MockConnect connect_data(SYNCHRONOUS, OK);
- scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
- scoped_ptr<SpdyFrame> msg(
- spdy_util_.ConstructSpdyBodyFrame(
- 1, msg_data.data(), msg_data_size, false));
+ scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
+ scoped_ptr<SpdyFrame> msg(spdy_util_.ConstructSpdyBodyFrame(
+ 1, msg_data.data(), msg_data_size, false));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
- CreateMockWrite(*msg, 2),
+ CreateMockWrite(*req, 0), CreateMockWrite(*msg, 2),
};
scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
- scoped_ptr<SpdyFrame> echo(
- spdy_util_.ConstructSpdyBodyFrame(
- 1, msg_data.data(), msg_data_size, false));
- scoped_ptr<SpdyFrame> window_update(
- spdy_util_.ConstructSpdyWindowUpdate(
- kSessionFlowControlStreamId, msg_data_size));
+ scoped_ptr<SpdyFrame> echo(spdy_util_.ConstructSpdyBodyFrame(
+ 1, msg_data.data(), msg_data_size, false));
+ scoped_ptr<SpdyFrame> window_update(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, 0, 4) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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);
@@ -3296,9 +3242,8 @@ TEST_P(SpdySessionTest, SessionFlowControlNoReceiveLeaks) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url(kStreamUrl);
- base::WeakPtr<SpdyStream> stream =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url, MEDIUM, BoundNetLog());
ASSERT_TRUE(stream.get() != NULL);
EXPECT_EQ(0u, stream->stream_id());
@@ -3345,22 +3290,20 @@ TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
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, NULL, 0));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
+ CreateMockWrite(*req, 0),
};
scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
MockRead reads[] = {
- CreateMockRead(*resp, 1),
- MockRead(ASYNC, 0, 2) // EOF
+ CreateMockRead(*resp, 1), MockRead(ASYNC, 0, 2) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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);
@@ -3371,9 +3314,8 @@ TEST_P(SpdySessionTest, SessionFlowControlNoSendLeaks) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url(kStreamUrl);
- base::WeakPtr<SpdyStream> stream =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url, MEDIUM, BoundNetLog());
ASSERT_TRUE(stream.get() != NULL);
EXPECT_EQ(0u, stream->stream_id());
@@ -3422,34 +3364,27 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
MockConnect connect_data(SYNCHRONOUS, OK);
- scoped_ptr<SpdyFrame> req(
- spdy_util_.ConstructSpdyPost(
- kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
- scoped_ptr<SpdyFrame> msg(
- spdy_util_.ConstructSpdyBodyFrame(
- 1, msg_data.data(), msg_data_size, false));
+ scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 1, msg_data_size, MEDIUM, NULL, 0));
+ scoped_ptr<SpdyFrame> msg(spdy_util_.ConstructSpdyBodyFrame(
+ 1, msg_data.data(), msg_data_size, false));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
- CreateMockWrite(*msg, 2),
+ CreateMockWrite(*req, 0), CreateMockWrite(*msg, 2),
};
scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
- scoped_ptr<SpdyFrame> echo(
- spdy_util_.ConstructSpdyBodyFrame(
- 1, msg_data.data(), msg_data_size, false));
- scoped_ptr<SpdyFrame> window_update(
- spdy_util_.ConstructSpdyWindowUpdate(
- kSessionFlowControlStreamId, msg_data_size));
+ scoped_ptr<SpdyFrame> echo(spdy_util_.ConstructSpdyBodyFrame(
+ 1, msg_data.data(), msg_data_size, false));
+ scoped_ptr<SpdyFrame> window_update(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), CreateMockRead(*echo, 3),
+ CreateMockRead(*window_update, 4), MockRead(ASYNC, 0, 5) // EOF
};
// Create SpdySession and SpdyStream and send the request.
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ 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);
@@ -3460,9 +3395,8 @@ TEST_P(SpdySessionTest, SessionFlowControlEndToEnd) {
CreateInsecureSpdySession(http_session_, key_, BoundNetLog());
GURL url(kStreamUrl);
- base::WeakPtr<SpdyStream> stream =
- CreateStreamSynchronously(SPDY_BIDIRECTIONAL_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
+ SPDY_BIDIRECTIONAL_STREAM, session, url, MEDIUM, BoundNetLog());
ASSERT_TRUE(stream.get() != NULL);
EXPECT_EQ(0u, stream->stream_id());
@@ -3546,27 +3480,23 @@ 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, NULL, 0));
scoped_ptr<SpdyFrame> body(
spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
MockWrite writes[] = {
- CreateMockWrite(*req, 0),
- CreateMockWrite(*body, 1),
+ CreateMockWrite(*req, 0), CreateMockWrite(*body, 1),
};
- scoped_ptr<SpdyFrame> resp(
- spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 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, 0, 3), // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
MockConnect connect_data(SYNCHRONOUS, OK);
data.set_connect_data(connect_data);
@@ -3578,9 +3508,8 @@ void SpdySessionTest::RunResumeAfterUnstallTest(
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
session->flow_control_state());
- base::WeakPtr<SpdyStream> stream =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(stream.get() != NULL);
test::StreamDelegateWithBody delegate(stream, kBodyDataStringPiece);
@@ -3624,10 +3553,8 @@ TEST_P(SpdySessionTest, ResumeAfterUnstallSession) {
return;
RunResumeAfterUnstallTest(
- base::Bind(&SpdySessionTest::StallSessionOnly,
- base::Unretained(this)),
- base::Bind(&SpdySessionTest::UnstallSessionOnly,
- base::Unretained(this)));
+ base::Bind(&SpdySessionTest::StallSessionOnly, base::Unretained(this)),
+ base::Bind(&SpdySessionTest::UnstallSessionOnly, base::Unretained(this)));
}
// Equivalent to
@@ -3637,10 +3564,8 @@ TEST_P(SpdySessionTest, ResumeAfterUnstallStream) {
return;
RunResumeAfterUnstallTest(
- base::Bind(&SpdySessionTest::StallStreamOnly,
- base::Unretained(this)),
- base::Bind(&SpdySessionTest::UnstallStreamOnly,
- base::Unretained(this)));
+ base::Bind(&SpdySessionTest::StallStreamOnly, base::Unretained(this)),
+ base::Bind(&SpdySessionTest::UnstallStreamOnly, base::Unretained(this)));
}
TEST_P(SpdySessionTest, StallSessionStreamResumeAfterUnstallSessionStream) {
@@ -3648,8 +3573,7 @@ TEST_P(SpdySessionTest, StallSessionStreamResumeAfterUnstallSessionStream) {
return;
RunResumeAfterUnstallTest(
- base::Bind(&SpdySessionTest::StallSessionStream,
- base::Unretained(this)),
+ base::Bind(&SpdySessionTest::StallSessionStream, base::Unretained(this)),
base::Bind(&SpdySessionTest::UnstallSessionStream,
base::Unretained(this)));
}
@@ -3659,8 +3583,7 @@ TEST_P(SpdySessionTest, StallStreamSessionResumeAfterUnstallSessionStream) {
return;
RunResumeAfterUnstallTest(
- base::Bind(&SpdySessionTest::StallStreamSession,
- base::Unretained(this)),
+ base::Bind(&SpdySessionTest::StallStreamSession, base::Unretained(this)),
base::Bind(&SpdySessionTest::UnstallSessionStream,
base::Unretained(this)));
}
@@ -3670,8 +3593,7 @@ TEST_P(SpdySessionTest, StallStreamSessionResumeAfterUnstallStreamSession) {
return;
RunResumeAfterUnstallTest(
- base::Bind(&SpdySessionTest::StallStreamSession,
- base::Unretained(this)),
+ base::Bind(&SpdySessionTest::StallStreamSession, base::Unretained(this)),
base::Bind(&SpdySessionTest::UnstallStreamSession,
base::Unretained(this)));
}
@@ -3681,8 +3603,7 @@ TEST_P(SpdySessionTest, StallSessionStreamResumeAfterUnstallStreamSession) {
return;
RunResumeAfterUnstallTest(
- base::Bind(&SpdySessionTest::StallSessionStream,
- base::Unretained(this)),
+ base::Bind(&SpdySessionTest::StallSessionStream, base::Unretained(this)),
base::Bind(&SpdySessionTest::UnstallStreamSession,
base::Unretained(this)));
}
@@ -3699,33 +3620,28 @@ 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, NULL, 0));
+ scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 3, kBodyDataSize, MEDIUM, NULL, 0));
scoped_ptr<SpdyFrame> body1(
spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, true));
scoped_ptr<SpdyFrame> body2(
spdy_util_.ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
- CreateMockWrite(*body2, 2),
- CreateMockWrite(*body1, 3),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
+ CreateMockWrite(*body2, 2), CreateMockWrite(*body1, 3),
};
scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 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, 0, 6), // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
MockConnect connect_data(SYNCHRONOUS, OK);
data.set_connect_data(connect_data);
@@ -3737,9 +3653,8 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
session->flow_control_state());
- base::WeakPtr<SpdyStream> stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(stream1.get() != NULL);
test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
@@ -3747,9 +3662,8 @@ TEST_P(SpdySessionTest, ResumeByPriorityAfterSendWindowSizeIncrease) {
EXPECT_FALSE(stream1->HasUrlFromHeaders());
- base::WeakPtr<SpdyStream> stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, MEDIUM, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, MEDIUM, BoundNetLog());
ASSERT_TRUE(stream2.get() != NULL);
test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
@@ -3853,32 +3767,26 @@ 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, 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> body2(
spdy_util_.ConstructSpdyBodyFrame(3, kBodyData, kBodyDataSize, true));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
- CreateMockWrite(*req3, 2),
- CreateMockWrite(*body2, 3),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
+ CreateMockWrite(*req3, 2), CreateMockWrite(*body2, 3),
};
scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
MockRead reads[] = {
- CreateMockRead(*resp2, 4),
- MockRead(ASYNC, 0, 0, 5), // EOF
+ CreateMockRead(*resp2, 4), MockRead(ASYNC, 0, 0, 5), // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
MockConnect connect_data(SYNCHRONOUS, OK);
data.set_connect_data(connect_data);
@@ -3890,9 +3798,8 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
session->flow_control_state());
- base::WeakPtr<SpdyStream> stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(stream1.get() != NULL);
test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
@@ -3900,9 +3807,8 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
EXPECT_FALSE(stream1->HasUrlFromHeaders());
- base::WeakPtr<SpdyStream> stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(stream2.get() != NULL);
StreamClosingDelegate delegate2(stream2, kBodyDataStringPiece);
@@ -3910,9 +3816,8 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedStreams) {
EXPECT_FALSE(stream2->HasUrlFromHeaders());
- base::WeakPtr<SpdyStream> stream3 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream3 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(stream3.get() != NULL);
test::StreamDelegateWithBody delegate3(stream3, kBodyDataStringPiece);
@@ -4015,25 +3920,22 @@ 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, NULL, 0));
+ scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyPost(
+ kStreamUrl, 3, kBodyDataSize, LOWEST, NULL, 0));
scoped_ptr<SpdyFrame> body1(
spdy_util_.ConstructSpdyBodyFrame(1, kBodyData, kBodyDataSize, false));
MockWrite writes[] = {
- CreateMockWrite(*req1, 0),
- CreateMockWrite(*req2, 1),
+ CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1),
};
MockRead reads[] = {
- MockRead(ASYNC, 0, 0, 2), // EOF
+ MockRead(ASYNC, 0, 0, 2), // EOF
};
- DeterministicSocketData data(reads, arraysize(reads),
- writes, arraysize(writes));
+ DeterministicSocketData data(
+ reads, arraysize(reads), writes, arraysize(writes));
MockConnect connect_data(SYNCHRONOUS, OK);
data.set_connect_data(connect_data);
@@ -4045,9 +3947,8 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION,
session->flow_control_state());
- base::WeakPtr<SpdyStream> stream1 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream1 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(stream1.get() != NULL);
test::StreamDelegateWithBody delegate1(stream1, kBodyDataStringPiece);
@@ -4055,9 +3956,8 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
EXPECT_FALSE(stream1->HasUrlFromHeaders());
- base::WeakPtr<SpdyStream> stream2 =
- CreateStreamSynchronously(SPDY_REQUEST_RESPONSE_STREAM,
- session, url, LOWEST, BoundNetLog());
+ base::WeakPtr<SpdyStream> stream2 = CreateStreamSynchronously(
+ SPDY_REQUEST_RESPONSE_STREAM, session, url, LOWEST, BoundNetLog());
ASSERT_TRUE(stream2.get() != NULL);
test::StreamDelegateWithBody delegate2(stream2, kBodyDataStringPiece);
@@ -4117,30 +4017,26 @@ TEST_P(SpdySessionTest, SendWindowSizeIncreaseWithDeletedSession) {
}
TEST(MapFramerErrorToProtocolError, MapsValues) {
- CHECK_EQ(SPDY_ERROR_INVALID_CONTROL_FRAME,
- MapFramerErrorToProtocolError(
- SpdyFramer::SPDY_INVALID_CONTROL_FRAME));
- CHECK_EQ(SPDY_ERROR_INVALID_DATA_FRAME_FLAGS,
- MapFramerErrorToProtocolError(
- SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS));
- CHECK_EQ(SPDY_ERROR_GOAWAY_FRAME_CORRUPT,
- MapFramerErrorToProtocolError(
- SpdyFramer::SPDY_GOAWAY_FRAME_CORRUPT));
+ CHECK_EQ(
+ SPDY_ERROR_INVALID_CONTROL_FRAME,
+ MapFramerErrorToProtocolError(SpdyFramer::SPDY_INVALID_CONTROL_FRAME));
+ CHECK_EQ(
+ SPDY_ERROR_INVALID_DATA_FRAME_FLAGS,
+ MapFramerErrorToProtocolError(SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS));
+ CHECK_EQ(
+ SPDY_ERROR_GOAWAY_FRAME_CORRUPT,
+ MapFramerErrorToProtocolError(SpdyFramer::SPDY_GOAWAY_FRAME_CORRUPT));
CHECK_EQ(SPDY_ERROR_UNEXPECTED_FRAME,
- MapFramerErrorToProtocolError(
- SpdyFramer::SPDY_UNEXPECTED_FRAME));
+ MapFramerErrorToProtocolError(SpdyFramer::SPDY_UNEXPECTED_FRAME));
}
TEST(MapRstStreamStatusToProtocolError, MapsValues) {
CHECK_EQ(STATUS_CODE_PROTOCOL_ERROR,
- MapRstStreamStatusToProtocolError(
- RST_STREAM_PROTOCOL_ERROR));
+ MapRstStreamStatusToProtocolError(RST_STREAM_PROTOCOL_ERROR));
CHECK_EQ(STATUS_CODE_FRAME_SIZE_ERROR,
- MapRstStreamStatusToProtocolError(
- RST_STREAM_FRAME_SIZE_ERROR));
+ MapRstStreamStatusToProtocolError(RST_STREAM_FRAME_SIZE_ERROR));
CHECK_EQ(STATUS_CODE_ENHANCE_YOUR_CALM,
- MapRstStreamStatusToProtocolError(
- RST_STREAM_ENHANCE_YOUR_CALM));
+ MapRstStreamStatusToProtocolError(RST_STREAM_ENHANCE_YOUR_CALM));
}
} // namespace net
« net/base/mime_util_unittest.cc ('K') | « net/spdy/spdy_session_test_util.cc ('k') | net/spdy/spdy_stream.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698