OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/spdy/spdy_session.h" | 5 #include "net/spdy/spdy_session.h" |
6 | 6 |
7 #include "base/base64.h" | 7 #include "base/base64.h" |
8 #include "base/bind.h" | 8 #include "base/bind.h" |
9 #include "base/callback.h" | 9 #include "base/callback.h" |
10 #include "base/memory/scoped_ptr.h" | 10 #include "base/memory/scoped_ptr.h" |
(...skipping 17 matching lines...) Expand all Loading... |
28 #include "net/spdy/spdy_stream_test_util.h" | 28 #include "net/spdy/spdy_stream_test_util.h" |
29 #include "net/spdy/spdy_test_util_common.h" | 29 #include "net/spdy/spdy_test_util_common.h" |
30 #include "net/spdy/spdy_test_utils.h" | 30 #include "net/spdy/spdy_test_utils.h" |
31 #include "net/test/cert_test_util.h" | 31 #include "net/test/cert_test_util.h" |
32 #include "testing/platform_test.h" | 32 #include "testing/platform_test.h" |
33 | 33 |
34 namespace net { | 34 namespace net { |
35 | 35 |
36 namespace { | 36 namespace { |
37 | 37 |
| 38 enum TestCase { |
| 39 // Test using the SPDY/3.1 protocol. |
| 40 kTestCaseSPDY31, |
| 41 |
| 42 // Test using the HTTP/2 protocol, without specifying a stream |
| 43 // dependency based on the RequestPriority. |
| 44 kTestCaseHTTP2NoPriorityDependencies, |
| 45 |
| 46 // Test using the HTTP/2 protocol, specifying a stream |
| 47 // dependency based on the RequestPriority. |
| 48 kTestCaseHTTP2PriorityDependencies |
| 49 }; |
| 50 |
38 const char kBodyData[] = "Body data"; | 51 const char kBodyData[] = "Body data"; |
39 const size_t kBodyDataSize = arraysize(kBodyData); | 52 const size_t kBodyDataSize = arraysize(kBodyData); |
40 const base::StringPiece kBodyDataStringPiece(kBodyData, kBodyDataSize); | 53 const base::StringPiece kBodyDataStringPiece(kBodyData, kBodyDataSize); |
41 | 54 |
42 static base::TimeDelta g_time_delta; | 55 static base::TimeDelta g_time_delta; |
43 static base::TimeTicks g_time_now; | 56 static base::TimeTicks g_time_now; |
44 | 57 |
45 base::TimeTicks TheNearFuture() { | 58 base::TimeTicks TheNearFuture() { |
46 return base::TimeTicks::Now() + g_time_delta; | 59 return base::TimeTicks::Now() + g_time_delta; |
47 } | 60 } |
48 | 61 |
49 base::TimeTicks SlowReads() { | 62 base::TimeTicks SlowReads() { |
50 g_time_delta += | 63 g_time_delta += |
51 base::TimeDelta::FromMilliseconds(2 * kYieldAfterDurationMilliseconds); | 64 base::TimeDelta::FromMilliseconds(2 * kYieldAfterDurationMilliseconds); |
52 return base::TimeTicks::Now() + g_time_delta; | 65 return base::TimeTicks::Now() + g_time_delta; |
53 } | 66 } |
54 | 67 |
55 base::TimeTicks InstantaneousReads() { | 68 base::TimeTicks InstantaneousReads() { |
56 return g_time_now; | 69 return g_time_now; |
57 } | 70 } |
58 | 71 |
59 } // namespace | 72 } // namespace |
60 | 73 |
61 class SpdySessionTest : public PlatformTest, | 74 class SpdySessionTest : public PlatformTest, |
62 public ::testing::WithParamInterface<NextProto> { | 75 public ::testing::WithParamInterface<TestCase> { |
63 public: | 76 public: |
64 // Functions used with RunResumeAfterUnstallTest(). | 77 // Functions used with RunResumeAfterUnstallTest(). |
65 | 78 |
66 void StallSessionOnly(SpdyStream* stream) { StallSessionSend(); } | 79 void StallSessionOnly(SpdyStream* stream) { StallSessionSend(); } |
67 | 80 |
68 void StallStreamOnly(SpdyStream* stream) { StallStreamSend(stream); } | 81 void StallStreamOnly(SpdyStream* stream) { StallStreamSend(stream); } |
69 | 82 |
70 void StallSessionStream(SpdyStream* stream) { | 83 void StallSessionStream(SpdyStream* stream) { |
71 StallSessionSend(); | 84 StallSessionSend(); |
72 StallStreamSend(stream); | 85 StallStreamSend(stream); |
(...skipping 16 matching lines...) Expand all Loading... |
89 UnstallSessionSend(delta_window_size); | 102 UnstallSessionSend(delta_window_size); |
90 UnstallStreamSend(stream, delta_window_size); | 103 UnstallStreamSend(stream, delta_window_size); |
91 } | 104 } |
92 | 105 |
93 void UnstallStreamSession(SpdyStream* stream, int32 delta_window_size) { | 106 void UnstallStreamSession(SpdyStream* stream, int32 delta_window_size) { |
94 UnstallStreamSend(stream, delta_window_size); | 107 UnstallStreamSend(stream, delta_window_size); |
95 UnstallSessionSend(delta_window_size); | 108 UnstallSessionSend(delta_window_size); |
96 } | 109 } |
97 | 110 |
98 protected: | 111 protected: |
| 112 NextProto GetProtocol() const { |
| 113 return GetParam() == kTestCaseSPDY31 ? kProtoSPDY31 : kProtoHTTP2; |
| 114 } |
| 115 |
| 116 bool GetDependenciesFromPriority() const { |
| 117 return GetParam() == kTestCaseHTTP2PriorityDependencies; |
| 118 } |
| 119 |
99 SpdySessionTest() | 120 SpdySessionTest() |
100 : old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group( | 121 : old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group( |
101 HttpNetworkSession::NORMAL_SOCKET_POOL)), | 122 HttpNetworkSession::NORMAL_SOCKET_POOL)), |
102 old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool( | 123 old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool( |
103 HttpNetworkSession::NORMAL_SOCKET_POOL)), | 124 HttpNetworkSession::NORMAL_SOCKET_POOL)), |
104 spdy_util_(GetParam()), | 125 spdy_util_(GetProtocol(), GetDependenciesFromPriority()), |
105 session_deps_(GetParam()), | 126 session_deps_(GetProtocol()), |
106 spdy_session_pool_(nullptr), | 127 spdy_session_pool_(nullptr), |
107 test_url_(kDefaultURL), | 128 test_url_(kDefaultURL), |
108 test_host_port_pair_(HostPortPair::FromURL(test_url_)), | 129 test_host_port_pair_(HostPortPair::FromURL(test_url_)), |
109 key_(test_host_port_pair_, | 130 key_(test_host_port_pair_, |
110 ProxyServer::Direct(), | 131 ProxyServer::Direct(), |
111 PRIVACY_MODE_DISABLED) {} | 132 PRIVACY_MODE_DISABLED) { |
| 133 SpdySession::SetPriorityDependencyDefaultForTesting( |
| 134 GetDependenciesFromPriority()); |
| 135 } |
112 | 136 |
113 virtual ~SpdySessionTest() { | 137 virtual ~SpdySessionTest() { |
114 // Important to restore the per-pool limit first, since the pool limit must | 138 // Important to restore the per-pool limit first, since the pool limit must |
115 // always be greater than group limit, and the tests reduce both limits. | 139 // always be greater than group limit, and the tests reduce both limits. |
116 ClientSocketPoolManager::set_max_sockets_per_pool( | 140 ClientSocketPoolManager::set_max_sockets_per_pool( |
117 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_); | 141 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_); |
118 ClientSocketPoolManager::set_max_sockets_per_group( | 142 ClientSocketPoolManager::set_max_sockets_per_group( |
119 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_); | 143 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_); |
| 144 SpdySession::SetPriorityDependencyDefaultForTesting(false); |
120 } | 145 } |
121 | 146 |
122 void SetUp() override { | 147 void SetUp() override { |
123 g_time_delta = base::TimeDelta(); | 148 g_time_delta = base::TimeDelta(); |
124 g_time_now = base::TimeTicks::Now(); | 149 g_time_now = base::TimeTicks::Now(); |
125 session_deps_.net_log = log_.bound().net_log(); | 150 session_deps_.net_log = log_.bound().net_log(); |
126 } | 151 } |
127 | 152 |
128 void CreateNetworkSession() { | 153 void CreateNetworkSession() { |
129 DCHECK(!http_session_); | 154 DCHECK(!http_session_); |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
176 SpdySessionDependencies session_deps_; | 201 SpdySessionDependencies session_deps_; |
177 scoped_ptr<HttpNetworkSession> http_session_; | 202 scoped_ptr<HttpNetworkSession> http_session_; |
178 base::WeakPtr<SpdySession> session_; | 203 base::WeakPtr<SpdySession> session_; |
179 SpdySessionPool* spdy_session_pool_; | 204 SpdySessionPool* spdy_session_pool_; |
180 GURL test_url_; | 205 GURL test_url_; |
181 HostPortPair test_host_port_pair_; | 206 HostPortPair test_host_port_pair_; |
182 SpdySessionKey key_; | 207 SpdySessionKey key_; |
183 BoundTestNetLog log_; | 208 BoundTestNetLog log_; |
184 }; | 209 }; |
185 | 210 |
186 INSTANTIATE_TEST_CASE_P(NextProto, | 211 INSTANTIATE_TEST_CASE_P(ProtoPlusDepend, |
187 SpdySessionTest, | 212 SpdySessionTest, |
188 testing::Values(kProtoSPDY31, | 213 testing::Values(kTestCaseSPDY31, |
189 kProtoHTTP2)); | 214 kTestCaseHTTP2NoPriorityDependencies, |
| 215 kTestCaseHTTP2PriorityDependencies)); |
190 | 216 |
191 // Try to create a SPDY session that will fail during | 217 // Try to create a SPDY session that will fail during |
192 // initialization. Nothing should blow up. | 218 // initialization. Nothing should blow up. |
193 TEST_P(SpdySessionTest, InitialReadError) { | 219 TEST_P(SpdySessionTest, InitialReadError) { |
194 CreateNetworkSession(); | 220 CreateNetworkSession(); |
195 | 221 |
196 session_ = TryCreateFakeSpdySessionExpectingFailure(spdy_session_pool_, key_, | 222 session_ = TryCreateFakeSpdySessionExpectingFailure(spdy_session_pool_, key_, |
197 ERR_CONNECTION_CLOSED); | 223 ERR_CONNECTION_CLOSED); |
198 EXPECT_TRUE(session_); | 224 EXPECT_TRUE(session_); |
199 // Flush the read. | 225 // Flush the read. |
(...skipping 1011 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1211 // Verify that there is one unclaimed push stream. | 1237 // Verify that there is one unclaimed push stream. |
1212 EXPECT_EQ(1u, session_->num_unclaimed_pushed_streams()); | 1238 EXPECT_EQ(1u, session_->num_unclaimed_pushed_streams()); |
1213 SpdySession::PushedStreamMap::iterator iter = | 1239 SpdySession::PushedStreamMap::iterator iter = |
1214 session_->unclaimed_pushed_streams_.find( | 1240 session_->unclaimed_pushed_streams_.find( |
1215 GURL("http://www.example.org/a.dat")); | 1241 GURL("http://www.example.org/a.dat")); |
1216 EXPECT_TRUE(session_->unclaimed_pushed_streams_.end() != iter); | 1242 EXPECT_TRUE(session_->unclaimed_pushed_streams_.end() != iter); |
1217 | 1243 |
1218 if (session_->flow_control_state_ == | 1244 if (session_->flow_control_state_ == |
1219 SpdySession::FLOW_CONTROL_STREAM_AND_SESSION) { | 1245 SpdySession::FLOW_CONTROL_STREAM_AND_SESSION) { |
1220 // Unclaimed push body consumed bytes from the session window. | 1246 // Unclaimed push body consumed bytes from the session window. |
1221 EXPECT_EQ( | 1247 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()) - |
1222 SpdySession::GetDefaultInitialWindowSize(GetParam()) - kUploadDataSize, | 1248 kUploadDataSize, |
1223 session_->session_recv_window_size_); | 1249 session_->session_recv_window_size_); |
1224 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); | 1250 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); |
1225 } | 1251 } |
1226 | 1252 |
1227 // Shift time to expire the push stream. Read the second SYN_STREAM, | 1253 // Shift time to expire the push stream. Read the second SYN_STREAM, |
1228 // and verify a RST_STREAM was written. | 1254 // and verify a RST_STREAM was written. |
1229 g_time_delta = base::TimeDelta::FromSeconds(301); | 1255 g_time_delta = base::TimeDelta::FromSeconds(301); |
1230 data.CompleteRead(); | 1256 data.CompleteRead(); |
1231 base::RunLoop().RunUntilIdle(); | 1257 base::RunLoop().RunUntilIdle(); |
1232 | 1258 |
1233 // Verify that the second pushed stream evicted the first pushed stream. | 1259 // Verify that the second pushed stream evicted the first pushed stream. |
1234 EXPECT_EQ(1u, session_->num_unclaimed_pushed_streams()); | 1260 EXPECT_EQ(1u, session_->num_unclaimed_pushed_streams()); |
1235 iter = session_->unclaimed_pushed_streams_.find( | 1261 iter = session_->unclaimed_pushed_streams_.find( |
1236 GURL("http://www.example.org/0.dat")); | 1262 GURL("http://www.example.org/0.dat")); |
1237 EXPECT_TRUE(session_->unclaimed_pushed_streams_.end() != iter); | 1263 EXPECT_TRUE(session_->unclaimed_pushed_streams_.end() != iter); |
1238 | 1264 |
1239 if (session_->flow_control_state_ == | 1265 if (session_->flow_control_state_ == |
1240 SpdySession::FLOW_CONTROL_STREAM_AND_SESSION) { | 1266 SpdySession::FLOW_CONTROL_STREAM_AND_SESSION) { |
1241 // Verify that the session window reclaimed the evicted stream body. | 1267 // Verify that the session window reclaimed the evicted stream body. |
1242 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()), | 1268 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()), |
1243 session_->session_recv_window_size_); | 1269 session_->session_recv_window_size_); |
1244 EXPECT_EQ(kUploadDataSize, session_->session_unacked_recv_window_bytes_); | 1270 EXPECT_EQ(kUploadDataSize, session_->session_unacked_recv_window_bytes_); |
1245 } | 1271 } |
1246 | 1272 |
1247 // Read and process EOF. | 1273 // Read and process EOF. |
1248 EXPECT_TRUE(session_); | 1274 EXPECT_TRUE(session_); |
1249 data.CompleteRead(); | 1275 data.CompleteRead(); |
1250 base::RunLoop().RunUntilIdle(); | 1276 base::RunLoop().RunUntilIdle(); |
1251 EXPECT_FALSE(session_); | 1277 EXPECT_FALSE(session_); |
1252 } | 1278 } |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1308 // sure nothing blows up. This is a regression test for | 1334 // sure nothing blows up. This is a regression test for |
1309 // http://crbug.com/57331 . | 1335 // http://crbug.com/57331 . |
1310 TEST_P(SpdySessionTest, OnSettings) { | 1336 TEST_P(SpdySessionTest, OnSettings) { |
1311 session_deps_.host_resolver->set_synchronous_mode(true); | 1337 session_deps_.host_resolver->set_synchronous_mode(true); |
1312 | 1338 |
1313 const SpdySettingsIds kSpdySettingsIds = SETTINGS_MAX_CONCURRENT_STREAMS; | 1339 const SpdySettingsIds kSpdySettingsIds = SETTINGS_MAX_CONCURRENT_STREAMS; |
1314 | 1340 |
1315 int seq = 0; | 1341 int seq = 0; |
1316 std::vector<MockWrite> writes; | 1342 std::vector<MockWrite> writes; |
1317 scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck()); | 1343 scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck()); |
1318 if (GetParam() == kProtoHTTP2) { | 1344 if (GetProtocol() == kProtoHTTP2) { |
1319 writes.push_back(CreateMockWrite(*settings_ack, ++seq)); | 1345 writes.push_back(CreateMockWrite(*settings_ack, ++seq)); |
1320 } | 1346 } |
1321 | 1347 |
1322 SettingsMap new_settings; | 1348 SettingsMap new_settings; |
1323 const uint32 max_concurrent_streams = kInitialMaxConcurrentStreams + 1; | 1349 const uint32 max_concurrent_streams = kInitialMaxConcurrentStreams + 1; |
1324 new_settings[kSpdySettingsIds] = | 1350 new_settings[kSpdySettingsIds] = |
1325 SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams); | 1351 SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams); |
1326 scoped_ptr<SpdyFrame> settings_frame( | 1352 scoped_ptr<SpdyFrame> settings_frame( |
1327 spdy_util_.ConstructSpdySettings(new_settings)); | 1353 spdy_util_.ConstructSpdySettings(new_settings)); |
1328 MockRead reads[] = { | 1354 MockRead reads[] = { |
(...skipping 176 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1505 MockRead reads[] = { | 1531 MockRead reads[] = { |
1506 MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever. | 1532 MockRead(SYNCHRONOUS, ERR_IO_PENDING) // Stall forever. |
1507 }; | 1533 }; |
1508 | 1534 |
1509 SettingsMap settings; | 1535 SettingsMap settings; |
1510 settings[SETTINGS_MAX_CONCURRENT_STREAMS] = | 1536 settings[SETTINGS_MAX_CONCURRENT_STREAMS] = |
1511 SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams); | 1537 SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams); |
1512 scoped_ptr<SpdyFrame> settings_frame( | 1538 scoped_ptr<SpdyFrame> settings_frame( |
1513 spdy_util_.ConstructSpdySettings(settings)); | 1539 spdy_util_.ConstructSpdySettings(settings)); |
1514 std::vector<MockWrite> writes; | 1540 std::vector<MockWrite> writes; |
1515 if (GetParam() == kProtoHTTP2) { | 1541 if (GetProtocol() == kProtoHTTP2) { |
1516 writes.push_back( | 1542 writes.push_back( |
1517 MockWrite(ASYNC, | 1543 MockWrite(ASYNC, |
1518 kHttp2ConnectionHeaderPrefix, | 1544 kHttp2ConnectionHeaderPrefix, |
1519 kHttp2ConnectionHeaderPrefixSize)); | 1545 kHttp2ConnectionHeaderPrefixSize)); |
1520 } | 1546 } |
1521 writes.push_back(CreateMockWrite(*settings_frame)); | 1547 writes.push_back(CreateMockWrite(*settings_frame)); |
1522 | 1548 |
1523 SettingsMap server_settings; | 1549 SettingsMap server_settings; |
1524 const uint32 initial_max_concurrent_streams = 1; | 1550 const uint32 initial_max_concurrent_streams = 1; |
1525 server_settings[SETTINGS_MAX_CONCURRENT_STREAMS] = | 1551 server_settings[SETTINGS_MAX_CONCURRENT_STREAMS] = |
1526 SettingsFlagsAndValue(SETTINGS_FLAG_PERSISTED, | 1552 SettingsFlagsAndValue(SETTINGS_FLAG_PERSISTED, |
1527 initial_max_concurrent_streams); | 1553 initial_max_concurrent_streams); |
1528 scoped_ptr<SpdyFrame> server_settings_frame( | 1554 scoped_ptr<SpdyFrame> server_settings_frame( |
1529 spdy_util_.ConstructSpdySettings(server_settings)); | 1555 spdy_util_.ConstructSpdySettings(server_settings)); |
1530 if (GetParam() <= kProtoSPDY31) { | 1556 if (GetProtocol() <= kProtoSPDY31) { |
1531 writes.push_back(CreateMockWrite(*server_settings_frame)); | 1557 writes.push_back(CreateMockWrite(*server_settings_frame)); |
1532 } | 1558 } |
1533 | 1559 |
1534 StaticSocketDataProvider data(reads, arraysize(reads), | 1560 StaticSocketDataProvider data(reads, arraysize(reads), |
1535 vector_as_array(&writes), writes.size()); | 1561 vector_as_array(&writes), writes.size()); |
1536 session_deps_.socket_factory->AddSocketDataProvider(&data); | 1562 session_deps_.socket_factory->AddSocketDataProvider(&data); |
1537 | 1563 |
1538 CreateNetworkSession(); | 1564 CreateNetworkSession(); |
1539 | 1565 |
1540 spdy_session_pool_->http_server_properties()->SetSpdySetting( | 1566 spdy_session_pool_->http_server_properties()->SetSpdySetting( |
(...skipping 84 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1625 base::RunLoop().RunUntilIdle(); | 1651 base::RunLoop().RunUntilIdle(); |
1626 | 1652 |
1627 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); | 1653 EXPECT_FALSE(HasSpdySession(spdy_session_pool_, key_)); |
1628 EXPECT_FALSE(session_); | 1654 EXPECT_FALSE(session_); |
1629 | 1655 |
1630 // Check that the NetLog was filled reasonably. | 1656 // Check that the NetLog was filled reasonably. |
1631 TestNetLogEntry::List entries; | 1657 TestNetLogEntry::List entries; |
1632 log_.GetEntries(&entries); | 1658 log_.GetEntries(&entries); |
1633 EXPECT_LT(0u, entries.size()); | 1659 EXPECT_LT(0u, entries.size()); |
1634 | 1660 |
1635 if (GetParam() == kProtoHTTP2) { | 1661 if (GetProtocol() == kProtoHTTP2) { |
1636 int pos = ExpectLogContainsSomewhere( | 1662 int pos = ExpectLogContainsSomewhere( |
1637 entries, 0, NetLog::TYPE_HTTP2_SESSION_GOAWAY, NetLog::PHASE_NONE); | 1663 entries, 0, NetLog::TYPE_HTTP2_SESSION_GOAWAY, NetLog::PHASE_NONE); |
1638 TestNetLogEntry entry = entries[pos]; | 1664 TestNetLogEntry entry = entries[pos]; |
1639 int last_accepted_stream_id; | 1665 int last_accepted_stream_id; |
1640 ASSERT_TRUE(entry.GetIntegerValue("last_accepted_stream_id", | 1666 ASSERT_TRUE(entry.GetIntegerValue("last_accepted_stream_id", |
1641 &last_accepted_stream_id)); | 1667 &last_accepted_stream_id)); |
1642 EXPECT_EQ(42, last_accepted_stream_id); | 1668 EXPECT_EQ(42, last_accepted_stream_id); |
1643 int active_streams; | 1669 int active_streams; |
1644 ASSERT_TRUE(entry.GetIntegerValue("active_streams", &active_streams)); | 1670 ASSERT_TRUE(entry.GetIntegerValue("active_streams", &active_streams)); |
1645 EXPECT_EQ(0, active_streams); | 1671 EXPECT_EQ(0, active_streams); |
(...skipping 663 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2309 // this file. | 2335 // this file. |
2310 SettingsMap new_settings; | 2336 SettingsMap new_settings; |
2311 const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS; | 2337 const SpdySettingsIds kSpdySettingsIds1 = SETTINGS_MAX_CONCURRENT_STREAMS; |
2312 const uint32 max_concurrent_streams = 1; | 2338 const uint32 max_concurrent_streams = 1; |
2313 new_settings[kSpdySettingsIds1] = | 2339 new_settings[kSpdySettingsIds1] = |
2314 SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams); | 2340 SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams); |
2315 | 2341 |
2316 scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck()); | 2342 scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck()); |
2317 scoped_ptr<SpdyFrame> req1( | 2343 scoped_ptr<SpdyFrame> req1( |
2318 spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true)); | 2344 spdy_util_.ConstructSpdyGet(nullptr, 0, false, 1, LOWEST, true)); |
| 2345 spdy_util_.UpdateWithStreamDestruction(1); |
2319 scoped_ptr<SpdyFrame> req2( | 2346 scoped_ptr<SpdyFrame> req2( |
2320 spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, LOWEST, true)); | 2347 spdy_util_.ConstructSpdyGet(nullptr, 0, false, 3, LOWEST, true)); |
| 2348 spdy_util_.UpdateWithStreamDestruction(3); |
2321 scoped_ptr<SpdyFrame> req3( | 2349 scoped_ptr<SpdyFrame> req3( |
2322 spdy_util_.ConstructSpdyGet(nullptr, 0, false, 5, LOWEST, true)); | 2350 spdy_util_.ConstructSpdyGet(nullptr, 0, false, 5, LOWEST, true)); |
2323 MockWrite writes[] = { | 2351 MockWrite writes[] = { |
2324 CreateMockWrite(*settings_ack, 1), | 2352 CreateMockWrite(*settings_ack, 1), |
2325 CreateMockWrite(*req1, 2), | 2353 CreateMockWrite(*req1, 2), |
2326 CreateMockWrite(*req2, 5), | 2354 CreateMockWrite(*req2, 5), |
2327 CreateMockWrite(*req3, 8), | 2355 CreateMockWrite(*req3, 8), |
2328 }; | 2356 }; |
2329 | 2357 |
2330 // Set up the socket so we read a SETTINGS frame that sets max concurrent | 2358 // Set up the socket so we read a SETTINGS frame that sets max concurrent |
(...skipping 681 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3012 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); | 3040 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); |
3013 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3041 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3014 | 3042 |
3015 CreateNetworkSession(); | 3043 CreateNetworkSession(); |
3016 session_ = CreateFakeSpdySession(spdy_session_pool_, key_); | 3044 session_ = CreateFakeSpdySession(spdy_session_pool_, key_); |
3017 | 3045 |
3018 EXPECT_EQ(spdy_util_.spdy_version(), | 3046 EXPECT_EQ(spdy_util_.spdy_version(), |
3019 session_->buffered_spdy_framer_->protocol_version()); | 3047 session_->buffered_spdy_framer_->protocol_version()); |
3020 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, | 3048 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, |
3021 session_->flow_control_state()); | 3049 session_->flow_control_state()); |
3022 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()), | 3050 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()), |
3023 session_->session_send_window_size_); | 3051 session_->session_send_window_size_); |
3024 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()), | 3052 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()), |
3025 session_->session_recv_window_size_); | 3053 session_->session_recv_window_size_); |
3026 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); | 3054 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); |
3027 } | 3055 } |
3028 | 3056 |
3029 // Tests the case of a non-SPDY request closing an idle SPDY session when no | 3057 // Tests the case of a non-SPDY request closing an idle SPDY session when no |
3030 // pointers to the idle session are currently held. | 3058 // pointers to the idle session are currently held. |
3031 TEST_P(SpdySessionTest, CloseOneIdleConnection) { | 3059 TEST_P(SpdySessionTest, CloseOneIdleConnection) { |
3032 ClientSocketPoolManager::set_max_sockets_per_group( | 3060 ClientSocketPoolManager::set_max_sockets_per_group( |
3033 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); | 3061 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); |
3034 ClientSocketPoolManager::set_max_sockets_per_pool( | 3062 ClientSocketPoolManager::set_max_sockets_per_pool( |
(...skipping 380 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3415 } | 3443 } |
3416 | 3444 |
3417 // SpdySession::{Increase,Decrease}RecvWindowSize should properly | 3445 // SpdySession::{Increase,Decrease}RecvWindowSize should properly |
3418 // adjust the session receive window size. In addition, | 3446 // adjust the session receive window size. In addition, |
3419 // SpdySession::IncreaseRecvWindowSize should trigger | 3447 // SpdySession::IncreaseRecvWindowSize should trigger |
3420 // sending a WINDOW_UPDATE frame for a large enough delta. | 3448 // sending a WINDOW_UPDATE frame for a large enough delta. |
3421 TEST_P(SpdySessionTest, AdjustRecvWindowSize) { | 3449 TEST_P(SpdySessionTest, AdjustRecvWindowSize) { |
3422 session_deps_.host_resolver->set_synchronous_mode(true); | 3450 session_deps_.host_resolver->set_synchronous_mode(true); |
3423 | 3451 |
3424 const int32 initial_window_size = | 3452 const int32 initial_window_size = |
3425 SpdySession::GetDefaultInitialWindowSize(GetParam()); | 3453 SpdySession::GetDefaultInitialWindowSize(GetProtocol()); |
3426 const int32 delta_window_size = 100; | 3454 const int32 delta_window_size = 100; |
3427 | 3455 |
3428 MockRead reads[] = { | 3456 MockRead reads[] = { |
3429 MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF | 3457 MockRead(ASYNC, ERR_IO_PENDING, 1), MockRead(ASYNC, 0, 2) // EOF |
3430 }; | 3458 }; |
3431 scoped_ptr<SpdyFrame> window_update(spdy_util_.ConstructSpdyWindowUpdate( | 3459 scoped_ptr<SpdyFrame> window_update(spdy_util_.ConstructSpdyWindowUpdate( |
3432 kSessionFlowControlStreamId, initial_window_size + delta_window_size)); | 3460 kSessionFlowControlStreamId, initial_window_size + delta_window_size)); |
3433 MockWrite writes[] = { | 3461 MockWrite writes[] = { |
3434 CreateMockWrite(*window_update, 0), | 3462 CreateMockWrite(*window_update, 0), |
3435 }; | 3463 }; |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3482 }; | 3510 }; |
3483 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); | 3511 StaticSocketDataProvider data(reads, arraysize(reads), nullptr, 0); |
3484 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3512 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3485 | 3513 |
3486 CreateNetworkSession(); | 3514 CreateNetworkSession(); |
3487 session_ = CreateFakeSpdySession(spdy_session_pool_, key_); | 3515 session_ = CreateFakeSpdySession(spdy_session_pool_, key_); |
3488 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, | 3516 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, |
3489 session_->flow_control_state()); | 3517 session_->flow_control_state()); |
3490 | 3518 |
3491 const int32 initial_window_size = | 3519 const int32 initial_window_size = |
3492 SpdySession::GetDefaultInitialWindowSize(GetParam()); | 3520 SpdySession::GetDefaultInitialWindowSize(GetProtocol()); |
3493 const int32 delta_window_size = 100; | 3521 const int32 delta_window_size = 100; |
3494 | 3522 |
3495 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); | 3523 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); |
3496 | 3524 |
3497 session_->IncreaseSendWindowSize(delta_window_size); | 3525 session_->IncreaseSendWindowSize(delta_window_size); |
3498 EXPECT_EQ(initial_window_size + delta_window_size, | 3526 EXPECT_EQ(initial_window_size + delta_window_size, |
3499 session_->session_send_window_size_); | 3527 session_->session_send_window_size_); |
3500 | 3528 |
3501 session_->DecreaseSendWindowSize(delta_window_size); | 3529 session_->DecreaseSendWindowSize(delta_window_size); |
3502 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); | 3530 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); |
(...skipping 12 matching lines...) Expand all Loading... |
3515 MockRead(ASYNC, 0, 2) // EOF | 3543 MockRead(ASYNC, 0, 2) // EOF |
3516 }; | 3544 }; |
3517 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); | 3545 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); |
3518 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3546 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3519 | 3547 |
3520 CreateNetworkSession(); | 3548 CreateNetworkSession(); |
3521 CreateInsecureSpdySession(); | 3549 CreateInsecureSpdySession(); |
3522 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, | 3550 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, |
3523 session_->flow_control_state()); | 3551 session_->flow_control_state()); |
3524 | 3552 |
3525 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()), | 3553 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()), |
3526 session_->session_recv_window_size_); | 3554 session_->session_recv_window_size_); |
3527 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); | 3555 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); |
3528 | 3556 |
3529 base::RunLoop().RunUntilIdle(); | 3557 base::RunLoop().RunUntilIdle(); |
3530 | 3558 |
3531 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()), | 3559 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()), |
3532 session_->session_recv_window_size_); | 3560 session_->session_recv_window_size_); |
3533 EXPECT_EQ(kUploadDataSize, session_->session_unacked_recv_window_bytes_); | 3561 EXPECT_EQ(kUploadDataSize, session_->session_unacked_recv_window_bytes_); |
3534 | 3562 |
3535 EXPECT_TRUE(session_); | 3563 EXPECT_TRUE(session_); |
3536 data.CompleteRead(); | 3564 data.CompleteRead(); |
3537 base::RunLoop().RunUntilIdle(); | 3565 base::RunLoop().RunUntilIdle(); |
3538 EXPECT_FALSE(session_); | 3566 EXPECT_FALSE(session_); |
3539 } | 3567 } |
3540 | 3568 |
3541 // The frame header is not included in flow control, but frame payload | 3569 // The frame header is not included in flow control, but frame payload |
3542 // (including optional pad length and padding) is. | 3570 // (including optional pad length and padding) is. |
3543 TEST_P(SpdySessionTest, SessionFlowControlPadding) { | 3571 TEST_P(SpdySessionTest, SessionFlowControlPadding) { |
3544 // Padding only exists in HTTP/2. | 3572 // Padding only exists in HTTP/2. |
3545 if (GetParam() < kProtoHTTP2) | 3573 if (GetProtocol() < kProtoHTTP2) |
3546 return; | 3574 return; |
3547 | 3575 |
3548 session_deps_.host_resolver->set_synchronous_mode(true); | 3576 session_deps_.host_resolver->set_synchronous_mode(true); |
3549 | 3577 |
3550 const int padding_length = 42; | 3578 const int padding_length = 42; |
3551 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyBodyFrame( | 3579 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyBodyFrame( |
3552 1, kUploadData, kUploadDataSize, false, padding_length)); | 3580 1, kUploadData, kUploadDataSize, false, padding_length)); |
3553 MockRead reads[] = { | 3581 MockRead reads[] = { |
3554 CreateMockRead(*resp, 0), | 3582 CreateMockRead(*resp, 0), |
3555 MockRead(ASYNC, ERR_IO_PENDING, 1), | 3583 MockRead(ASYNC, ERR_IO_PENDING, 1), |
3556 MockRead(ASYNC, 0, 2) // EOF | 3584 MockRead(ASYNC, 0, 2) // EOF |
3557 }; | 3585 }; |
3558 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); | 3586 SequencedSocketData data(reads, arraysize(reads), nullptr, 0); |
3559 session_deps_.socket_factory->AddSocketDataProvider(&data); | 3587 session_deps_.socket_factory->AddSocketDataProvider(&data); |
3560 | 3588 |
3561 CreateNetworkSession(); | 3589 CreateNetworkSession(); |
3562 CreateInsecureSpdySession(); | 3590 CreateInsecureSpdySession(); |
3563 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, | 3591 EXPECT_EQ(SpdySession::FLOW_CONTROL_STREAM_AND_SESSION, |
3564 session_->flow_control_state()); | 3592 session_->flow_control_state()); |
3565 | 3593 |
3566 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()), | 3594 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()), |
3567 session_->session_recv_window_size_); | 3595 session_->session_recv_window_size_); |
3568 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); | 3596 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); |
3569 | 3597 |
3570 base::RunLoop().RunUntilIdle(); | 3598 base::RunLoop().RunUntilIdle(); |
3571 | 3599 |
3572 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetParam()), | 3600 EXPECT_EQ(SpdySession::GetDefaultInitialWindowSize(GetProtocol()), |
3573 session_->session_recv_window_size_); | 3601 session_->session_recv_window_size_); |
3574 EXPECT_EQ(kUploadDataSize + padding_length, | 3602 EXPECT_EQ(kUploadDataSize + padding_length, |
3575 session_->session_unacked_recv_window_bytes_); | 3603 session_->session_unacked_recv_window_bytes_); |
3576 | 3604 |
3577 data.CompleteRead(); | 3605 data.CompleteRead(); |
3578 base::RunLoop().RunUntilIdle(); | 3606 base::RunLoop().RunUntilIdle(); |
3579 EXPECT_FALSE(session_); | 3607 EXPECT_FALSE(session_); |
3580 } | 3608 } |
3581 | 3609 |
3582 // Peer sends more data than stream level receiving flow control window. | 3610 // Peer sends more data than stream level receiving flow control window. |
(...skipping 274 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3857 DropReceivedDataDelegate delegate(stream, msg_data); | 3885 DropReceivedDataDelegate delegate(stream, msg_data); |
3858 stream->SetDelegate(&delegate); | 3886 stream->SetDelegate(&delegate); |
3859 | 3887 |
3860 scoped_ptr<SpdyHeaderBlock> headers( | 3888 scoped_ptr<SpdyHeaderBlock> headers( |
3861 spdy_util_.ConstructPostHeaderBlock(kDefaultURL, msg_data_size)); | 3889 spdy_util_.ConstructPostHeaderBlock(kDefaultURL, msg_data_size)); |
3862 EXPECT_EQ(ERR_IO_PENDING, | 3890 EXPECT_EQ(ERR_IO_PENDING, |
3863 stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND)); | 3891 stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND)); |
3864 EXPECT_TRUE(stream->HasUrlFromHeaders()); | 3892 EXPECT_TRUE(stream->HasUrlFromHeaders()); |
3865 | 3893 |
3866 const int32 initial_window_size = | 3894 const int32 initial_window_size = |
3867 SpdySession::GetDefaultInitialWindowSize(GetParam()); | 3895 SpdySession::GetDefaultInitialWindowSize(GetProtocol()); |
3868 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); | 3896 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); |
3869 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); | 3897 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); |
3870 | 3898 |
3871 base::RunLoop().RunUntilIdle(); | 3899 base::RunLoop().RunUntilIdle(); |
3872 | 3900 |
3873 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); | 3901 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); |
3874 EXPECT_EQ(msg_data_size, session_->session_unacked_recv_window_bytes_); | 3902 EXPECT_EQ(msg_data_size, session_->session_unacked_recv_window_bytes_); |
3875 | 3903 |
3876 stream->Close(); | 3904 stream->Close(); |
3877 EXPECT_FALSE(stream); | 3905 EXPECT_FALSE(stream); |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3923 test::StreamDelegateSendImmediate delegate(stream, msg_data); | 3951 test::StreamDelegateSendImmediate delegate(stream, msg_data); |
3924 stream->SetDelegate(&delegate); | 3952 stream->SetDelegate(&delegate); |
3925 | 3953 |
3926 scoped_ptr<SpdyHeaderBlock> headers( | 3954 scoped_ptr<SpdyHeaderBlock> headers( |
3927 spdy_util_.ConstructPostHeaderBlock(kDefaultURL, msg_data_size)); | 3955 spdy_util_.ConstructPostHeaderBlock(kDefaultURL, msg_data_size)); |
3928 EXPECT_EQ(ERR_IO_PENDING, | 3956 EXPECT_EQ(ERR_IO_PENDING, |
3929 stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND)); | 3957 stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND)); |
3930 EXPECT_TRUE(stream->HasUrlFromHeaders()); | 3958 EXPECT_TRUE(stream->HasUrlFromHeaders()); |
3931 | 3959 |
3932 const int32 initial_window_size = | 3960 const int32 initial_window_size = |
3933 SpdySession::GetDefaultInitialWindowSize(GetParam()); | 3961 SpdySession::GetDefaultInitialWindowSize(GetProtocol()); |
3934 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); | 3962 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); |
3935 | 3963 |
3936 // Write request. | 3964 // Write request. |
3937 base::RunLoop().RunUntilIdle(); | 3965 base::RunLoop().RunUntilIdle(); |
3938 | 3966 |
3939 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); | 3967 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); |
3940 | 3968 |
3941 // Read response, but do not run the message loop, so that the body is not | 3969 // Read response, but do not run the message loop, so that the body is not |
3942 // written to the socket. | 3970 // written to the socket. |
3943 data.CompleteRead(); | 3971 data.CompleteRead(); |
(...skipping 66 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
4010 test::StreamDelegateSendImmediate delegate(stream, msg_data); | 4038 test::StreamDelegateSendImmediate delegate(stream, msg_data); |
4011 stream->SetDelegate(&delegate); | 4039 stream->SetDelegate(&delegate); |
4012 | 4040 |
4013 scoped_ptr<SpdyHeaderBlock> headers( | 4041 scoped_ptr<SpdyHeaderBlock> headers( |
4014 spdy_util_.ConstructPostHeaderBlock(kDefaultURL, msg_data_size)); | 4042 spdy_util_.ConstructPostHeaderBlock(kDefaultURL, msg_data_size)); |
4015 EXPECT_EQ(ERR_IO_PENDING, | 4043 EXPECT_EQ(ERR_IO_PENDING, |
4016 stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND)); | 4044 stream->SendRequestHeaders(headers.Pass(), MORE_DATA_TO_SEND)); |
4017 EXPECT_TRUE(stream->HasUrlFromHeaders()); | 4045 EXPECT_TRUE(stream->HasUrlFromHeaders()); |
4018 | 4046 |
4019 const int32 initial_window_size = | 4047 const int32 initial_window_size = |
4020 SpdySession::GetDefaultInitialWindowSize(GetParam()); | 4048 SpdySession::GetDefaultInitialWindowSize(GetProtocol()); |
4021 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); | 4049 EXPECT_EQ(initial_window_size, session_->session_send_window_size_); |
4022 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); | 4050 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); |
4023 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); | 4051 EXPECT_EQ(0, session_->session_unacked_recv_window_bytes_); |
4024 | 4052 |
4025 // Send request and message. | 4053 // Send request and message. |
4026 base::RunLoop().RunUntilIdle(); | 4054 base::RunLoop().RunUntilIdle(); |
4027 | 4055 |
4028 EXPECT_EQ(initial_window_size - msg_data_size, | 4056 EXPECT_EQ(initial_window_size - msg_data_size, |
4029 session_->session_send_window_size_); | 4057 session_->session_send_window_size_); |
4030 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); | 4058 EXPECT_EQ(initial_window_size, session_->session_recv_window_size_); |
(...skipping 1156 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
5187 ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(), | 5215 ssl_info.cert = ImportCertFromFile(GetTestCertsDirectory(), |
5188 "spdy_pooling.pem"); | 5216 "spdy_pooling.pem"); |
5189 ssl_info.is_issued_by_known_root = true; | 5217 ssl_info.is_issued_by_known_root = true; |
5190 ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin)); | 5218 ssl_info.public_key_hashes.push_back(test::GetTestHashValue(primary_pin)); |
5191 | 5219 |
5192 EXPECT_TRUE(SpdySession::CanPool( | 5220 EXPECT_TRUE(SpdySession::CanPool( |
5193 &tss, ssl_info, "www.example.org", "mail.example.org")); | 5221 &tss, ssl_info, "www.example.org", "mail.example.org")); |
5194 } | 5222 } |
5195 | 5223 |
5196 } // namespace net | 5224 } // namespace net |
OLD | NEW |