OLD | NEW |
---|---|
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 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/http/http_network_transaction.h" | 5 #include "net/http/http_network_transaction.h" |
6 | 6 |
7 #include <math.h> // ceil | 7 #include <math.h> // ceil |
8 #include <stdarg.h> | 8 #include <stdarg.h> |
9 #include <stdint.h> | 9 #include <stdint.h> |
10 | 10 |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
85 #include "url/gurl.h" | 85 #include "url/gurl.h" |
86 | 86 |
87 using base::ASCIIToUTF16; | 87 using base::ASCIIToUTF16; |
88 | 88 |
89 //----------------------------------------------------------------------------- | 89 //----------------------------------------------------------------------------- |
90 | 90 |
91 namespace net { | 91 namespace net { |
92 | 92 |
93 namespace { | 93 namespace { |
94 | 94 |
95 enum TestCase { | |
96 // Test using the SPDY 3.1 protocol. | |
97 kTestCaseSPDY31, | |
98 | |
99 // Test using the HTTP2 protocol, without specifying a stream | |
100 // dependency based on the RequestPriority. | |
101 kTestCaseHTTP2NoPriorityDependencies, | |
102 | |
103 // Test using the HTTP2 protocol, specifying a stream | |
104 // dependency based on the RequestPriority. | |
105 kTestCaseHTTP2PriorityDependencies | |
106 }; | |
107 | |
95 const base::string16 kBar(ASCIIToUTF16("bar")); | 108 const base::string16 kBar(ASCIIToUTF16("bar")); |
96 const base::string16 kBar2(ASCIIToUTF16("bar2")); | 109 const base::string16 kBar2(ASCIIToUTF16("bar2")); |
97 const base::string16 kBar3(ASCIIToUTF16("bar3")); | 110 const base::string16 kBar3(ASCIIToUTF16("bar3")); |
98 const base::string16 kBaz(ASCIIToUTF16("baz")); | 111 const base::string16 kBaz(ASCIIToUTF16("baz")); |
99 const base::string16 kFirst(ASCIIToUTF16("first")); | 112 const base::string16 kFirst(ASCIIToUTF16("first")); |
100 const base::string16 kFoo(ASCIIToUTF16("foo")); | 113 const base::string16 kFoo(ASCIIToUTF16("foo")); |
101 const base::string16 kFoo2(ASCIIToUTF16("foo2")); | 114 const base::string16 kFoo2(ASCIIToUTF16("foo2")); |
102 const base::string16 kFoo3(ASCIIToUTF16("foo3")); | 115 const base::string16 kFoo3(ASCIIToUTF16("foo3")); |
103 const base::string16 kFou(ASCIIToUTF16("fou")); | 116 const base::string16 kFou(ASCIIToUTF16("fou")); |
104 const base::string16 kSecond(ASCIIToUTF16("second")); | 117 const base::string16 kSecond(ASCIIToUTF16("second")); |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
234 | 247 |
235 scoped_ptr<HttpNetworkSession> CreateSession( | 248 scoped_ptr<HttpNetworkSession> CreateSession( |
236 SpdySessionDependencies* session_deps) { | 249 SpdySessionDependencies* session_deps) { |
237 return SpdySessionDependencies::SpdyCreateSession(session_deps); | 250 return SpdySessionDependencies::SpdyCreateSession(session_deps); |
238 } | 251 } |
239 | 252 |
240 } // namespace | 253 } // namespace |
241 | 254 |
242 class HttpNetworkTransactionTest | 255 class HttpNetworkTransactionTest |
243 : public PlatformTest, | 256 : public PlatformTest, |
244 public ::testing::WithParamInterface<NextProto> { | 257 public ::testing::WithParamInterface<TestCase> { |
245 public: | 258 public: |
246 virtual ~HttpNetworkTransactionTest() { | 259 virtual ~HttpNetworkTransactionTest() { |
247 // Important to restore the per-pool limit first, since the pool limit must | 260 // Important to restore the per-pool limit first, since the pool limit must |
248 // always be greater than group limit, and the tests reduce both limits. | 261 // always be greater than group limit, and the tests reduce both limits. |
249 ClientSocketPoolManager::set_max_sockets_per_pool( | 262 ClientSocketPoolManager::set_max_sockets_per_pool( |
250 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_); | 263 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_pool_sockets_); |
251 ClientSocketPoolManager::set_max_sockets_per_group( | 264 ClientSocketPoolManager::set_max_sockets_per_group( |
252 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_); | 265 HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_group_sockets_); |
266 SpdySession::SetPriorityDependencyDefaultForTesting(false); | |
253 } | 267 } |
254 | 268 |
255 protected: | 269 protected: |
256 HttpNetworkTransactionTest() | 270 HttpNetworkTransactionTest() |
257 : spdy_util_(GetParam()), | 271 : spdy_util_(GetProtocol(), GetDependenciesFromPriority()), |
258 session_deps_(GetParam()), | 272 session_deps_(GetProtocol()), |
259 old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group( | 273 old_max_group_sockets_(ClientSocketPoolManager::max_sockets_per_group( |
260 HttpNetworkSession::NORMAL_SOCKET_POOL)), | 274 HttpNetworkSession::NORMAL_SOCKET_POOL)), |
261 old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool( | 275 old_max_pool_sockets_(ClientSocketPoolManager::max_sockets_per_pool( |
262 HttpNetworkSession::NORMAL_SOCKET_POOL)) { | 276 HttpNetworkSession::NORMAL_SOCKET_POOL)) { |
277 SpdySession::SetPriorityDependencyDefaultForTesting( | |
278 GetDependenciesFromPriority()); | |
263 } | 279 } |
264 | 280 |
265 struct SimpleGetHelperResult { | 281 struct SimpleGetHelperResult { |
266 int rv; | 282 int rv; |
267 std::string status_line; | 283 std::string status_line; |
268 std::string response_data; | 284 std::string response_data; |
269 int64_t total_received_bytes; | 285 int64_t total_received_bytes; |
270 int64_t total_sent_bytes; | 286 int64_t total_sent_bytes; |
271 LoadTimingInfo load_timing_info; | 287 LoadTimingInfo load_timing_info; |
272 ConnectionAttempts connection_attempts; | 288 ConnectionAttempts connection_attempts; |
273 IPEndPoint remote_endpoint_after_start; | 289 IPEndPoint remote_endpoint_after_start; |
274 }; | 290 }; |
275 | 291 |
276 void SetUp() override { | 292 void SetUp() override { |
277 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); | 293 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
278 base::MessageLoop::current()->RunUntilIdle(); | 294 base::MessageLoop::current()->RunUntilIdle(); |
279 } | 295 } |
280 | 296 |
281 void TearDown() override { | 297 void TearDown() override { |
282 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); | 298 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
283 base::MessageLoop::current()->RunUntilIdle(); | 299 base::MessageLoop::current()->RunUntilIdle(); |
284 // Empty the current queue. | 300 // Empty the current queue. |
285 base::MessageLoop::current()->RunUntilIdle(); | 301 base::MessageLoop::current()->RunUntilIdle(); |
286 PlatformTest::TearDown(); | 302 PlatformTest::TearDown(); |
287 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); | 303 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
288 base::MessageLoop::current()->RunUntilIdle(); | 304 base::MessageLoop::current()->RunUntilIdle(); |
289 } | 305 } |
290 | 306 |
307 NextProto GetProtocol() const { | |
308 return GetParam() == kTestCaseSPDY31 ? kProtoSPDY31 : kProtoHTTP2; | |
309 } | |
310 | |
311 bool GetDependenciesFromPriority() const { | |
312 return GetParam() == kTestCaseHTTP2PriorityDependencies; | |
313 } | |
314 | |
291 const char* GetAlternateProtocolFromParam() { | 315 const char* GetAlternateProtocolFromParam() { |
292 return | 316 return AlternateProtocolToString( |
293 AlternateProtocolToString(AlternateProtocolFromNextProto(GetParam())); | 317 AlternateProtocolFromNextProto(GetProtocol())); |
294 } | 318 } |
295 | 319 |
296 std::string GetAlternativeServiceHttpHeader() { | 320 std::string GetAlternativeServiceHttpHeader() { |
297 return std::string("Alt-Svc: ") + GetAlternateProtocolFromParam() + | 321 return std::string("Alt-Svc: ") + GetAlternateProtocolFromParam() + |
298 "=\"www.example.com:443\"\r\n"; | 322 "=\"www.example.com:443\"\r\n"; |
299 } | 323 } |
300 | 324 |
301 std::string GetAlternateProtocolHttpHeader() { | 325 std::string GetAlternateProtocolHttpHeader() { |
302 return std::string("Alternate-Protocol: 443:") + | 326 return std::string("Alternate-Protocol: 443:") + |
303 GetAlternateProtocolFromParam() + "\r\n"; | 327 GetAlternateProtocolFromParam() + "\r\n"; |
(...skipping 135 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
439 | 463 |
440 SpdyTestUtil spdy_util_; | 464 SpdyTestUtil spdy_util_; |
441 SpdySessionDependencies session_deps_; | 465 SpdySessionDependencies session_deps_; |
442 | 466 |
443 // Original socket limits. Some tests set these. Safest to always restore | 467 // Original socket limits. Some tests set these. Safest to always restore |
444 // them once each test has been run. | 468 // them once each test has been run. |
445 int old_max_group_sockets_; | 469 int old_max_group_sockets_; |
446 int old_max_pool_sockets_; | 470 int old_max_pool_sockets_; |
447 }; | 471 }; |
448 | 472 |
449 INSTANTIATE_TEST_CASE_P(NextProto, | 473 INSTANTIATE_TEST_CASE_P(ProtoPlusDepend, |
450 HttpNetworkTransactionTest, | 474 HttpNetworkTransactionTest, |
451 testing::Values(kProtoSPDY31, | 475 testing::Values(kTestCaseSPDY31, |
452 kProtoHTTP2)); | 476 kTestCaseHTTP2NoPriorityDependencies, |
477 kTestCaseHTTP2PriorityDependencies)); | |
453 | 478 |
454 namespace { | 479 namespace { |
455 | 480 |
456 class BeforeNetworkStartHandler { | 481 class BeforeNetworkStartHandler { |
457 public: | 482 public: |
458 explicit BeforeNetworkStartHandler(bool defer) | 483 explicit BeforeNetworkStartHandler(bool defer) |
459 : defer_on_before_network_start_(defer), | 484 : defer_on_before_network_start_(defer), |
460 observed_before_network_start_(false) {} | 485 observed_before_network_start_(false) {} |
461 | 486 |
462 void OnBeforeNetworkStart(bool* defer) { | 487 void OnBeforeNetworkStart(bool* defer) { |
(...skipping 930 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1393 request.url = GURL("https://www.foo.com/"); | 1418 request.url = GURL("https://www.foo.com/"); |
1394 request.load_flags = 0; | 1419 request.load_flags = 0; |
1395 | 1420 |
1396 TestNetLog net_log; | 1421 TestNetLog net_log; |
1397 session_deps_.net_log = &net_log; | 1422 session_deps_.net_log = &net_log; |
1398 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 1423 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
1399 | 1424 |
1400 SSLSocketDataProvider ssl1(ASYNC, OK); | 1425 SSLSocketDataProvider ssl1(ASYNC, OK); |
1401 SSLSocketDataProvider ssl2(ASYNC, OK); | 1426 SSLSocketDataProvider ssl2(ASYNC, OK); |
1402 if (use_spdy) { | 1427 if (use_spdy) { |
1403 ssl1.SetNextProto(GetParam()); | 1428 ssl1.SetNextProto(GetProtocol()); |
1404 ssl2.SetNextProto(GetParam()); | 1429 ssl2.SetNextProto(GetProtocol()); |
1405 } | 1430 } |
1406 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); | 1431 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); |
1407 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 1432 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
1408 | 1433 |
1409 // SPDY versions of the request and response. | 1434 // SPDY versions of the request and response. |
1410 scoped_ptr<SpdyFrame> spdy_request(spdy_util_.ConstructSpdyGet( | 1435 scoped_ptr<SpdyFrame> spdy_request(spdy_util_.ConstructSpdyGet( |
1411 request.url.spec().c_str(), false, 1, DEFAULT_PRIORITY)); | 1436 request.url.spec().c_str(), false, 1, DEFAULT_PRIORITY)); |
1412 scoped_ptr<SpdyFrame> spdy_response( | 1437 scoped_ptr<SpdyFrame> spdy_response( |
1413 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 1438 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
1414 scoped_ptr<SpdyFrame> spdy_data( | 1439 scoped_ptr<SpdyFrame> spdy_data( |
(...skipping 2631 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4046 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 4071 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
4047 MockRead spdy_reads[] = { | 4072 MockRead spdy_reads[] = { |
4048 CreateMockRead(*resp, 1), CreateMockRead(*data, 2), MockRead(ASYNC, 0, 3), | 4073 CreateMockRead(*resp, 1), CreateMockRead(*data, 2), MockRead(ASYNC, 0, 3), |
4049 }; | 4074 }; |
4050 | 4075 |
4051 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4076 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4052 arraysize(spdy_writes)); | 4077 arraysize(spdy_writes)); |
4053 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4078 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4054 | 4079 |
4055 SSLSocketDataProvider ssl(ASYNC, OK); | 4080 SSLSocketDataProvider ssl(ASYNC, OK); |
4056 ssl.SetNextProto(GetParam()); | 4081 ssl.SetNextProto(GetProtocol()); |
4057 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4082 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4058 | 4083 |
4059 TestCompletionCallback callback1; | 4084 TestCompletionCallback callback1; |
4060 | 4085 |
4061 scoped_ptr<HttpTransaction> trans( | 4086 scoped_ptr<HttpTransaction> trans( |
4062 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 4087 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
4063 | 4088 |
4064 int rv = trans->Start(&request, callback1.callback(), log.bound()); | 4089 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
4065 EXPECT_EQ(ERR_IO_PENDING, rv); | 4090 EXPECT_EQ(ERR_IO_PENDING, rv); |
4066 | 4091 |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4106 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 4131 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
4107 MockRead spdy_reads[] = { | 4132 MockRead spdy_reads[] = { |
4108 CreateMockRead(*resp, 1), CreateMockRead(*data, 2), MockRead(ASYNC, 0, 3), | 4133 CreateMockRead(*resp, 1), CreateMockRead(*data, 2), MockRead(ASYNC, 0, 3), |
4109 }; | 4134 }; |
4110 | 4135 |
4111 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4136 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4112 arraysize(spdy_writes)); | 4137 arraysize(spdy_writes)); |
4113 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4138 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4114 | 4139 |
4115 SSLSocketDataProvider ssl(ASYNC, OK); | 4140 SSLSocketDataProvider ssl(ASYNC, OK); |
4116 ssl.SetNextProto(GetParam()); | 4141 ssl.SetNextProto(GetProtocol()); |
4117 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4142 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4118 | 4143 |
4119 TestCompletionCallback callback1; | 4144 TestCompletionCallback callback1; |
4120 | 4145 |
4121 scoped_ptr<HttpTransaction> trans( | 4146 scoped_ptr<HttpTransaction> trans( |
4122 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 4147 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
4123 | 4148 |
4124 // Stall the hostname resolution begun by the transaction. | 4149 // Stall the hostname resolution begun by the transaction. |
4125 session_deps_.host_resolver->set_synchronous_mode(false); | 4150 session_deps_.host_resolver->set_synchronous_mode(false); |
4126 session_deps_.host_resolver->set_ondemand_mode(true); | 4151 session_deps_.host_resolver->set_ondemand_mode(true); |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4163 // Configure against https proxy server "myproxy:70". | 4188 // Configure against https proxy server "myproxy:70". |
4164 session_deps_.proxy_service = ProxyService::CreateFixed("https://myproxy:70"); | 4189 session_deps_.proxy_service = ProxyService::CreateFixed("https://myproxy:70"); |
4165 BoundTestNetLog log; | 4190 BoundTestNetLog log; |
4166 session_deps_.net_log = log.bound().net_log(); | 4191 session_deps_.net_log = log.bound().net_log(); |
4167 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 4192 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
4168 | 4193 |
4169 // The first request will be a bare GET, the second request will be a | 4194 // The first request will be a bare GET, the second request will be a |
4170 // GET with a Proxy-Authorization header. | 4195 // GET with a Proxy-Authorization header. |
4171 scoped_ptr<SpdyFrame> req_get( | 4196 scoped_ptr<SpdyFrame> req_get( |
4172 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, false)); | 4197 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, false)); |
4198 spdy_util_.UpdateWithStreamDestruction(1); | |
4173 const char* const kExtraAuthorizationHeaders[] = { | 4199 const char* const kExtraAuthorizationHeaders[] = { |
4174 "proxy-authorization", "Basic Zm9vOmJhcg==" | 4200 "proxy-authorization", "Basic Zm9vOmJhcg==" |
4175 }; | 4201 }; |
4176 scoped_ptr<SpdyFrame> req_get_authorization( | 4202 scoped_ptr<SpdyFrame> req_get_authorization( |
4177 spdy_util_.ConstructSpdyGet(kExtraAuthorizationHeaders, | 4203 spdy_util_.ConstructSpdyGet(kExtraAuthorizationHeaders, |
4178 arraysize(kExtraAuthorizationHeaders) / 2, | 4204 arraysize(kExtraAuthorizationHeaders) / 2, |
4179 false, | 4205 false, |
4180 3, | 4206 3, |
4181 LOWEST, | 4207 LOWEST, |
4182 false)); | 4208 false)); |
(...skipping 23 matching lines...) Expand all Loading... | |
4206 CreateMockRead(*resp_data, 4), | 4232 CreateMockRead(*resp_data, 4), |
4207 CreateMockRead(*body_data, 5), | 4233 CreateMockRead(*body_data, 5), |
4208 MockRead(ASYNC, 0, 6), | 4234 MockRead(ASYNC, 0, 6), |
4209 }; | 4235 }; |
4210 | 4236 |
4211 SequencedSocketData data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4237 SequencedSocketData data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4212 arraysize(spdy_writes)); | 4238 arraysize(spdy_writes)); |
4213 session_deps_.socket_factory->AddSocketDataProvider(&data); | 4239 session_deps_.socket_factory->AddSocketDataProvider(&data); |
4214 | 4240 |
4215 SSLSocketDataProvider ssl(ASYNC, OK); | 4241 SSLSocketDataProvider ssl(ASYNC, OK); |
4216 ssl.SetNextProto(GetParam()); | 4242 ssl.SetNextProto(GetProtocol()); |
4217 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4243 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4218 | 4244 |
4219 TestCompletionCallback callback1; | 4245 TestCompletionCallback callback1; |
4220 | 4246 |
4221 scoped_ptr<HttpTransaction> trans( | 4247 scoped_ptr<HttpTransaction> trans( |
4222 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 4248 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
4223 | 4249 |
4224 int rv = trans->Start(&request, callback1.callback(), log.bound()); | 4250 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
4225 EXPECT_EQ(ERR_IO_PENDING, rv); | 4251 EXPECT_EQ(ERR_IO_PENDING, rv); |
4226 | 4252 |
(...skipping 76 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4303 CreateMockRead(*wrapped_body, 4, ASYNC), | 4329 CreateMockRead(*wrapped_body, 4, ASYNC), |
4304 CreateMockRead(*wrapped_body, 5, ASYNC), | 4330 CreateMockRead(*wrapped_body, 5, ASYNC), |
4305 MockRead(ASYNC, 0, 7), | 4331 MockRead(ASYNC, 0, 7), |
4306 }; | 4332 }; |
4307 | 4333 |
4308 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4334 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4309 arraysize(spdy_writes)); | 4335 arraysize(spdy_writes)); |
4310 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4336 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4311 | 4337 |
4312 SSLSocketDataProvider ssl(ASYNC, OK); | 4338 SSLSocketDataProvider ssl(ASYNC, OK); |
4313 ssl.SetNextProto(GetParam()); | 4339 ssl.SetNextProto(GetProtocol()); |
4314 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4340 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4315 SSLSocketDataProvider ssl2(ASYNC, OK); | 4341 SSLSocketDataProvider ssl2(ASYNC, OK); |
4316 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 4342 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
4317 | 4343 |
4318 TestCompletionCallback callback1; | 4344 TestCompletionCallback callback1; |
4319 | 4345 |
4320 int rv = trans->Start(&request, callback1.callback(), log.bound()); | 4346 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
4321 EXPECT_EQ(ERR_IO_PENDING, rv); | 4347 EXPECT_EQ(ERR_IO_PENDING, rv); |
4322 | 4348 |
4323 rv = callback1.WaitForResult(); | 4349 rv = callback1.WaitForResult(); |
4324 ASSERT_EQ(OK, rv); | 4350 ASSERT_EQ(OK, rv); |
4325 | 4351 |
4326 LoadTimingInfo load_timing_info; | 4352 LoadTimingInfo load_timing_info; |
4327 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info)); | 4353 EXPECT_TRUE(trans->GetLoadTimingInfo(&load_timing_info)); |
4328 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES); | 4354 TestLoadTimingNotReused(load_timing_info, CONNECT_TIMING_HAS_SSL_TIMES); |
4329 | 4355 |
4330 const HttpResponseInfo* response = trans->GetResponseInfo(); | 4356 const HttpResponseInfo* response = trans->GetResponseInfo(); |
4331 ASSERT_TRUE(response != NULL); | 4357 ASSERT_TRUE(response != NULL); |
4332 ASSERT_TRUE(response->headers.get() != NULL); | 4358 ASSERT_TRUE(response->headers.get() != NULL); |
4333 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); | 4359 EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine()); |
4334 | 4360 |
4335 std::string response_data; | 4361 std::string response_data; |
4336 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 4362 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
4337 EXPECT_EQ("1234567890", response_data); | 4363 EXPECT_EQ("1234567890", response_data); |
4338 } | 4364 } |
4339 | 4365 |
4340 // Test a SPDY CONNECT through an HTTPS Proxy to a SPDY server. | 4366 // Test a SPDY CONNECT through an HTTPS Proxy to a SPDY server. |
4341 TEST_P(HttpNetworkTransactionTest, HttpsProxySpdyConnectSpdy) { | 4367 TEST_P(HttpNetworkTransactionTest, HttpsProxySpdyConnectSpdy) { |
4368 SpdyTestUtil spdy_util_wrapped(GetProtocol(), GetDependenciesFromPriority()); | |
4369 | |
4342 HttpRequestInfo request; | 4370 HttpRequestInfo request; |
4343 request.method = "GET"; | 4371 request.method = "GET"; |
4344 request.url = GURL("https://www.example.org/"); | 4372 request.url = GURL("https://www.example.org/"); |
4345 request.load_flags = 0; | 4373 request.load_flags = 0; |
4346 | 4374 |
4347 // Configure against https proxy server "proxy:70". | 4375 // Configure against https proxy server "proxy:70". |
4348 session_deps_.proxy_service = ProxyService::CreateFixed("https://proxy:70"); | 4376 session_deps_.proxy_service = ProxyService::CreateFixed("https://proxy:70"); |
4349 BoundTestNetLog log; | 4377 BoundTestNetLog log; |
4350 session_deps_.net_log = log.bound().net_log(); | 4378 session_deps_.net_log = log.bound().net_log(); |
4351 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 4379 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
4352 | 4380 |
4353 scoped_ptr<HttpTransaction> trans( | 4381 scoped_ptr<HttpTransaction> trans( |
4354 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 4382 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
4355 | 4383 |
4356 // CONNECT to www.example.org:443 via SPDY | 4384 // CONNECT to www.example.org:443 via SPDY |
4357 scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect( | 4385 scoped_ptr<SpdyFrame> connect(spdy_util_.ConstructSpdyConnect( |
4358 NULL, 0, 1, LOWEST, HostPortPair("www.example.org", 443))); | 4386 NULL, 0, 1, LOWEST, HostPortPair("www.example.org", 443))); |
4359 // fetch https://www.example.org/ via SPDY | 4387 // fetch https://www.example.org/ via SPDY |
4360 const char kMyUrl[] = "https://www.example.org/"; | 4388 const char kMyUrl[] = "https://www.example.org/"; |
4361 scoped_ptr<SpdyFrame> get( | 4389 scoped_ptr<SpdyFrame> get( |
4362 spdy_util_.ConstructSpdyGet(kMyUrl, false, 1, LOWEST)); | 4390 spdy_util_wrapped.ConstructSpdyGet(kMyUrl, false, 1, LOWEST)); |
4363 scoped_ptr<SpdyFrame> wrapped_get( | 4391 scoped_ptr<SpdyFrame> wrapped_get( |
4364 spdy_util_.ConstructWrappedSpdyFrame(get, 1)); | 4392 spdy_util_.ConstructWrappedSpdyFrame(get, 1)); |
4365 scoped_ptr<SpdyFrame> conn_resp( | 4393 scoped_ptr<SpdyFrame> conn_resp( |
4366 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 4394 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
4367 scoped_ptr<SpdyFrame> get_resp( | 4395 scoped_ptr<SpdyFrame> get_resp( |
4368 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 4396 spdy_util_wrapped.ConstructSpdyGetSynReply(NULL, 0, 1)); |
4369 scoped_ptr<SpdyFrame> wrapped_get_resp( | 4397 scoped_ptr<SpdyFrame> wrapped_get_resp( |
4370 spdy_util_.ConstructWrappedSpdyFrame(get_resp, 1)); | 4398 spdy_util_.ConstructWrappedSpdyFrame(get_resp, 1)); |
4371 scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 4399 scoped_ptr<SpdyFrame> body(spdy_util_wrapped.ConstructSpdyBodyFrame(1, true)); |
4372 scoped_ptr<SpdyFrame> wrapped_body( | 4400 scoped_ptr<SpdyFrame> wrapped_body( |
4373 spdy_util_.ConstructWrappedSpdyFrame(body, 1)); | 4401 spdy_util_.ConstructWrappedSpdyFrame(body, 1)); |
4374 scoped_ptr<SpdyFrame> window_update_get_resp( | 4402 scoped_ptr<SpdyFrame> window_update_get_resp( |
4375 spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp->size())); | 4403 spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp->size())); |
4376 scoped_ptr<SpdyFrame> window_update_body( | 4404 scoped_ptr<SpdyFrame> window_update_body( |
4377 spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_body->size())); | 4405 spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_body->size())); |
4378 | 4406 |
4379 MockWrite spdy_writes[] = { | 4407 MockWrite spdy_writes[] = { |
4380 CreateMockWrite(*connect, 0), | 4408 CreateMockWrite(*connect, 0), |
4381 CreateMockWrite(*wrapped_get, 2), | 4409 CreateMockWrite(*wrapped_get, 2), |
4382 CreateMockWrite(*window_update_get_resp, 6), | 4410 CreateMockWrite(*window_update_get_resp, 6), |
4383 CreateMockWrite(*window_update_body, 7), | 4411 CreateMockWrite(*window_update_body, 7), |
4384 }; | 4412 }; |
4385 | 4413 |
4386 MockRead spdy_reads[] = { | 4414 MockRead spdy_reads[] = { |
4387 CreateMockRead(*conn_resp, 1, ASYNC), | 4415 CreateMockRead(*conn_resp, 1, ASYNC), |
4388 MockRead(ASYNC, ERR_IO_PENDING, 3), | 4416 MockRead(ASYNC, ERR_IO_PENDING, 3), |
4389 CreateMockRead(*wrapped_get_resp, 4, ASYNC), | 4417 CreateMockRead(*wrapped_get_resp, 4, ASYNC), |
4390 CreateMockRead(*wrapped_body, 5, ASYNC), | 4418 CreateMockRead(*wrapped_body, 5, ASYNC), |
4391 MockRead(ASYNC, 0, 8), | 4419 MockRead(ASYNC, 0, 8), |
4392 }; | 4420 }; |
4393 | 4421 |
4394 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4422 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4395 arraysize(spdy_writes)); | 4423 arraysize(spdy_writes)); |
4396 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4424 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4397 | 4425 |
4398 SSLSocketDataProvider ssl(ASYNC, OK); | 4426 SSLSocketDataProvider ssl(ASYNC, OK); |
4399 ssl.SetNextProto(GetParam()); | 4427 ssl.SetNextProto(GetProtocol()); |
4400 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4428 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4401 SSLSocketDataProvider ssl2(ASYNC, OK); | 4429 SSLSocketDataProvider ssl2(ASYNC, OK); |
4402 ssl2.SetNextProto(GetParam()); | 4430 ssl2.SetNextProto(GetProtocol()); |
4403 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 4431 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
4404 | 4432 |
4405 TestCompletionCallback callback1; | 4433 TestCompletionCallback callback1; |
4406 | 4434 |
4407 int rv = trans->Start(&request, callback1.callback(), log.bound()); | 4435 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
4408 EXPECT_EQ(ERR_IO_PENDING, rv); | 4436 EXPECT_EQ(ERR_IO_PENDING, rv); |
4409 | 4437 |
4410 // Allow the SpdyProxyClientSocket's write callback to complete. | 4438 // Allow the SpdyProxyClientSocket's write callback to complete. |
4411 base::MessageLoop::current()->RunUntilIdle(); | 4439 base::MessageLoop::current()->RunUntilIdle(); |
4412 // Now allow the read of the response to complete. | 4440 // Now allow the read of the response to complete. |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4458 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 4486 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
4459 MockRead spdy_reads[] = { | 4487 MockRead spdy_reads[] = { |
4460 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), | 4488 CreateMockRead(*resp, 1, ASYNC), MockRead(ASYNC, 0, 3), |
4461 }; | 4489 }; |
4462 | 4490 |
4463 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4491 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4464 arraysize(spdy_writes)); | 4492 arraysize(spdy_writes)); |
4465 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4493 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4466 | 4494 |
4467 SSLSocketDataProvider ssl(ASYNC, OK); | 4495 SSLSocketDataProvider ssl(ASYNC, OK); |
4468 ssl.SetNextProto(GetParam()); | 4496 ssl.SetNextProto(GetProtocol()); |
4469 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4497 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4470 SSLSocketDataProvider ssl2(ASYNC, OK); | 4498 SSLSocketDataProvider ssl2(ASYNC, OK); |
4471 ssl2.SetNextProto(GetParam()); | 4499 ssl2.SetNextProto(GetProtocol()); |
4472 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 4500 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
4473 | 4501 |
4474 TestCompletionCallback callback1; | 4502 TestCompletionCallback callback1; |
4475 | 4503 |
4476 int rv = trans->Start(&request, callback1.callback(), log.bound()); | 4504 int rv = trans->Start(&request, callback1.callback(), log.bound()); |
4477 EXPECT_EQ(ERR_IO_PENDING, rv); | 4505 EXPECT_EQ(ERR_IO_PENDING, rv); |
4478 | 4506 |
4479 rv = callback1.WaitForResult(); | 4507 rv = callback1.WaitForResult(); |
4480 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); | 4508 EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv); |
4481 | 4509 |
(...skipping 40 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4522 spdy_util_.ConstructSpdyBodyFrame(1, resp1, strlen(resp1), false)); | 4550 spdy_util_.ConstructSpdyBodyFrame(1, resp1, strlen(resp1), false)); |
4523 scoped_ptr<SpdyFrame> wrapped_body1( | 4551 scoped_ptr<SpdyFrame> wrapped_body1( |
4524 spdy_util_.ConstructSpdyBodyFrame(1, "1", 1, false)); | 4552 spdy_util_.ConstructSpdyBodyFrame(1, "1", 1, false)); |
4525 scoped_ptr<SpdyFrame> window_update( | 4553 scoped_ptr<SpdyFrame> window_update( |
4526 spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp1->size())); | 4554 spdy_util_.ConstructSpdyWindowUpdate(1, wrapped_get_resp1->size())); |
4527 | 4555 |
4528 // CONNECT to mail.example.org:443 via SPDY. | 4556 // CONNECT to mail.example.org:443 via SPDY. |
4529 SpdyHeaderBlock connect2_block; | 4557 SpdyHeaderBlock connect2_block; |
4530 spdy_util_.MaybeAddVersionHeader(&connect2_block); | 4558 spdy_util_.MaybeAddVersionHeader(&connect2_block); |
4531 connect2_block[spdy_util_.GetMethodKey()] = "CONNECT"; | 4559 connect2_block[spdy_util_.GetMethodKey()] = "CONNECT"; |
4532 if (GetParam() == kProtoHTTP2) { | 4560 if (GetProtocol() == kProtoHTTP2) { |
4533 connect2_block[spdy_util_.GetHostKey()] = "mail.example.org:443"; | 4561 connect2_block[spdy_util_.GetHostKey()] = "mail.example.org:443"; |
4534 } else { | 4562 } else { |
4535 connect2_block[spdy_util_.GetHostKey()] = "mail.example.org"; | 4563 connect2_block[spdy_util_.GetHostKey()] = "mail.example.org"; |
4536 connect2_block[spdy_util_.GetPathKey()] = "mail.example.org:443"; | 4564 connect2_block[spdy_util_.GetPathKey()] = "mail.example.org:443"; |
4537 } | 4565 } |
4538 scoped_ptr<SpdyFrame> connect2( | 4566 scoped_ptr<SpdyFrame> connect2( |
4539 spdy_util_.ConstructSpdySyn(3, connect2_block, LOWEST, false, false)); | 4567 spdy_util_.ConstructSpdySyn(3, connect2_block, LOWEST, false, false)); |
4540 | 4568 |
4541 scoped_ptr<SpdyFrame> conn_resp2( | 4569 scoped_ptr<SpdyFrame> conn_resp2( |
4542 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); | 4570 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
(...skipping 27 matching lines...) Expand all Loading... | |
4570 CreateMockRead(*wrapped_get_resp2, 8, ASYNC), | 4598 CreateMockRead(*wrapped_get_resp2, 8, ASYNC), |
4571 CreateMockRead(*wrapped_body2, 9, ASYNC), | 4599 CreateMockRead(*wrapped_body2, 9, ASYNC), |
4572 MockRead(ASYNC, 0, 10), | 4600 MockRead(ASYNC, 0, 10), |
4573 }; | 4601 }; |
4574 | 4602 |
4575 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4603 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4576 arraysize(spdy_writes)); | 4604 arraysize(spdy_writes)); |
4577 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4605 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4578 | 4606 |
4579 SSLSocketDataProvider ssl(ASYNC, OK); | 4607 SSLSocketDataProvider ssl(ASYNC, OK); |
4580 ssl.SetNextProto(GetParam()); | 4608 ssl.SetNextProto(GetProtocol()); |
4581 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4609 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4582 SSLSocketDataProvider ssl2(ASYNC, OK); | 4610 SSLSocketDataProvider ssl2(ASYNC, OK); |
4583 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 4611 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
4584 SSLSocketDataProvider ssl3(ASYNC, OK); | 4612 SSLSocketDataProvider ssl3(ASYNC, OK); |
4585 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl3); | 4613 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl3); |
4586 | 4614 |
4587 TestCompletionCallback callback; | 4615 TestCompletionCallback callback; |
4588 | 4616 |
4589 scoped_ptr<HttpTransaction> trans( | 4617 scoped_ptr<HttpTransaction> trans( |
4590 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 4618 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4694 CreateMockRead(*wrapped_get_resp2, 6, ASYNC), | 4722 CreateMockRead(*wrapped_get_resp2, 6, ASYNC), |
4695 CreateMockRead(*wrapped_body2, 7, ASYNC), | 4723 CreateMockRead(*wrapped_body2, 7, ASYNC), |
4696 MockRead(ASYNC, 0, 8), | 4724 MockRead(ASYNC, 0, 8), |
4697 }; | 4725 }; |
4698 | 4726 |
4699 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4727 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4700 arraysize(spdy_writes)); | 4728 arraysize(spdy_writes)); |
4701 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4729 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4702 | 4730 |
4703 SSLSocketDataProvider ssl(ASYNC, OK); | 4731 SSLSocketDataProvider ssl(ASYNC, OK); |
4704 ssl.SetNextProto(GetParam()); | 4732 ssl.SetNextProto(GetProtocol()); |
4705 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4733 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4706 SSLSocketDataProvider ssl2(ASYNC, OK); | 4734 SSLSocketDataProvider ssl2(ASYNC, OK); |
4707 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 4735 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
4708 | 4736 |
4709 TestCompletionCallback callback; | 4737 TestCompletionCallback callback; |
4710 | 4738 |
4711 scoped_ptr<HttpTransaction> trans( | 4739 scoped_ptr<HttpTransaction> trans( |
4712 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 4740 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
4713 int rv = trans->Start(&request1, callback.callback(), BoundNetLog()); | 4741 int rv = trans->Start(&request1, callback.callback(), BoundNetLog()); |
4714 EXPECT_EQ(ERR_IO_PENDING, rv); | 4742 EXPECT_EQ(ERR_IO_PENDING, rv); |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
4770 | 4798 |
4771 // http://www.example.org/ | 4799 // http://www.example.org/ |
4772 scoped_ptr<SpdyHeaderBlock> headers( | 4800 scoped_ptr<SpdyHeaderBlock> headers( |
4773 spdy_util_.ConstructGetHeaderBlockForProxy("http://www.example.org/")); | 4801 spdy_util_.ConstructGetHeaderBlockForProxy("http://www.example.org/")); |
4774 scoped_ptr<SpdyFrame> get1( | 4802 scoped_ptr<SpdyFrame> get1( |
4775 spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true)); | 4803 spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true)); |
4776 scoped_ptr<SpdyFrame> get_resp1( | 4804 scoped_ptr<SpdyFrame> get_resp1( |
4777 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 4805 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
4778 scoped_ptr<SpdyFrame> body1( | 4806 scoped_ptr<SpdyFrame> body1( |
4779 spdy_util_.ConstructSpdyBodyFrame(1, "1", 1, true)); | 4807 spdy_util_.ConstructSpdyBodyFrame(1, "1", 1, true)); |
4808 spdy_util_.UpdateWithStreamDestruction(1); | |
4780 | 4809 |
4781 // http://mail.example.org/ | 4810 // http://mail.example.org/ |
4782 scoped_ptr<SpdyHeaderBlock> headers2( | 4811 scoped_ptr<SpdyHeaderBlock> headers2( |
4783 spdy_util_.ConstructGetHeaderBlockForProxy("http://mail.example.org/")); | 4812 spdy_util_.ConstructGetHeaderBlockForProxy("http://mail.example.org/")); |
4784 scoped_ptr<SpdyFrame> get2( | 4813 scoped_ptr<SpdyFrame> get2( |
4785 spdy_util_.ConstructSpdySyn(3, *headers2, LOWEST, false, true)); | 4814 spdy_util_.ConstructSpdySyn(3, *headers2, LOWEST, false, true)); |
4786 scoped_ptr<SpdyFrame> get_resp2( | 4815 scoped_ptr<SpdyFrame> get_resp2( |
4787 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); | 4816 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
4788 scoped_ptr<SpdyFrame> body2( | 4817 scoped_ptr<SpdyFrame> body2( |
4789 spdy_util_.ConstructSpdyBodyFrame(3, "22", 2, true)); | 4818 spdy_util_.ConstructSpdyBodyFrame(3, "22", 2, true)); |
4790 | 4819 |
4791 MockWrite spdy_writes[] = { | 4820 MockWrite spdy_writes[] = { |
4792 CreateMockWrite(*get1, 0), | 4821 CreateMockWrite(*get1, 0), |
4793 CreateMockWrite(*get2, 3), | 4822 CreateMockWrite(*get2, 3), |
4794 }; | 4823 }; |
4795 | 4824 |
4796 MockRead spdy_reads[] = { | 4825 MockRead spdy_reads[] = { |
4797 CreateMockRead(*get_resp1, 1, ASYNC), | 4826 CreateMockRead(*get_resp1, 1, ASYNC), |
4798 CreateMockRead(*body1, 2, ASYNC), | 4827 CreateMockRead(*body1, 2, ASYNC), |
4799 CreateMockRead(*get_resp2, 4, ASYNC), | 4828 CreateMockRead(*get_resp2, 4, ASYNC), |
4800 CreateMockRead(*body2, 5, ASYNC), | 4829 CreateMockRead(*body2, 5, ASYNC), |
4801 MockRead(ASYNC, 0, 6), | 4830 MockRead(ASYNC, 0, 6), |
4802 }; | 4831 }; |
4803 | 4832 |
4804 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 4833 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
4805 arraysize(spdy_writes)); | 4834 arraysize(spdy_writes)); |
4806 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 4835 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
4807 | 4836 |
4808 SSLSocketDataProvider ssl(ASYNC, OK); | 4837 SSLSocketDataProvider ssl(ASYNC, OK); |
4809 ssl.SetNextProto(GetParam()); | 4838 ssl.SetNextProto(GetProtocol()); |
4810 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 4839 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
4811 | 4840 |
4812 TestCompletionCallback callback; | 4841 TestCompletionCallback callback; |
4813 | 4842 |
4814 scoped_ptr<HttpTransaction> trans( | 4843 scoped_ptr<HttpTransaction> trans( |
4815 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 4844 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
4816 int rv = trans->Start(&request1, callback.callback(), BoundNetLog()); | 4845 int rv = trans->Start(&request1, callback.callback(), BoundNetLog()); |
4817 EXPECT_EQ(OK, callback.GetResult(rv)); | 4846 EXPECT_EQ(OK, callback.GetResult(rv)); |
4818 | 4847 |
4819 LoadTimingInfo load_timing_info; | 4848 LoadTimingInfo load_timing_info; |
(...skipping 2422 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7242 scoped_ptr<SpdyFrame> resp( | 7271 scoped_ptr<SpdyFrame> resp( |
7243 spdy_util_.ConstructSpdySynReplyError("302 Redirect", kExtraHeaders, | 7272 spdy_util_.ConstructSpdySynReplyError("302 Redirect", kExtraHeaders, |
7244 arraysize(kExtraHeaders)/2, 1)); | 7273 arraysize(kExtraHeaders)/2, 1)); |
7245 MockRead data_reads[] = { | 7274 MockRead data_reads[] = { |
7246 CreateMockRead(*resp.get(), 1), MockRead(ASYNC, 0, 3), // EOF | 7275 CreateMockRead(*resp.get(), 1), MockRead(ASYNC, 0, 3), // EOF |
7247 }; | 7276 }; |
7248 | 7277 |
7249 SequencedSocketData data(data_reads, arraysize(data_reads), data_writes, | 7278 SequencedSocketData data(data_reads, arraysize(data_reads), data_writes, |
7250 arraysize(data_writes)); | 7279 arraysize(data_writes)); |
7251 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy | 7280 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy |
7252 proxy_ssl.SetNextProto(GetParam()); | 7281 proxy_ssl.SetNextProto(GetProtocol()); |
7253 | 7282 |
7254 session_deps_.socket_factory->AddSocketDataProvider(&data); | 7283 session_deps_.socket_factory->AddSocketDataProvider(&data); |
7255 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); | 7284 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); |
7256 | 7285 |
7257 TestCompletionCallback callback; | 7286 TestCompletionCallback callback; |
7258 | 7287 |
7259 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 7288 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
7260 scoped_ptr<HttpTransaction> trans( | 7289 scoped_ptr<HttpTransaction> trans( |
7261 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 7290 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
7262 | 7291 |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7351 1, "The host does not exist", 23, true)); | 7380 1, "The host does not exist", 23, true)); |
7352 MockRead data_reads[] = { | 7381 MockRead data_reads[] = { |
7353 CreateMockRead(*resp.get(), 1), | 7382 CreateMockRead(*resp.get(), 1), |
7354 CreateMockRead(*body.get(), 2), | 7383 CreateMockRead(*body.get(), 2), |
7355 MockRead(ASYNC, 0, 4), // EOF | 7384 MockRead(ASYNC, 0, 4), // EOF |
7356 }; | 7385 }; |
7357 | 7386 |
7358 SequencedSocketData data(data_reads, arraysize(data_reads), data_writes, | 7387 SequencedSocketData data(data_reads, arraysize(data_reads), data_writes, |
7359 arraysize(data_writes)); | 7388 arraysize(data_writes)); |
7360 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy | 7389 SSLSocketDataProvider proxy_ssl(ASYNC, OK); // SSL to the proxy |
7361 proxy_ssl.SetNextProto(GetParam()); | 7390 proxy_ssl.SetNextProto(GetProtocol()); |
7362 | 7391 |
7363 session_deps_.socket_factory->AddSocketDataProvider(&data); | 7392 session_deps_.socket_factory->AddSocketDataProvider(&data); |
7364 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); | 7393 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy_ssl); |
7365 | 7394 |
7366 TestCompletionCallback callback; | 7395 TestCompletionCallback callback; |
7367 | 7396 |
7368 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 7397 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
7369 scoped_ptr<HttpTransaction> trans( | 7398 scoped_ptr<HttpTransaction> trans( |
7370 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 7399 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
7371 | 7400 |
(...skipping 20 matching lines...) Expand all Loading... | |
7392 ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70"); | 7421 ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70"); |
7393 BoundTestNetLog log; | 7422 BoundTestNetLog log; |
7394 session_deps_.net_log = log.bound().net_log(); | 7423 session_deps_.net_log = log.bound().net_log(); |
7395 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 7424 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
7396 | 7425 |
7397 // Since we have proxy, should try to establish tunnel. | 7426 // Since we have proxy, should try to establish tunnel. |
7398 scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyConnect( | 7427 scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyConnect( |
7399 NULL, 0, 1, LOWEST, HostPortPair("www.example.org", 443))); | 7428 NULL, 0, 1, LOWEST, HostPortPair("www.example.org", 443))); |
7400 scoped_ptr<SpdyFrame> rst( | 7429 scoped_ptr<SpdyFrame> rst( |
7401 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); | 7430 spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL)); |
7431 spdy_util_.UpdateWithStreamDestruction(1); | |
7402 | 7432 |
7403 // After calling trans->RestartWithAuth(), this is the request we should | 7433 // After calling trans->RestartWithAuth(), this is the request we should |
7404 // be issuing -- the final header line contains the credentials. | 7434 // be issuing -- the final header line contains the credentials. |
7405 const char* const kAuthCredentials[] = { | 7435 const char* const kAuthCredentials[] = { |
7406 "proxy-authorization", "Basic Zm9vOmJhcg==", | 7436 "proxy-authorization", "Basic Zm9vOmJhcg==", |
7407 }; | 7437 }; |
7408 scoped_ptr<SpdyFrame> connect2(spdy_util_.ConstructSpdyConnect( | 7438 scoped_ptr<SpdyFrame> connect2(spdy_util_.ConstructSpdyConnect( |
7409 kAuthCredentials, arraysize(kAuthCredentials) / 2, 3, LOWEST, | 7439 kAuthCredentials, arraysize(kAuthCredentials) / 2, 3, LOWEST, |
7410 HostPortPair("www.example.org", 443))); | 7440 HostPortPair("www.example.org", 443))); |
7411 // fetch https://www.example.org/ via HTTP | 7441 // fetch https://www.example.org/ via HTTP |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7447 CreateMockRead(*wrapped_get_resp, 6, ASYNC), | 7477 CreateMockRead(*wrapped_get_resp, 6, ASYNC), |
7448 CreateMockRead(*wrapped_body, 7, ASYNC), | 7478 CreateMockRead(*wrapped_body, 7, ASYNC), |
7449 MockRead(ASYNC, OK, 8), // EOF. May or may not be read. | 7479 MockRead(ASYNC, OK, 8), // EOF. May or may not be read. |
7450 }; | 7480 }; |
7451 | 7481 |
7452 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 7482 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
7453 arraysize(spdy_writes)); | 7483 arraysize(spdy_writes)); |
7454 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 7484 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
7455 // Negotiate SPDY to the proxy | 7485 // Negotiate SPDY to the proxy |
7456 SSLSocketDataProvider proxy(ASYNC, OK); | 7486 SSLSocketDataProvider proxy(ASYNC, OK); |
7457 proxy.SetNextProto(GetParam()); | 7487 proxy.SetNextProto(GetProtocol()); |
7458 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy); | 7488 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy); |
7459 // Vanilla SSL to the server | 7489 // Vanilla SSL to the server |
7460 SSLSocketDataProvider server(ASYNC, OK); | 7490 SSLSocketDataProvider server(ASYNC, OK); |
7461 session_deps_.socket_factory->AddSSLSocketDataProvider(&server); | 7491 session_deps_.socket_factory->AddSSLSocketDataProvider(&server); |
7462 | 7492 |
7463 TestCompletionCallback callback1; | 7493 TestCompletionCallback callback1; |
7464 | 7494 |
7465 scoped_ptr<HttpTransaction> trans( | 7495 scoped_ptr<HttpTransaction> trans( |
7466 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 7496 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
7467 | 7497 |
(...skipping 101 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7569 CreateMockRead(*stream1_body, 3, ASYNC), | 7599 CreateMockRead(*stream1_body, 3, ASYNC), |
7570 CreateMockRead(*stream2_body, 4, ASYNC), | 7600 CreateMockRead(*stream2_body, 4, ASYNC), |
7571 MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause | 7601 MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
7572 }; | 7602 }; |
7573 | 7603 |
7574 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 7604 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
7575 arraysize(spdy_writes)); | 7605 arraysize(spdy_writes)); |
7576 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 7606 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
7577 // Negotiate SPDY to the proxy | 7607 // Negotiate SPDY to the proxy |
7578 SSLSocketDataProvider proxy(ASYNC, OK); | 7608 SSLSocketDataProvider proxy(ASYNC, OK); |
7579 proxy.SetNextProto(GetParam()); | 7609 proxy.SetNextProto(GetProtocol()); |
7580 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy); | 7610 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy); |
7581 | 7611 |
7582 scoped_ptr<HttpTransaction> trans( | 7612 scoped_ptr<HttpTransaction> trans( |
7583 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 7613 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
7584 TestCompletionCallback callback; | 7614 TestCompletionCallback callback; |
7585 int rv = trans->Start(&request, callback.callback(), log.bound()); | 7615 int rv = trans->Start(&request, callback.callback(), log.bound()); |
7586 EXPECT_EQ(ERR_IO_PENDING, rv); | 7616 EXPECT_EQ(ERR_IO_PENDING, rv); |
7587 | 7617 |
7588 rv = callback.WaitForResult(); | 7618 rv = callback.WaitForResult(); |
7589 EXPECT_EQ(OK, rv); | 7619 EXPECT_EQ(OK, rv); |
(...skipping 90 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
7680 CreateMockRead(*stream2_syn, 2, ASYNC), | 7710 CreateMockRead(*stream2_syn, 2, ASYNC), |
7681 CreateMockRead(*stream1_body, 4, ASYNC), | 7711 CreateMockRead(*stream1_body, 4, ASYNC), |
7682 MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause | 7712 MockRead(ASYNC, ERR_IO_PENDING, 5), // Force a pause |
7683 }; | 7713 }; |
7684 | 7714 |
7685 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 7715 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
7686 arraysize(spdy_writes)); | 7716 arraysize(spdy_writes)); |
7687 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 7717 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
7688 // Negotiate SPDY to the proxy | 7718 // Negotiate SPDY to the proxy |
7689 SSLSocketDataProvider proxy(ASYNC, OK); | 7719 SSLSocketDataProvider proxy(ASYNC, OK); |
7690 proxy.SetNextProto(GetParam()); | 7720 proxy.SetNextProto(GetProtocol()); |
7691 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy); | 7721 session_deps_.socket_factory->AddSSLSocketDataProvider(&proxy); |
7692 | 7722 |
7693 scoped_ptr<HttpTransaction> trans( | 7723 scoped_ptr<HttpTransaction> trans( |
7694 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 7724 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
7695 TestCompletionCallback callback; | 7725 TestCompletionCallback callback; |
7696 int rv = trans->Start(&request, callback.callback(), log.bound()); | 7726 int rv = trans->Start(&request, callback.callback(), log.bound()); |
7697 EXPECT_EQ(ERR_IO_PENDING, rv); | 7727 EXPECT_EQ(ERR_IO_PENDING, rv); |
7698 | 7728 |
7699 rv = callback.WaitForResult(); | 7729 rv = callback.WaitForResult(); |
7700 EXPECT_EQ(OK, rv); | 7730 EXPECT_EQ(OK, rv); |
(...skipping 906 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
8607 true, | 8637 true, |
8608 }, | 8638 }, |
8609 }; | 8639 }; |
8610 | 8640 |
8611 session_deps_.use_alternative_services = true; | 8641 session_deps_.use_alternative_services = true; |
8612 | 8642 |
8613 for (size_t i = 0; i < arraysize(tests); ++i) { | 8643 for (size_t i = 0; i < arraysize(tests); ++i) { |
8614 session_deps_.proxy_service = | 8644 session_deps_.proxy_service = |
8615 ProxyService::CreateFixed(tests[i].proxy_server); | 8645 ProxyService::CreateFixed(tests[i].proxy_server); |
8616 scoped_ptr<HttpNetworkSession> session( | 8646 scoped_ptr<HttpNetworkSession> session( |
8617 SetupSessionForGroupNameTests(GetParam(), &session_deps_)); | 8647 SetupSessionForGroupNameTests(GetProtocol(), &session_deps_)); |
8618 | 8648 |
8619 HttpNetworkSessionPeer peer(session.get()); | 8649 HttpNetworkSessionPeer peer(session.get()); |
8620 CaptureGroupNameTransportSocketPool* transport_conn_pool = | 8650 CaptureGroupNameTransportSocketPool* transport_conn_pool = |
8621 new CaptureGroupNameTransportSocketPool(NULL, NULL); | 8651 new CaptureGroupNameTransportSocketPool(NULL, NULL); |
8622 CaptureGroupNameSSLSocketPool* ssl_conn_pool = | 8652 CaptureGroupNameSSLSocketPool* ssl_conn_pool = |
8623 new CaptureGroupNameSSLSocketPool(NULL, NULL); | 8653 new CaptureGroupNameSSLSocketPool(NULL, NULL); |
8624 scoped_ptr<MockClientSocketPoolManager> mock_pool_manager( | 8654 scoped_ptr<MockClientSocketPoolManager> mock_pool_manager( |
8625 new MockClientSocketPoolManager); | 8655 new MockClientSocketPoolManager); |
8626 mock_pool_manager->SetTransportSocketPool(transport_conn_pool); | 8656 mock_pool_manager->SetTransportSocketPool(transport_conn_pool); |
8627 mock_pool_manager->SetSSLSocketPool(ssl_conn_pool); | 8657 mock_pool_manager->SetSSLSocketPool(ssl_conn_pool); |
(...skipping 41 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
8669 false, | 8699 false, |
8670 }, | 8700 }, |
8671 }; | 8701 }; |
8672 | 8702 |
8673 session_deps_.use_alternative_services = true; | 8703 session_deps_.use_alternative_services = true; |
8674 | 8704 |
8675 for (size_t i = 0; i < arraysize(tests); ++i) { | 8705 for (size_t i = 0; i < arraysize(tests); ++i) { |
8676 session_deps_.proxy_service = | 8706 session_deps_.proxy_service = |
8677 ProxyService::CreateFixed(tests[i].proxy_server); | 8707 ProxyService::CreateFixed(tests[i].proxy_server); |
8678 scoped_ptr<HttpNetworkSession> session( | 8708 scoped_ptr<HttpNetworkSession> session( |
8679 SetupSessionForGroupNameTests(GetParam(), &session_deps_)); | 8709 SetupSessionForGroupNameTests(GetProtocol(), &session_deps_)); |
8680 | 8710 |
8681 HttpNetworkSessionPeer peer(session.get()); | 8711 HttpNetworkSessionPeer peer(session.get()); |
8682 | 8712 |
8683 HostPortPair proxy_host("http_proxy", 80); | 8713 HostPortPair proxy_host("http_proxy", 80); |
8684 CaptureGroupNameHttpProxySocketPool* http_proxy_pool = | 8714 CaptureGroupNameHttpProxySocketPool* http_proxy_pool = |
8685 new CaptureGroupNameHttpProxySocketPool(NULL, NULL); | 8715 new CaptureGroupNameHttpProxySocketPool(NULL, NULL); |
8686 CaptureGroupNameSSLSocketPool* ssl_conn_pool = | 8716 CaptureGroupNameSSLSocketPool* ssl_conn_pool = |
8687 new CaptureGroupNameSSLSocketPool(NULL, NULL); | 8717 new CaptureGroupNameSSLSocketPool(NULL, NULL); |
8688 | 8718 |
8689 scoped_ptr<MockClientSocketPoolManager> mock_pool_manager( | 8719 scoped_ptr<MockClientSocketPoolManager> mock_pool_manager( |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
8739 true, | 8769 true, |
8740 }, | 8770 }, |
8741 }; | 8771 }; |
8742 | 8772 |
8743 session_deps_.use_alternative_services = true; | 8773 session_deps_.use_alternative_services = true; |
8744 | 8774 |
8745 for (size_t i = 0; i < arraysize(tests); ++i) { | 8775 for (size_t i = 0; i < arraysize(tests); ++i) { |
8746 session_deps_.proxy_service = | 8776 session_deps_.proxy_service = |
8747 ProxyService::CreateFixed(tests[i].proxy_server); | 8777 ProxyService::CreateFixed(tests[i].proxy_server); |
8748 scoped_ptr<HttpNetworkSession> session( | 8778 scoped_ptr<HttpNetworkSession> session( |
8749 SetupSessionForGroupNameTests(GetParam(), &session_deps_)); | 8779 SetupSessionForGroupNameTests(GetProtocol(), &session_deps_)); |
8750 | 8780 |
8751 HttpNetworkSessionPeer peer(session.get()); | 8781 HttpNetworkSessionPeer peer(session.get()); |
8752 | 8782 |
8753 HostPortPair proxy_host("socks_proxy", 1080); | 8783 HostPortPair proxy_host("socks_proxy", 1080); |
8754 CaptureGroupNameSOCKSSocketPool* socks_conn_pool = | 8784 CaptureGroupNameSOCKSSocketPool* socks_conn_pool = |
8755 new CaptureGroupNameSOCKSSocketPool(NULL, NULL); | 8785 new CaptureGroupNameSOCKSSocketPool(NULL, NULL); |
8756 CaptureGroupNameSSLSocketPool* ssl_conn_pool = | 8786 CaptureGroupNameSSLSocketPool* ssl_conn_pool = |
8757 new CaptureGroupNameSSLSocketPool(NULL, NULL); | 8787 new CaptureGroupNameSSLSocketPool(NULL, NULL); |
8758 | 8788 |
8759 scoped_ptr<MockClientSocketPoolManager> mock_pool_manager( | 8789 scoped_ptr<MockClientSocketPoolManager> mock_pool_manager( |
(...skipping 689 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
9449 EXPECT_FALSE(response->was_fetched_via_spdy); | 9479 EXPECT_FALSE(response->was_fetched_via_spdy); |
9450 EXPECT_FALSE(response->was_npn_negotiated); | 9480 EXPECT_FALSE(response->was_npn_negotiated); |
9451 | 9481 |
9452 std::string response_data; | 9482 std::string response_data; |
9453 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 9483 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
9454 EXPECT_EQ("hello world", response_data); | 9484 EXPECT_EQ("hello world", response_data); |
9455 | 9485 |
9456 alternative_service_vector = | 9486 alternative_service_vector = |
9457 http_server_properties.GetAlternativeServices(http_host_port_pair); | 9487 http_server_properties.GetAlternativeServices(http_host_port_pair); |
9458 ASSERT_EQ(1u, alternative_service_vector.size()); | 9488 ASSERT_EQ(1u, alternative_service_vector.size()); |
9459 EXPECT_EQ(AlternateProtocolFromNextProto(GetParam()), | 9489 EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()), |
9460 alternative_service_vector[0].protocol); | 9490 alternative_service_vector[0].protocol); |
9461 EXPECT_EQ("www.example.com", alternative_service_vector[0].host); | 9491 EXPECT_EQ("www.example.com", alternative_service_vector[0].host); |
9462 EXPECT_EQ(443, alternative_service_vector[0].port); | 9492 EXPECT_EQ(443, alternative_service_vector[0].port); |
9463 } | 9493 } |
9464 | 9494 |
9465 TEST_P(HttpNetworkTransactionTest, ClearAlternativeServices) { | 9495 TEST_P(HttpNetworkTransactionTest, ClearAlternativeServices) { |
9466 session_deps_.next_protos = SpdyNextProtos(); | 9496 session_deps_.next_protos = SpdyNextProtos(); |
9467 session_deps_.use_alternative_services = true; | 9497 session_deps_.use_alternative_services = true; |
9468 | 9498 |
9469 // Set an alternative service for origin. | 9499 // Set an alternative service for origin. |
(...skipping 157 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
9627 EXPECT_FALSE(response->was_fetched_via_spdy); | 9657 EXPECT_FALSE(response->was_fetched_via_spdy); |
9628 EXPECT_FALSE(response->was_npn_negotiated); | 9658 EXPECT_FALSE(response->was_npn_negotiated); |
9629 | 9659 |
9630 std::string response_data; | 9660 std::string response_data; |
9631 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 9661 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
9632 EXPECT_EQ("hello world", response_data); | 9662 EXPECT_EQ("hello world", response_data); |
9633 | 9663 |
9634 alternative_service_vector = | 9664 alternative_service_vector = |
9635 http_server_properties.GetAlternativeServices(http_host_port_pair); | 9665 http_server_properties.GetAlternativeServices(http_host_port_pair); |
9636 ASSERT_EQ(2u, alternative_service_vector.size()); | 9666 ASSERT_EQ(2u, alternative_service_vector.size()); |
9637 EXPECT_EQ(AlternateProtocolFromNextProto(GetParam()), | 9667 EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()), |
9638 alternative_service_vector[0].protocol); | 9668 alternative_service_vector[0].protocol); |
9639 EXPECT_EQ("www.example.com", alternative_service_vector[0].host); | 9669 EXPECT_EQ("www.example.com", alternative_service_vector[0].host); |
9640 EXPECT_EQ(443, alternative_service_vector[0].port); | 9670 EXPECT_EQ(443, alternative_service_vector[0].port); |
9641 EXPECT_EQ(QUIC, alternative_service_vector[1].protocol); | 9671 EXPECT_EQ(QUIC, alternative_service_vector[1].protocol); |
9642 EXPECT_EQ("www.example.org", alternative_service_vector[1].host); | 9672 EXPECT_EQ("www.example.org", alternative_service_vector[1].host); |
9643 EXPECT_EQ(1234, alternative_service_vector[1].port); | 9673 EXPECT_EQ(1234, alternative_service_vector[1].port); |
9644 } | 9674 } |
9645 | 9675 |
9646 // Alternate Protocol headers must be honored even if |use_alternative_services| | 9676 // Alternate Protocol headers must be honored even if |use_alternative_services| |
9647 // is false. | 9677 // is false. |
(...skipping 47 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
9695 EXPECT_FALSE(response->was_npn_negotiated); | 9725 EXPECT_FALSE(response->was_npn_negotiated); |
9696 | 9726 |
9697 std::string response_data; | 9727 std::string response_data; |
9698 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 9728 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
9699 EXPECT_EQ("hello world", response_data); | 9729 EXPECT_EQ("hello world", response_data); |
9700 | 9730 |
9701 alternative_service_vector = | 9731 alternative_service_vector = |
9702 http_server_properties.GetAlternativeServices(http_host_port_pair); | 9732 http_server_properties.GetAlternativeServices(http_host_port_pair); |
9703 ASSERT_EQ(1u, alternative_service_vector.size()); | 9733 ASSERT_EQ(1u, alternative_service_vector.size()); |
9704 EXPECT_EQ(443, alternative_service_vector[0].port); | 9734 EXPECT_EQ(443, alternative_service_vector[0].port); |
9705 EXPECT_EQ(AlternateProtocolFromNextProto(GetParam()), | 9735 EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()), |
9706 alternative_service_vector[0].protocol); | 9736 alternative_service_vector[0].protocol); |
9707 } | 9737 } |
9708 | 9738 |
9709 TEST_P(HttpNetworkTransactionTest, EmptyAlternateProtocolHeader) { | 9739 TEST_P(HttpNetworkTransactionTest, EmptyAlternateProtocolHeader) { |
9710 session_deps_.next_protos = SpdyNextProtos(); | 9740 session_deps_.next_protos = SpdyNextProtos(); |
9711 session_deps_.use_alternative_services = true; | 9741 session_deps_.use_alternative_services = true; |
9712 | 9742 |
9713 MockRead data_reads[] = { | 9743 MockRead data_reads[] = { |
9714 MockRead("HTTP/1.1 200 OK\r\n"), | 9744 MockRead("HTTP/1.1 200 OK\r\n"), |
9715 MockRead("Alternate-Protocol: \r\n\r\n"), | 9745 MockRead("Alternate-Protocol: \r\n\r\n"), |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
9818 EXPECT_FALSE(response->was_fetched_via_spdy); | 9848 EXPECT_FALSE(response->was_fetched_via_spdy); |
9819 EXPECT_FALSE(response->was_npn_negotiated); | 9849 EXPECT_FALSE(response->was_npn_negotiated); |
9820 | 9850 |
9821 std::string response_data; | 9851 std::string response_data; |
9822 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 9852 ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
9823 EXPECT_EQ("hello world", response_data); | 9853 EXPECT_EQ("hello world", response_data); |
9824 | 9854 |
9825 alternative_service_vector = | 9855 alternative_service_vector = |
9826 http_server_properties.GetAlternativeServices(http_host_port_pair); | 9856 http_server_properties.GetAlternativeServices(http_host_port_pair); |
9827 ASSERT_EQ(1u, alternative_service_vector.size()); | 9857 ASSERT_EQ(1u, alternative_service_vector.size()); |
9828 EXPECT_EQ(AlternateProtocolFromNextProto(GetParam()), | 9858 EXPECT_EQ(AlternateProtocolFromNextProto(GetProtocol()), |
9829 alternative_service_vector[0].protocol); | 9859 alternative_service_vector[0].protocol); |
9830 EXPECT_EQ("www.example.com", alternative_service_vector[0].host); | 9860 EXPECT_EQ("www.example.com", alternative_service_vector[0].host); |
9831 EXPECT_EQ(443, alternative_service_vector[0].port); | 9861 EXPECT_EQ(443, alternative_service_vector[0].port); |
9832 } | 9862 } |
9833 | 9863 |
9834 // When |use_alternative_services| is false, do not observe alternative service | 9864 // When |use_alternative_services| is false, do not observe alternative service |
9835 // entries that point to a different host. | 9865 // entries that point to a different host. |
9836 TEST_P(HttpNetworkTransactionTest, DisableAlternativeServiceToDifferentHost) { | 9866 TEST_P(HttpNetworkTransactionTest, DisableAlternativeServiceToDifferentHost) { |
9837 session_deps_.use_alternative_services = false; | 9867 session_deps_.use_alternative_services = false; |
9838 | 9868 |
(...skipping 13 matching lines...) Expand all Loading... | |
9852 }; | 9882 }; |
9853 StaticSocketDataProvider second_data(data_reads, arraysize(data_reads), | 9883 StaticSocketDataProvider second_data(data_reads, arraysize(data_reads), |
9854 nullptr, 0); | 9884 nullptr, 0); |
9855 session_deps_.socket_factory->AddSocketDataProvider(&second_data); | 9885 session_deps_.socket_factory->AddSocketDataProvider(&second_data); |
9856 | 9886 |
9857 scoped_ptr<HttpNetworkSession> session = CreateSession(&session_deps_); | 9887 scoped_ptr<HttpNetworkSession> session = CreateSession(&session_deps_); |
9858 | 9888 |
9859 base::WeakPtr<HttpServerProperties> http_server_properties = | 9889 base::WeakPtr<HttpServerProperties> http_server_properties = |
9860 session->http_server_properties(); | 9890 session->http_server_properties(); |
9861 AlternativeService alternative_service( | 9891 AlternativeService alternative_service( |
9862 AlternateProtocolFromNextProto(GetParam()), "different.example.org", 80); | 9892 AlternateProtocolFromNextProto(GetProtocol()), "different.example.org", |
9893 80); | |
9863 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 9894 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
9864 http_server_properties->SetAlternativeService( | 9895 http_server_properties->SetAlternativeService( |
9865 HostPortPair::FromURL(request.url), alternative_service, 1.0, expiration); | 9896 HostPortPair::FromURL(request.url), alternative_service, 1.0, expiration); |
9866 | 9897 |
9867 scoped_ptr<HttpTransaction> trans( | 9898 scoped_ptr<HttpTransaction> trans( |
9868 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 9899 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
9869 TestCompletionCallback callback; | 9900 TestCompletionCallback callback; |
9870 | 9901 |
9871 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); | 9902 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
9872 // The connetion to origin was refused, and the alternative service should not | 9903 // The connetion to origin was refused, and the alternative service should not |
(...skipping 26 matching lines...) Expand all Loading... | |
9899 session_deps_.socket_factory->AddSocketDataProvider(&second_data); | 9930 session_deps_.socket_factory->AddSocketDataProvider(&second_data); |
9900 | 9931 |
9901 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 9932 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
9902 | 9933 |
9903 base::WeakPtr<HttpServerProperties> http_server_properties = | 9934 base::WeakPtr<HttpServerProperties> http_server_properties = |
9904 session->http_server_properties(); | 9935 session->http_server_properties(); |
9905 const HostPortPair host_port_pair = HostPortPair::FromURL(request.url); | 9936 const HostPortPair host_port_pair = HostPortPair::FromURL(request.url); |
9906 // Port must be < 1024, or the header will be ignored (since initial port was | 9937 // Port must be < 1024, or the header will be ignored (since initial port was |
9907 // port 80 (another restricted port). | 9938 // port 80 (another restricted port). |
9908 const AlternativeService alternative_service( | 9939 const AlternativeService alternative_service( |
9909 AlternateProtocolFromNextProto(GetParam()), "www.example.org", | 9940 AlternateProtocolFromNextProto(GetProtocol()), "www.example.org", |
9910 666); // Port is ignored by MockConnect anyway. | 9941 666); // Port is ignored by MockConnect anyway. |
9911 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 9942 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
9912 http_server_properties->SetAlternativeService( | 9943 http_server_properties->SetAlternativeService( |
9913 host_port_pair, alternative_service, 1.0, expiration); | 9944 host_port_pair, alternative_service, 1.0, expiration); |
9914 | 9945 |
9915 scoped_ptr<HttpTransaction> trans( | 9946 scoped_ptr<HttpTransaction> trans( |
9916 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 9947 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
9917 TestCompletionCallback callback; | 9948 TestCompletionCallback callback; |
9918 | 9949 |
9919 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); | 9950 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
(...skipping 43 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
9963 StaticSocketDataProvider second_data( | 9994 StaticSocketDataProvider second_data( |
9964 data_reads, arraysize(data_reads), NULL, 0); | 9995 data_reads, arraysize(data_reads), NULL, 0); |
9965 session_deps_.socket_factory->AddSocketDataProvider(&second_data); | 9996 session_deps_.socket_factory->AddSocketDataProvider(&second_data); |
9966 | 9997 |
9967 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 9998 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
9968 | 9999 |
9969 base::WeakPtr<HttpServerProperties> http_server_properties = | 10000 base::WeakPtr<HttpServerProperties> http_server_properties = |
9970 session->http_server_properties(); | 10001 session->http_server_properties(); |
9971 const int kUnrestrictedAlternatePort = 1024; | 10002 const int kUnrestrictedAlternatePort = 1024; |
9972 AlternativeService alternative_service( | 10003 AlternativeService alternative_service( |
9973 AlternateProtocolFromNextProto(GetParam()), "www.example.org", | 10004 AlternateProtocolFromNextProto(GetProtocol()), "www.example.org", |
9974 kUnrestrictedAlternatePort); | 10005 kUnrestrictedAlternatePort); |
9975 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 10006 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
9976 http_server_properties->SetAlternativeService( | 10007 http_server_properties->SetAlternativeService( |
9977 HostPortPair::FromURL(restricted_port_request.url), alternative_service, | 10008 HostPortPair::FromURL(restricted_port_request.url), alternative_service, |
9978 1.0, expiration); | 10009 1.0, expiration); |
9979 | 10010 |
9980 scoped_ptr<HttpTransaction> trans( | 10011 scoped_ptr<HttpTransaction> trans( |
9981 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 10012 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
9982 TestCompletionCallback callback; | 10013 TestCompletionCallback callback; |
9983 | 10014 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
10015 StaticSocketDataProvider second_data( | 10046 StaticSocketDataProvider second_data( |
10016 data_reads, arraysize(data_reads), NULL, 0); | 10047 data_reads, arraysize(data_reads), NULL, 0); |
10017 session_deps_.socket_factory->AddSocketDataProvider(&second_data); | 10048 session_deps_.socket_factory->AddSocketDataProvider(&second_data); |
10018 | 10049 |
10019 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 10050 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
10020 | 10051 |
10021 base::WeakPtr<HttpServerProperties> http_server_properties = | 10052 base::WeakPtr<HttpServerProperties> http_server_properties = |
10022 session->http_server_properties(); | 10053 session->http_server_properties(); |
10023 const int kUnrestrictedAlternatePort = 1024; | 10054 const int kUnrestrictedAlternatePort = 1024; |
10024 AlternativeService alternative_service( | 10055 AlternativeService alternative_service( |
10025 AlternateProtocolFromNextProto(GetParam()), "www.example.org", | 10056 AlternateProtocolFromNextProto(GetProtocol()), "www.example.org", |
10026 kUnrestrictedAlternatePort); | 10057 kUnrestrictedAlternatePort); |
10027 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 10058 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
10028 http_server_properties->SetAlternativeService( | 10059 http_server_properties->SetAlternativeService( |
10029 HostPortPair::FromURL(restricted_port_request.url), alternative_service, | 10060 HostPortPair::FromURL(restricted_port_request.url), alternative_service, |
10030 1.0, expiration); | 10061 1.0, expiration); |
10031 | 10062 |
10032 scoped_ptr<HttpTransaction> trans( | 10063 scoped_ptr<HttpTransaction> trans( |
10033 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 10064 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
10034 TestCompletionCallback callback; | 10065 TestCompletionCallback callback; |
10035 | 10066 |
(...skipping 30 matching lines...) Expand all Loading... | |
10066 StaticSocketDataProvider second_data( | 10097 StaticSocketDataProvider second_data( |
10067 data_reads, arraysize(data_reads), NULL, 0); | 10098 data_reads, arraysize(data_reads), NULL, 0); |
10068 session_deps_.socket_factory->AddSocketDataProvider(&second_data); | 10099 session_deps_.socket_factory->AddSocketDataProvider(&second_data); |
10069 | 10100 |
10070 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 10101 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
10071 | 10102 |
10072 base::WeakPtr<HttpServerProperties> http_server_properties = | 10103 base::WeakPtr<HttpServerProperties> http_server_properties = |
10073 session->http_server_properties(); | 10104 session->http_server_properties(); |
10074 const int kRestrictedAlternatePort = 80; | 10105 const int kRestrictedAlternatePort = 80; |
10075 AlternativeService alternative_service( | 10106 AlternativeService alternative_service( |
10076 AlternateProtocolFromNextProto(GetParam()), "www.example.org", | 10107 AlternateProtocolFromNextProto(GetProtocol()), "www.example.org", |
10077 kRestrictedAlternatePort); | 10108 kRestrictedAlternatePort); |
10078 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 10109 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
10079 http_server_properties->SetAlternativeService( | 10110 http_server_properties->SetAlternativeService( |
10080 HostPortPair::FromURL(restricted_port_request.url), alternative_service, | 10111 HostPortPair::FromURL(restricted_port_request.url), alternative_service, |
10081 1.0, expiration); | 10112 1.0, expiration); |
10082 | 10113 |
10083 scoped_ptr<HttpTransaction> trans( | 10114 scoped_ptr<HttpTransaction> trans( |
10084 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 10115 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
10085 TestCompletionCallback callback; | 10116 TestCompletionCallback callback; |
10086 | 10117 |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
10118 StaticSocketDataProvider second_data( | 10149 StaticSocketDataProvider second_data( |
10119 data_reads, arraysize(data_reads), NULL, 0); | 10150 data_reads, arraysize(data_reads), NULL, 0); |
10120 session_deps_.socket_factory->AddSocketDataProvider(&second_data); | 10151 session_deps_.socket_factory->AddSocketDataProvider(&second_data); |
10121 | 10152 |
10122 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 10153 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
10123 | 10154 |
10124 base::WeakPtr<HttpServerProperties> http_server_properties = | 10155 base::WeakPtr<HttpServerProperties> http_server_properties = |
10125 session->http_server_properties(); | 10156 session->http_server_properties(); |
10126 const int kRestrictedAlternatePort = 80; | 10157 const int kRestrictedAlternatePort = 80; |
10127 AlternativeService alternative_service( | 10158 AlternativeService alternative_service( |
10128 AlternateProtocolFromNextProto(GetParam()), "www.example.org", | 10159 AlternateProtocolFromNextProto(GetProtocol()), "www.example.org", |
10129 kRestrictedAlternatePort); | 10160 kRestrictedAlternatePort); |
10130 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 10161 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
10131 http_server_properties->SetAlternativeService( | 10162 http_server_properties->SetAlternativeService( |
10132 HostPortPair::FromURL(unrestricted_port_request.url), alternative_service, | 10163 HostPortPair::FromURL(unrestricted_port_request.url), alternative_service, |
10133 1.0, expiration); | 10164 1.0, expiration); |
10134 | 10165 |
10135 scoped_ptr<HttpTransaction> trans( | 10166 scoped_ptr<HttpTransaction> trans( |
10136 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 10167 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
10137 TestCompletionCallback callback; | 10168 TestCompletionCallback callback; |
10138 | 10169 |
(...skipping 30 matching lines...) Expand all Loading... | |
10169 StaticSocketDataProvider second_data( | 10200 StaticSocketDataProvider second_data( |
10170 data_reads, arraysize(data_reads), NULL, 0); | 10201 data_reads, arraysize(data_reads), NULL, 0); |
10171 session_deps_.socket_factory->AddSocketDataProvider(&second_data); | 10202 session_deps_.socket_factory->AddSocketDataProvider(&second_data); |
10172 | 10203 |
10173 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 10204 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
10174 | 10205 |
10175 base::WeakPtr<HttpServerProperties> http_server_properties = | 10206 base::WeakPtr<HttpServerProperties> http_server_properties = |
10176 session->http_server_properties(); | 10207 session->http_server_properties(); |
10177 const int kUnrestrictedAlternatePort = 1025; | 10208 const int kUnrestrictedAlternatePort = 1025; |
10178 AlternativeService alternative_service( | 10209 AlternativeService alternative_service( |
10179 AlternateProtocolFromNextProto(GetParam()), "www.example.org", | 10210 AlternateProtocolFromNextProto(GetProtocol()), "www.example.org", |
10180 kUnrestrictedAlternatePort); | 10211 kUnrestrictedAlternatePort); |
10181 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 10212 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
10182 http_server_properties->SetAlternativeService( | 10213 http_server_properties->SetAlternativeService( |
10183 HostPortPair::FromURL(unrestricted_port_request.url), alternative_service, | 10214 HostPortPair::FromURL(unrestricted_port_request.url), alternative_service, |
10184 1.0, expiration); | 10215 1.0, expiration); |
10185 | 10216 |
10186 scoped_ptr<HttpTransaction> trans( | 10217 scoped_ptr<HttpTransaction> trans( |
10187 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 10218 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
10188 TestCompletionCallback callback; | 10219 TestCompletionCallback callback; |
10189 | 10220 |
(...skipping 25 matching lines...) Expand all Loading... | |
10215 StaticSocketDataProvider data( | 10246 StaticSocketDataProvider data( |
10216 data_reads, arraysize(data_reads), NULL, 0); | 10247 data_reads, arraysize(data_reads), NULL, 0); |
10217 session_deps_.socket_factory->AddSocketDataProvider(&data); | 10248 session_deps_.socket_factory->AddSocketDataProvider(&data); |
10218 | 10249 |
10219 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 10250 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
10220 | 10251 |
10221 base::WeakPtr<HttpServerProperties> http_server_properties = | 10252 base::WeakPtr<HttpServerProperties> http_server_properties = |
10222 session->http_server_properties(); | 10253 session->http_server_properties(); |
10223 const int kUnsafePort = 7; | 10254 const int kUnsafePort = 7; |
10224 AlternativeService alternative_service( | 10255 AlternativeService alternative_service( |
10225 AlternateProtocolFromNextProto(GetParam()), "www.example.org", | 10256 AlternateProtocolFromNextProto(GetProtocol()), "www.example.org", |
10226 kUnsafePort); | 10257 kUnsafePort); |
10227 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 10258 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
10228 http_server_properties->SetAlternativeService( | 10259 http_server_properties->SetAlternativeService( |
10229 HostPortPair::FromURL(request.url), alternative_service, 1.0, expiration); | 10260 HostPortPair::FromURL(request.url), alternative_service, 1.0, expiration); |
10230 | 10261 |
10231 scoped_ptr<HttpTransaction> trans( | 10262 scoped_ptr<HttpTransaction> trans( |
10232 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 10263 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
10233 TestCompletionCallback callback; | 10264 TestCompletionCallback callback; |
10234 | 10265 |
10235 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); | 10266 int rv = trans->Start(&request, callback.callback(), BoundNetLog()); |
(...skipping 29 matching lines...) Expand all Loading... | |
10265 MockRead("\r\n"), | 10296 MockRead("\r\n"), |
10266 MockRead("hello world"), | 10297 MockRead("hello world"), |
10267 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | 10298 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
10268 MockRead(ASYNC, OK)}; | 10299 MockRead(ASYNC, OK)}; |
10269 | 10300 |
10270 StaticSocketDataProvider first_transaction( | 10301 StaticSocketDataProvider first_transaction( |
10271 data_reads, arraysize(data_reads), NULL, 0); | 10302 data_reads, arraysize(data_reads), NULL, 0); |
10272 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); | 10303 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); |
10273 | 10304 |
10274 SSLSocketDataProvider ssl(ASYNC, OK); | 10305 SSLSocketDataProvider ssl(ASYNC, OK); |
10275 ssl.SetNextProto(GetParam()); | 10306 ssl.SetNextProto(GetProtocol()); |
10276 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 10307 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
10277 ASSERT_TRUE(ssl.cert.get()); | 10308 ASSERT_TRUE(ssl.cert.get()); |
10278 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 10309 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
10279 | 10310 |
10280 scoped_ptr<SpdyFrame> req( | 10311 scoped_ptr<SpdyFrame> req( |
10281 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); | 10312 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
10282 MockWrite spdy_writes[] = {CreateMockWrite(*req, 0)}; | 10313 MockWrite spdy_writes[] = {CreateMockWrite(*req, 0)}; |
10283 | 10314 |
10284 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 10315 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
10285 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 10316 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
(...skipping 78 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
10364 MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING); | 10395 MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING); |
10365 StaticSocketDataProvider hanging_socket( | 10396 StaticSocketDataProvider hanging_socket( |
10366 NULL, 0, NULL, 0); | 10397 NULL, 0, NULL, 0); |
10367 hanging_socket.set_connect_data(never_finishing_connect); | 10398 hanging_socket.set_connect_data(never_finishing_connect); |
10368 // Socket 2 and 3 are the hanging Alternate-Protocol and | 10399 // Socket 2 and 3 are the hanging Alternate-Protocol and |
10369 // non-Alternate-Protocol jobs from the 2nd transaction. | 10400 // non-Alternate-Protocol jobs from the 2nd transaction. |
10370 session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket); | 10401 session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket); |
10371 session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket); | 10402 session_deps_.socket_factory->AddSocketDataProvider(&hanging_socket); |
10372 | 10403 |
10373 SSLSocketDataProvider ssl(ASYNC, OK); | 10404 SSLSocketDataProvider ssl(ASYNC, OK); |
10374 ssl.SetNextProto(GetParam()); | 10405 ssl.SetNextProto(GetProtocol()); |
10375 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 10406 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
10376 ASSERT_TRUE(ssl.cert.get()); | 10407 ASSERT_TRUE(ssl.cert.get()); |
10377 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 10408 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
10378 | 10409 |
10379 scoped_ptr<SpdyFrame> req1( | 10410 scoped_ptr<SpdyFrame> req1( |
10380 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); | 10411 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
10381 scoped_ptr<SpdyFrame> req2( | 10412 scoped_ptr<SpdyFrame> req2( |
10382 spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true)); | 10413 spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true)); |
10383 MockWrite spdy_writes[] = { | 10414 MockWrite spdy_writes[] = { |
10384 CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1), | 10415 CreateMockWrite(*req1, 0), CreateMockWrite(*req2, 1), |
(...skipping 86 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
10471 MockRead("hello world"), | 10502 MockRead("hello world"), |
10472 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | 10503 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
10473 MockRead(ASYNC, OK), | 10504 MockRead(ASYNC, OK), |
10474 }; | 10505 }; |
10475 | 10506 |
10476 StaticSocketDataProvider first_transaction( | 10507 StaticSocketDataProvider first_transaction( |
10477 data_reads, arraysize(data_reads), NULL, 0); | 10508 data_reads, arraysize(data_reads), NULL, 0); |
10478 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); | 10509 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); |
10479 | 10510 |
10480 SSLSocketDataProvider ssl(ASYNC, OK); | 10511 SSLSocketDataProvider ssl(ASYNC, OK); |
10481 ssl.SetNextProto(GetParam()); | 10512 ssl.SetNextProto(GetProtocol()); |
10482 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 10513 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
10483 | 10514 |
10484 MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING); | 10515 MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING); |
10485 StaticSocketDataProvider hanging_alternate_protocol_socket( | 10516 StaticSocketDataProvider hanging_alternate_protocol_socket( |
10486 NULL, 0, NULL, 0); | 10517 NULL, 0, NULL, 0); |
10487 hanging_alternate_protocol_socket.set_connect_data( | 10518 hanging_alternate_protocol_socket.set_connect_data( |
10488 never_finishing_connect); | 10519 never_finishing_connect); |
10489 session_deps_.socket_factory->AddSocketDataProvider( | 10520 session_deps_.socket_factory->AddSocketDataProvider( |
10490 &hanging_alternate_protocol_socket); | 10521 &hanging_alternate_protocol_socket); |
10491 | 10522 |
(...skipping 119 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
10611 MockRead("hello world"), | 10642 MockRead("hello world"), |
10612 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), | 10643 MockRead(SYNCHRONOUS, ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ), |
10613 MockRead(ASYNC, OK), | 10644 MockRead(ASYNC, OK), |
10614 }; | 10645 }; |
10615 | 10646 |
10616 StaticSocketDataProvider first_transaction( | 10647 StaticSocketDataProvider first_transaction( |
10617 data_reads, arraysize(data_reads), NULL, 0); | 10648 data_reads, arraysize(data_reads), NULL, 0); |
10618 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); | 10649 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); |
10619 | 10650 |
10620 SSLSocketDataProvider ssl(ASYNC, OK); | 10651 SSLSocketDataProvider ssl(ASYNC, OK); |
10621 ssl.SetNextProto(GetParam()); | 10652 ssl.SetNextProto(GetProtocol()); |
10622 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 10653 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
10623 ASSERT_TRUE(ssl.cert.get()); | 10654 ASSERT_TRUE(ssl.cert.get()); |
10624 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 10655 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
10625 | 10656 |
10626 scoped_ptr<SpdyFrame> req( | 10657 scoped_ptr<SpdyFrame> req( |
10627 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); | 10658 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
10628 MockWrite spdy_writes[] = { | 10659 MockWrite spdy_writes[] = { |
10629 MockWrite(ASYNC, 0, | 10660 MockWrite(ASYNC, 0, |
10630 "CONNECT www.example.org:443 HTTP/1.1\r\n" | 10661 "CONNECT www.example.org:443 HTTP/1.1\r\n" |
10631 "Host: www.example.org\r\n" | 10662 "Host: www.example.org\r\n" |
(...skipping 91 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
10723 MockRead("\r\n"), | 10754 MockRead("\r\n"), |
10724 MockRead("hello world"), | 10755 MockRead("hello world"), |
10725 MockRead(ASYNC, OK), | 10756 MockRead(ASYNC, OK), |
10726 }; | 10757 }; |
10727 | 10758 |
10728 StaticSocketDataProvider first_transaction( | 10759 StaticSocketDataProvider first_transaction( |
10729 data_reads, arraysize(data_reads), NULL, 0); | 10760 data_reads, arraysize(data_reads), NULL, 0); |
10730 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); | 10761 session_deps_.socket_factory->AddSocketDataProvider(&first_transaction); |
10731 | 10762 |
10732 SSLSocketDataProvider ssl(ASYNC, OK); | 10763 SSLSocketDataProvider ssl(ASYNC, OK); |
10733 ssl.SetNextProto(GetParam()); | 10764 ssl.SetNextProto(GetProtocol()); |
10734 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 10765 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
10735 ASSERT_TRUE(ssl.cert.get()); | 10766 ASSERT_TRUE(ssl.cert.get()); |
10736 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 10767 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
10737 | 10768 |
10738 scoped_ptr<SpdyFrame> req( | 10769 scoped_ptr<SpdyFrame> req( |
10739 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); | 10770 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
10740 MockWrite spdy_writes[] = {CreateMockWrite(*req, 0)}; | 10771 MockWrite spdy_writes[] = {CreateMockWrite(*req, 0)}; |
10741 | 10772 |
10742 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 10773 scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
10743 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 10774 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
(...skipping 726 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
11470 TEST_P(HttpNetworkTransactionTest, SpdyPostNPNServerHangup) { | 11501 TEST_P(HttpNetworkTransactionTest, SpdyPostNPNServerHangup) { |
11471 session_deps_.use_alternative_services = true; | 11502 session_deps_.use_alternative_services = true; |
11472 session_deps_.next_protos = SpdyNextProtos(); | 11503 session_deps_.next_protos = SpdyNextProtos(); |
11473 | 11504 |
11474 HttpRequestInfo request; | 11505 HttpRequestInfo request; |
11475 request.method = "GET"; | 11506 request.method = "GET"; |
11476 request.url = GURL("https://www.example.org/"); | 11507 request.url = GURL("https://www.example.org/"); |
11477 request.load_flags = 0; | 11508 request.load_flags = 0; |
11478 | 11509 |
11479 SSLSocketDataProvider ssl(ASYNC, OK); | 11510 SSLSocketDataProvider ssl(ASYNC, OK); |
11480 ssl.SetNextProto(GetParam()); | 11511 ssl.SetNextProto(GetProtocol()); |
11481 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 11512 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
11482 | 11513 |
11483 scoped_ptr<SpdyFrame> req( | 11514 scoped_ptr<SpdyFrame> req( |
11484 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); | 11515 spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true)); |
11485 MockWrite spdy_writes[] = {CreateMockWrite(*req, 1)}; | 11516 MockWrite spdy_writes[] = {CreateMockWrite(*req, 1)}; |
11486 | 11517 |
11487 MockRead spdy_reads[] = { | 11518 MockRead spdy_reads[] = { |
11488 MockRead(SYNCHRONOUS, 0, 0) // Not async - return 0 immediately. | 11519 MockRead(SYNCHRONOUS, 0, 0) // Not async - return 0 immediately. |
11489 }; | 11520 }; |
11490 | 11521 |
(...skipping 135 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
11626 MockRead(ASYNC, 3, "HTTP/1.1 200 Connected\r\n\r\n"), | 11657 MockRead(ASYNC, 3, "HTTP/1.1 200 Connected\r\n\r\n"), |
11627 | 11658 |
11628 // SPDY response | 11659 // SPDY response |
11629 CreateMockRead(*resp.get(), 5), CreateMockRead(*data.get(), 6), | 11660 CreateMockRead(*resp.get(), 5), CreateMockRead(*data.get(), 6), |
11630 MockRead(ASYNC, 0, 0, 7), | 11661 MockRead(ASYNC, 0, 0, 7), |
11631 }; | 11662 }; |
11632 SequencedSocketData data_2(data_reads_2, arraysize(data_reads_2), | 11663 SequencedSocketData data_2(data_reads_2, arraysize(data_reads_2), |
11633 data_writes_2, arraysize(data_writes_2)); | 11664 data_writes_2, arraysize(data_writes_2)); |
11634 | 11665 |
11635 SSLSocketDataProvider ssl(ASYNC, OK); | 11666 SSLSocketDataProvider ssl(ASYNC, OK); |
11636 ssl.SetNextProto(GetParam()); | 11667 ssl.SetNextProto(GetProtocol()); |
11637 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); | 11668 ssl.cert = ImportCertFromFile(GetTestCertsDirectory(), "spdy_pooling.pem"); |
11638 ASSERT_TRUE(ssl.cert.get()); | 11669 ASSERT_TRUE(ssl.cert.get()); |
11639 | 11670 |
11640 MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING); | 11671 MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING); |
11641 StaticSocketDataProvider hanging_non_alternate_protocol_socket( | 11672 StaticSocketDataProvider hanging_non_alternate_protocol_socket( |
11642 NULL, 0, NULL, 0); | 11673 NULL, 0, NULL, 0); |
11643 hanging_non_alternate_protocol_socket.set_connect_data( | 11674 hanging_non_alternate_protocol_socket.set_connect_data( |
11644 never_finishing_connect); | 11675 never_finishing_connect); |
11645 | 11676 |
11646 session_deps_.socket_factory->AddSocketDataProvider(&data_1); | 11677 session_deps_.socket_factory->AddSocketDataProvider(&data_1); |
(...skipping 338 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
11985 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 12016 scoped_ptr<SpdyFrame> data(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
11986 MockRead spdy_reads[] = { | 12017 MockRead spdy_reads[] = { |
11987 CreateMockRead(*resp, 1), CreateMockRead(*data, 2), MockRead(ASYNC, 0, 3), | 12018 CreateMockRead(*resp, 1), CreateMockRead(*data, 2), MockRead(ASYNC, 0, 3), |
11988 }; | 12019 }; |
11989 | 12020 |
11990 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, | 12021 SequencedSocketData spdy_data(spdy_reads, arraysize(spdy_reads), spdy_writes, |
11991 arraysize(spdy_writes)); | 12022 arraysize(spdy_writes)); |
11992 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); | 12023 session_deps_.socket_factory->AddSocketDataProvider(&spdy_data); |
11993 | 12024 |
11994 SSLSocketDataProvider ssl(ASYNC, OK); | 12025 SSLSocketDataProvider ssl(ASYNC, OK); |
11995 ssl.SetNextProto(GetParam()); | 12026 ssl.SetNextProto(GetProtocol()); |
11996 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 12027 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
11997 | 12028 |
11998 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 12029 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
11999 | 12030 |
12000 // Set up an initial SpdySession in the pool to reuse. | 12031 // Set up an initial SpdySession in the pool to reuse. |
12001 HostPortPair host_port_pair("www.example.org", 443); | 12032 HostPortPair host_port_pair("www.example.org", 443); |
12002 SpdySessionKey key(host_port_pair, ProxyServer::Direct(), | 12033 SpdySessionKey key(host_port_pair, ProxyServer::Direct(), |
12003 PRIVACY_MODE_DISABLED); | 12034 PRIVACY_MODE_DISABLED); |
12004 base::WeakPtr<SpdySession> spdy_session = | 12035 base::WeakPtr<SpdySession> spdy_session = |
12005 CreateInsecureSpdySession(session.get(), key, BoundNetLog()); | 12036 CreateInsecureSpdySession(session.get(), key, BoundNetLog()); |
(...skipping 379 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
12385 session_deps_.use_alternative_services = true; | 12416 session_deps_.use_alternative_services = true; |
12386 session_deps_.next_protos = SpdyNextProtos(); | 12417 session_deps_.next_protos = SpdyNextProtos(); |
12387 | 12418 |
12388 // Set up a special HttpNetworkSession with a MockCachingHostResolver. | 12419 // Set up a special HttpNetworkSession with a MockCachingHostResolver. |
12389 session_deps_.host_resolver.reset(new MockCachingHostResolver()); | 12420 session_deps_.host_resolver.reset(new MockCachingHostResolver()); |
12390 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 12421 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
12391 SpdySessionPoolPeer pool_peer(session->spdy_session_pool()); | 12422 SpdySessionPoolPeer pool_peer(session->spdy_session_pool()); |
12392 pool_peer.DisableDomainAuthenticationVerification(); | 12423 pool_peer.DisableDomainAuthenticationVerification(); |
12393 | 12424 |
12394 SSLSocketDataProvider ssl(ASYNC, OK); | 12425 SSLSocketDataProvider ssl(ASYNC, OK); |
12395 ssl.SetNextProto(GetParam()); | 12426 ssl.SetNextProto(GetProtocol()); |
12396 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 12427 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
12397 | 12428 |
12398 scoped_ptr<SpdyFrame> host1_req( | 12429 scoped_ptr<SpdyFrame> host1_req( |
12399 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST)); | 12430 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST)); |
12431 spdy_util_.UpdateWithStreamDestruction(1); | |
12400 scoped_ptr<SpdyFrame> host2_req( | 12432 scoped_ptr<SpdyFrame> host2_req( |
12401 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); | 12433 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); |
12402 MockWrite spdy_writes[] = { | 12434 MockWrite spdy_writes[] = { |
12403 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), | 12435 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), |
12404 }; | 12436 }; |
12405 scoped_ptr<SpdyFrame> host1_resp( | 12437 scoped_ptr<SpdyFrame> host1_resp( |
12406 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 12438 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
12407 scoped_ptr<SpdyFrame> host1_resp_body( | 12439 scoped_ptr<SpdyFrame> host1_resp_body( |
12408 spdy_util_.ConstructSpdyBodyFrame(1, true)); | 12440 spdy_util_.ConstructSpdyBodyFrame(1, true)); |
12409 scoped_ptr<SpdyFrame> host2_resp( | 12441 scoped_ptr<SpdyFrame> host2_resp( |
(...skipping 74 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
12484 session_deps_.use_alternative_services = true; | 12516 session_deps_.use_alternative_services = true; |
12485 session_deps_.next_protos = SpdyNextProtos(); | 12517 session_deps_.next_protos = SpdyNextProtos(); |
12486 | 12518 |
12487 // Set up a special HttpNetworkSession with a MockCachingHostResolver. | 12519 // Set up a special HttpNetworkSession with a MockCachingHostResolver. |
12488 session_deps_.host_resolver.reset(new MockCachingHostResolver()); | 12520 session_deps_.host_resolver.reset(new MockCachingHostResolver()); |
12489 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 12521 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
12490 SpdySessionPoolPeer pool_peer(session->spdy_session_pool()); | 12522 SpdySessionPoolPeer pool_peer(session->spdy_session_pool()); |
12491 pool_peer.DisableDomainAuthenticationVerification(); | 12523 pool_peer.DisableDomainAuthenticationVerification(); |
12492 | 12524 |
12493 SSLSocketDataProvider ssl(ASYNC, OK); | 12525 SSLSocketDataProvider ssl(ASYNC, OK); |
12494 ssl.SetNextProto(GetParam()); | 12526 ssl.SetNextProto(GetProtocol()); |
12495 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 12527 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
12496 | 12528 |
12497 scoped_ptr<SpdyFrame> host1_req( | 12529 scoped_ptr<SpdyFrame> host1_req( |
12498 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST)); | 12530 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST)); |
12531 spdy_util_.UpdateWithStreamDestruction(1); | |
12499 scoped_ptr<SpdyFrame> host2_req( | 12532 scoped_ptr<SpdyFrame> host2_req( |
12500 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); | 12533 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); |
12501 MockWrite spdy_writes[] = { | 12534 MockWrite spdy_writes[] = { |
12502 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), | 12535 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), |
12503 }; | 12536 }; |
12504 scoped_ptr<SpdyFrame> host1_resp( | 12537 scoped_ptr<SpdyFrame> host1_resp( |
12505 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 12538 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
12506 scoped_ptr<SpdyFrame> host1_resp_body( | 12539 scoped_ptr<SpdyFrame> host1_resp_body( |
12507 spdy_util_.ConstructSpdyBodyFrame(1, true)); | 12540 spdy_util_.ConstructSpdyBodyFrame(1, true)); |
12508 scoped_ptr<SpdyFrame> host2_resp( | 12541 scoped_ptr<SpdyFrame> host2_resp( |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
12614 // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver. | 12647 // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver. |
12615 OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443)); | 12648 OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443)); |
12616 HttpNetworkSession::Params params = | 12649 HttpNetworkSession::Params params = |
12617 SpdySessionDependencies::CreateSessionParams(&session_deps_); | 12650 SpdySessionDependencies::CreateSessionParams(&session_deps_); |
12618 params.host_resolver = &host_resolver; | 12651 params.host_resolver = &host_resolver; |
12619 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 12652 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
12620 SpdySessionPoolPeer pool_peer(session->spdy_session_pool()); | 12653 SpdySessionPoolPeer pool_peer(session->spdy_session_pool()); |
12621 pool_peer.DisableDomainAuthenticationVerification(); | 12654 pool_peer.DisableDomainAuthenticationVerification(); |
12622 | 12655 |
12623 SSLSocketDataProvider ssl(ASYNC, OK); | 12656 SSLSocketDataProvider ssl(ASYNC, OK); |
12624 ssl.SetNextProto(GetParam()); | 12657 ssl.SetNextProto(GetProtocol()); |
12625 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 12658 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
12626 | 12659 |
12627 scoped_ptr<SpdyFrame> host1_req( | 12660 scoped_ptr<SpdyFrame> host1_req( |
12628 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST)); | 12661 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST)); |
12662 spdy_util_.UpdateWithStreamDestruction(1); | |
12629 scoped_ptr<SpdyFrame> host2_req( | 12663 scoped_ptr<SpdyFrame> host2_req( |
12630 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); | 12664 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); |
12631 MockWrite spdy_writes[] = { | 12665 MockWrite spdy_writes[] = { |
12632 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), | 12666 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), |
12633 }; | 12667 }; |
12634 scoped_ptr<SpdyFrame> host1_resp( | 12668 scoped_ptr<SpdyFrame> host1_resp( |
12635 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 12669 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
12636 scoped_ptr<SpdyFrame> host1_resp_body( | 12670 scoped_ptr<SpdyFrame> host1_resp_body( |
12637 spdy_util_.ConstructSpdyBodyFrame(1, true)); | 12671 spdy_util_.ConstructSpdyBodyFrame(1, true)); |
12638 scoped_ptr<SpdyFrame> host2_resp( | 12672 scoped_ptr<SpdyFrame> host2_resp( |
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
12744 MockRead reads2[] = { | 12778 MockRead reads2[] = { |
12745 MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"), | 12779 MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"), |
12746 MockRead(ASYNC, 2, "hello"), | 12780 MockRead(ASYNC, 2, "hello"), |
12747 MockRead(ASYNC, OK, 3), | 12781 MockRead(ASYNC, OK, 3), |
12748 }; | 12782 }; |
12749 | 12783 |
12750 SequencedSocketData data2(reads2, arraysize(reads2), writes2, | 12784 SequencedSocketData data2(reads2, arraysize(reads2), writes2, |
12751 arraysize(writes2)); | 12785 arraysize(writes2)); |
12752 | 12786 |
12753 SSLSocketDataProvider ssl(ASYNC, OK); | 12787 SSLSocketDataProvider ssl(ASYNC, OK); |
12754 ssl.SetNextProto(GetParam()); | 12788 ssl.SetNextProto(GetProtocol()); |
12755 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 12789 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
12756 session_deps_.socket_factory->AddSocketDataProvider(&data1); | 12790 session_deps_.socket_factory->AddSocketDataProvider(&data1); |
12757 session_deps_.socket_factory->AddSocketDataProvider(&data2); | 12791 session_deps_.socket_factory->AddSocketDataProvider(&data2); |
12758 | 12792 |
12759 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 12793 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
12760 | 12794 |
12761 // Start the first transaction to set up the SpdySession | 12795 // Start the first transaction to set up the SpdySession |
12762 HttpRequestInfo request1; | 12796 HttpRequestInfo request1; |
12763 request1.method = "GET"; | 12797 request1.method = "GET"; |
12764 request1.url = GURL(https_url); | 12798 request1.url = GURL(https_url); |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
12797 base::FilePath certs_dir = GetTestCertsDirectory(); | 12831 base::FilePath certs_dir = GetTestCertsDirectory(); |
12798 scoped_refptr<X509Certificate> cert( | 12832 scoped_refptr<X509Certificate> cert( |
12799 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); | 12833 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); |
12800 ASSERT_TRUE(cert.get()); | 12834 ASSERT_TRUE(cert.get()); |
12801 bool common_name_fallback_used; | 12835 bool common_name_fallback_used; |
12802 EXPECT_EQ(valid, | 12836 EXPECT_EQ(valid, |
12803 cert->VerifyNameMatch(origin.host(), &common_name_fallback_used)); | 12837 cert->VerifyNameMatch(origin.host(), &common_name_fallback_used)); |
12804 EXPECT_TRUE( | 12838 EXPECT_TRUE( |
12805 cert->VerifyNameMatch(alternative.host(), &common_name_fallback_used)); | 12839 cert->VerifyNameMatch(alternative.host(), &common_name_fallback_used)); |
12806 SSLSocketDataProvider ssl(ASYNC, OK); | 12840 SSLSocketDataProvider ssl(ASYNC, OK); |
12807 ssl.SetNextProto(GetParam()); | 12841 ssl.SetNextProto(GetProtocol()); |
12808 ssl.cert = cert; | 12842 ssl.cert = cert; |
12809 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); | 12843 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); |
12810 | 12844 |
12811 // If pooling, then start a request to alternative first to create a | 12845 // If pooling, then start a request to alternative first to create a |
12812 // SpdySession. | 12846 // SpdySession. |
12813 std::string url0 = "https://www.example.org:443"; | 12847 std::string url0 = "https://www.example.org:443"; |
12814 // Second request to origin, which has an alternative service, and could | 12848 // Second request to origin, which has an alternative service, and could |
12815 // open a connection to the alternative host or pool to the existing one. | 12849 // open a connection to the alternative host or pool to the existing one. |
12816 std::string url1("https://"); | 12850 std::string url1("https://"); |
12817 url1.append(origin.host()); | 12851 url1.append(origin.host()); |
12818 url1.append(":443"); | 12852 url1.append(":443"); |
12819 | 12853 |
12820 scoped_ptr<SpdyFrame> req0; | 12854 scoped_ptr<SpdyFrame> req0; |
12821 scoped_ptr<SpdyFrame> req1; | 12855 scoped_ptr<SpdyFrame> req1; |
12822 scoped_ptr<SpdyFrame> resp0; | 12856 scoped_ptr<SpdyFrame> resp0; |
12823 scoped_ptr<SpdyFrame> body0; | 12857 scoped_ptr<SpdyFrame> body0; |
12824 scoped_ptr<SpdyFrame> resp1; | 12858 scoped_ptr<SpdyFrame> resp1; |
12825 scoped_ptr<SpdyFrame> body1; | 12859 scoped_ptr<SpdyFrame> body1; |
12826 std::vector<MockWrite> writes; | 12860 std::vector<MockWrite> writes; |
12827 std::vector<MockRead> reads; | 12861 std::vector<MockRead> reads; |
12828 | 12862 |
12829 if (pooling) { | 12863 if (pooling) { |
12830 req0.reset(spdy_util_.ConstructSpdyGet(url0.c_str(), false, 1, LOWEST)); | 12864 req0.reset(spdy_util_.ConstructSpdyGet(url0.c_str(), false, 1, LOWEST)); |
12865 spdy_util_.UpdateWithStreamDestruction(1); | |
12831 req1.reset(spdy_util_.ConstructSpdyGet(url1.c_str(), false, 3, LOWEST)); | 12866 req1.reset(spdy_util_.ConstructSpdyGet(url1.c_str(), false, 3, LOWEST)); |
12832 | 12867 |
12833 writes.push_back(CreateMockWrite(*req0, 0)); | 12868 writes.push_back(CreateMockWrite(*req0, 0)); |
12834 writes.push_back(CreateMockWrite(*req1, 3)); | 12869 writes.push_back(CreateMockWrite(*req1, 3)); |
12835 | 12870 |
12836 resp0.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 12871 resp0.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
12837 body0.reset(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 12872 body0.reset(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
12838 resp1.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); | 12873 resp1.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
12839 body1.reset(spdy_util_.ConstructSpdyBodyFrame(3, true)); | 12874 body1.reset(spdy_util_.ConstructSpdyBodyFrame(3, true)); |
12840 | 12875 |
(...skipping 24 matching lines...) Expand all Loading... | |
12865 MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED); | 12900 MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED); |
12866 StaticSocketDataProvider data_refused; | 12901 StaticSocketDataProvider data_refused; |
12867 data_refused.set_connect_data(mock_connect); | 12902 data_refused.set_connect_data(mock_connect); |
12868 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); | 12903 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); |
12869 | 12904 |
12870 session_deps_.use_alternative_services = true; | 12905 session_deps_.use_alternative_services = true; |
12871 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 12906 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
12872 base::WeakPtr<HttpServerProperties> http_server_properties = | 12907 base::WeakPtr<HttpServerProperties> http_server_properties = |
12873 session->http_server_properties(); | 12908 session->http_server_properties(); |
12874 AlternativeService alternative_service( | 12909 AlternativeService alternative_service( |
12875 AlternateProtocolFromNextProto(GetParam()), alternative); | 12910 AlternateProtocolFromNextProto(GetProtocol()), alternative); |
12876 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 12911 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
12877 http_server_properties->SetAlternativeService(origin, alternative_service, | 12912 http_server_properties->SetAlternativeService(origin, alternative_service, |
12878 1.0, expiration); | 12913 1.0, expiration); |
12879 | 12914 |
12880 // First request to alternative. | 12915 // First request to alternative. |
12881 if (pooling) { | 12916 if (pooling) { |
12882 scoped_ptr<HttpTransaction> trans0( | 12917 scoped_ptr<HttpTransaction> trans0( |
12883 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 12918 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
12884 HttpRequestInfo request0; | 12919 HttpRequestInfo request0; |
12885 request0.method = "GET"; | 12920 request0.method = "GET"; |
(...skipping 28 matching lines...) Expand all Loading... | |
12914 } else { | 12949 } else { |
12915 if (pooling) { | 12950 if (pooling) { |
12916 EXPECT_EQ(ERR_CONNECTION_REFUSED, rv); | 12951 EXPECT_EQ(ERR_CONNECTION_REFUSED, rv); |
12917 } else { | 12952 } else { |
12918 EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv); | 12953 EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv); |
12919 } | 12954 } |
12920 } | 12955 } |
12921 } | 12956 } |
12922 }; | 12957 }; |
12923 | 12958 |
12924 INSTANTIATE_TEST_CASE_P(NextProto, | 12959 INSTANTIATE_TEST_CASE_P(ProtoPlusDepend, |
12925 AltSvcCertificateVerificationTest, | 12960 AltSvcCertificateVerificationTest, |
12926 testing::Values(kProtoSPDY31, | 12961 testing::Values(kTestCaseSPDY31, |
12927 kProtoHTTP2)); | 12962 kTestCaseHTTP2NoPriorityDependencies, |
12963 kTestCaseHTTP2PriorityDependencies)); | |
12928 | 12964 |
12929 // The alternative service host must exhibit a certificate that is valid for the | 12965 // The alternative service host must exhibit a certificate that is valid for the |
12930 // origin host. Test that this is enforced when pooling to an existing | 12966 // origin host. Test that this is enforced when pooling to an existing |
12931 // connection. | 12967 // connection. |
12932 TEST_P(AltSvcCertificateVerificationTest, PoolingValid) { | 12968 TEST_P(AltSvcCertificateVerificationTest, PoolingValid) { |
12933 Run(true, true); | 12969 Run(true, true); |
12934 } | 12970 } |
12935 | 12971 |
12936 TEST_P(AltSvcCertificateVerificationTest, PoolingInvalid) { | 12972 TEST_P(AltSvcCertificateVerificationTest, PoolingInvalid) { |
12937 Run(true, false); | 12973 Run(true, false); |
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
12969 StaticSocketDataProvider data_refused; | 13005 StaticSocketDataProvider data_refused; |
12970 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED)); | 13006 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED)); |
12971 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); | 13007 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); |
12972 | 13008 |
12973 // Set up alternative service for origin. | 13009 // Set up alternative service for origin. |
12974 session_deps_.use_alternative_services = true; | 13010 session_deps_.use_alternative_services = true; |
12975 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 13011 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
12976 base::WeakPtr<HttpServerProperties> http_server_properties = | 13012 base::WeakPtr<HttpServerProperties> http_server_properties = |
12977 session->http_server_properties(); | 13013 session->http_server_properties(); |
12978 AlternativeService alternative_service( | 13014 AlternativeService alternative_service( |
12979 AlternateProtocolFromNextProto(GetParam()), alternative); | 13015 AlternateProtocolFromNextProto(GetProtocol()), alternative); |
12980 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 13016 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
12981 http_server_properties->SetAlternativeService(origin, alternative_service, | 13017 http_server_properties->SetAlternativeService(origin, alternative_service, |
12982 1.0, expiration); | 13018 1.0, expiration); |
12983 | 13019 |
12984 scoped_ptr<HttpTransaction> trans( | 13020 scoped_ptr<HttpTransaction> trans( |
12985 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 13021 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
12986 HttpRequestInfo request; | 13022 HttpRequestInfo request; |
12987 request.method = "GET"; | 13023 request.method = "GET"; |
12988 request.url = GURL("https://origin.example.org:443"); | 13024 request.url = GURL("https://origin.example.org:443"); |
12989 request.load_flags = 0; | 13025 request.load_flags = 0; |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
13042 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), | 13078 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), |
13043 http_writes, arraysize(http_writes)); | 13079 http_writes, arraysize(http_writes)); |
13044 session_deps_.socket_factory->AddSocketDataProvider(&http_data); | 13080 session_deps_.socket_factory->AddSocketDataProvider(&http_data); |
13045 | 13081 |
13046 // Set up alternative service for origin. | 13082 // Set up alternative service for origin. |
13047 session_deps_.use_alternative_services = true; | 13083 session_deps_.use_alternative_services = true; |
13048 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 13084 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
13049 base::WeakPtr<HttpServerProperties> http_server_properties = | 13085 base::WeakPtr<HttpServerProperties> http_server_properties = |
13050 session->http_server_properties(); | 13086 session->http_server_properties(); |
13051 AlternativeService alternative_service( | 13087 AlternativeService alternative_service( |
13052 AlternateProtocolFromNextProto(GetParam()), alternative); | 13088 AlternateProtocolFromNextProto(GetProtocol()), alternative); |
13053 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 13089 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
13054 http_server_properties->SetAlternativeService(origin, alternative_service, | 13090 http_server_properties->SetAlternativeService(origin, alternative_service, |
13055 1.0, expiration); | 13091 1.0, expiration); |
13056 | 13092 |
13057 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); | 13093 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); |
13058 HttpRequestInfo request1; | 13094 HttpRequestInfo request1; |
13059 request1.method = "GET"; | 13095 request1.method = "GET"; |
13060 request1.url = GURL("https://origin.example.org:443"); | 13096 request1.url = GURL("https://origin.example.org:443"); |
13061 request1.load_flags = 0; | 13097 request1.load_flags = 0; |
13062 TestCompletionCallback callback1; | 13098 TestCompletionCallback callback1; |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
13151 StaticSocketDataProvider data_refused; | 13187 StaticSocketDataProvider data_refused; |
13152 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED)); | 13188 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED)); |
13153 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); | 13189 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); |
13154 | 13190 |
13155 // Set up alternative service for origin. | 13191 // Set up alternative service for origin. |
13156 session_deps_.use_alternative_services = true; | 13192 session_deps_.use_alternative_services = true; |
13157 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 13193 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
13158 base::WeakPtr<HttpServerProperties> http_server_properties = | 13194 base::WeakPtr<HttpServerProperties> http_server_properties = |
13159 session->http_server_properties(); | 13195 session->http_server_properties(); |
13160 AlternativeService alternative_service( | 13196 AlternativeService alternative_service( |
13161 AlternateProtocolFromNextProto(GetParam()), alternative); | 13197 AlternateProtocolFromNextProto(GetProtocol()), alternative); |
13162 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); | 13198 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); |
13163 http_server_properties->SetAlternativeService(origin, alternative_service, | 13199 http_server_properties->SetAlternativeService(origin, alternative_service, |
13164 1.0, expiration); | 13200 1.0, expiration); |
13165 | 13201 |
13166 // First transaction to alternative to open an HTTP/1.1 socket. | 13202 // First transaction to alternative to open an HTTP/1.1 socket. |
13167 scoped_ptr<HttpTransaction> trans1( | 13203 scoped_ptr<HttpTransaction> trans1( |
13168 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); | 13204 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); |
13169 HttpRequestInfo request1; | 13205 HttpRequestInfo request1; |
13170 request1.method = "GET"; | 13206 request1.method = "GET"; |
13171 request1.url = GURL(alternative_url); | 13207 request1.url = GURL(alternative_url); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
13220 EXPECT_FALSE(response3->was_fetched_via_spdy); | 13256 EXPECT_FALSE(response3->was_fetched_via_spdy); |
13221 std::string response_data3; | 13257 std::string response_data3; |
13222 ASSERT_EQ(OK, ReadTransaction(trans3.get(), &response_data3)); | 13258 ASSERT_EQ(OK, ReadTransaction(trans3.get(), &response_data3)); |
13223 EXPECT_EQ("second HTTP/1.1 response from alternative", response_data3); | 13259 EXPECT_EQ("second HTTP/1.1 response from alternative", response_data3); |
13224 } | 13260 } |
13225 | 13261 |
13226 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionForHttpOverTunnel) { | 13262 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionForHttpOverTunnel) { |
13227 const std::string https_url = "https://www.example.org:8080/"; | 13263 const std::string https_url = "https://www.example.org:8080/"; |
13228 const std::string http_url = "http://www.example.org:8080/"; | 13264 const std::string http_url = "http://www.example.org:8080/"; |
13229 | 13265 |
13266 // Separate SPDY util classes for naked and wrapped requests. | |
13267 SpdyTestUtil spdy_util_wrapped(GetProtocol(), GetDependenciesFromPriority()); | |
13268 | |
13230 // SPDY GET for HTTPS URL (through CONNECT tunnel) | 13269 // SPDY GET for HTTPS URL (through CONNECT tunnel) |
13231 const HostPortPair host_port_pair("www.example.org", 8080); | 13270 const HostPortPair host_port_pair("www.example.org", 8080); |
13232 scoped_ptr<SpdyFrame> connect( | 13271 scoped_ptr<SpdyFrame> connect( |
13233 spdy_util_.ConstructSpdyConnect(NULL, 0, 1, LOWEST, host_port_pair)); | 13272 spdy_util_.ConstructSpdyConnect(NULL, 0, 1, LOWEST, host_port_pair)); |
13234 scoped_ptr<SpdyFrame> req1( | 13273 scoped_ptr<SpdyFrame> req1( |
13235 spdy_util_.ConstructSpdyGet(https_url.c_str(), false, 1, LOWEST)); | 13274 spdy_util_wrapped.ConstructSpdyGet(https_url.c_str(), false, 1, LOWEST)); |
13236 scoped_ptr<SpdyFrame> wrapped_req1( | 13275 scoped_ptr<SpdyFrame> wrapped_req1( |
13237 spdy_util_.ConstructWrappedSpdyFrame(req1, 1)); | 13276 spdy_util_.ConstructWrappedSpdyFrame(req1, 1)); |
13238 | 13277 |
13239 // SPDY GET for HTTP URL (through the proxy, but not the tunnel). | 13278 // SPDY GET for HTTP URL (through the proxy, but not the tunnel). |
13240 SpdyHeaderBlock req2_block; | 13279 SpdyHeaderBlock req2_block; |
13241 spdy_util_.MaybeAddVersionHeader(&req2_block); | 13280 spdy_util_.MaybeAddVersionHeader(&req2_block); |
13242 req2_block[spdy_util_.GetMethodKey()] = "GET"; | 13281 req2_block[spdy_util_.GetMethodKey()] = "GET"; |
13243 req2_block[spdy_util_.GetHostKey()] = "www.example.org:8080"; | 13282 req2_block[spdy_util_.GetHostKey()] = "www.example.org:8080"; |
13244 req2_block[spdy_util_.GetSchemeKey()] = "http"; | 13283 req2_block[spdy_util_.GetSchemeKey()] = "http"; |
13245 req2_block[spdy_util_.GetPathKey()] = "/"; | 13284 req2_block[spdy_util_.GetPathKey()] = "/"; |
13246 scoped_ptr<SpdyFrame> req2( | 13285 scoped_ptr<SpdyFrame> req2( |
13247 spdy_util_.ConstructSpdySyn(3, req2_block, MEDIUM, false, true)); | 13286 spdy_util_.ConstructSpdySyn(3, req2_block, MEDIUM, false, true)); |
13248 | 13287 |
13249 MockWrite writes1[] = { | 13288 MockWrite writes1[] = { |
13250 CreateMockWrite(*connect, 0), | 13289 CreateMockWrite(*connect, 0), |
13251 CreateMockWrite(*wrapped_req1, 2), | 13290 CreateMockWrite(*wrapped_req1, 2), |
13252 CreateMockWrite(*req2, 5), | 13291 CreateMockWrite(*req2, 5), |
13253 }; | 13292 }; |
13254 | 13293 |
13255 scoped_ptr<SpdyFrame> conn_resp( | 13294 scoped_ptr<SpdyFrame> conn_resp( |
13256 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 13295 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
13257 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 13296 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
13258 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 13297 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
13259 scoped_ptr<SpdyFrame> wrapped_resp1( | 13298 scoped_ptr<SpdyFrame> wrapped_resp1( |
13260 spdy_util_.ConstructWrappedSpdyFrame(resp1, 1)); | 13299 spdy_util_wrapped.ConstructWrappedSpdyFrame(resp1, 1)); |
13261 scoped_ptr<SpdyFrame> wrapped_body1( | 13300 scoped_ptr<SpdyFrame> wrapped_body1( |
13262 spdy_util_.ConstructWrappedSpdyFrame(body1, 1)); | 13301 spdy_util_wrapped.ConstructWrappedSpdyFrame(body1, 1)); |
13263 scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); | 13302 scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); |
13264 scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true)); | 13303 scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true)); |
13265 MockRead reads1[] = { | 13304 MockRead reads1[] = { |
13266 CreateMockRead(*conn_resp, 1), | 13305 CreateMockRead(*conn_resp, 1), |
13267 CreateMockRead(*wrapped_resp1, 3), | 13306 CreateMockRead(*wrapped_resp1, 3), |
13268 CreateMockRead(*wrapped_body1, 4), | 13307 CreateMockRead(*wrapped_body1, 4), |
13269 CreateMockRead(*resp2, 6), | 13308 CreateMockRead(*resp2, 6), |
13270 CreateMockRead(*body2, 7), | 13309 CreateMockRead(*body2, 7), |
13271 MockRead(ASYNC, ERR_IO_PENDING, 8) | 13310 MockRead(ASYNC, ERR_IO_PENDING, 8) |
13272 }; | 13311 }; |
13273 | 13312 |
13274 DeterministicSocketData data1(reads1, arraysize(reads1), | 13313 DeterministicSocketData data1(reads1, arraysize(reads1), |
13275 writes1, arraysize(writes1)); | 13314 writes1, arraysize(writes1)); |
13276 MockConnect connect_data1(ASYNC, OK); | 13315 MockConnect connect_data1(ASYNC, OK); |
13277 data1.set_connect_data(connect_data1); | 13316 data1.set_connect_data(connect_data1); |
13278 | 13317 |
13279 session_deps_.proxy_service = | 13318 session_deps_.proxy_service = |
13280 ProxyService::CreateFixedFromPacResult("HTTPS proxy:70"); | 13319 ProxyService::CreateFixedFromPacResult("HTTPS proxy:70"); |
13281 TestNetLog log; | 13320 TestNetLog log; |
13282 session_deps_.net_log = &log; | 13321 session_deps_.net_log = &log; |
13283 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy | 13322 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy |
13284 ssl1.SetNextProto(GetParam()); | 13323 ssl1.SetNextProto(GetProtocol()); |
13285 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1); | 13324 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1); |
13286 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server | 13325 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server |
13287 ssl2.SetNextProto(GetParam()); | 13326 ssl2.SetNextProto(GetProtocol()); |
13288 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2); | 13327 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2); |
13289 session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data1); | 13328 session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data1); |
13290 | 13329 |
13291 scoped_ptr<HttpNetworkSession> session( | 13330 scoped_ptr<HttpNetworkSession> session( |
13292 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_)); | 13331 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_)); |
13293 | 13332 |
13294 // Start the first transaction to set up the SpdySession | 13333 // Start the first transaction to set up the SpdySession |
13295 HttpRequestInfo request1; | 13334 HttpRequestInfo request1; |
13296 request1.method = "GET"; | 13335 request1.method = "GET"; |
13297 request1.url = GURL(https_url); | 13336 request1.url = GURL(https_url); |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
13337 | 13376 |
13338 // Test that in the case where we have a SPDY session to a SPDY proxy | 13377 // Test that in the case where we have a SPDY session to a SPDY proxy |
13339 // that we do not pool other origins that resolve to the same IP when | 13378 // that we do not pool other origins that resolve to the same IP when |
13340 // the certificate does not match the new origin. | 13379 // the certificate does not match the new origin. |
13341 // http://crbug.com/134690 | 13380 // http://crbug.com/134690 |
13342 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionIfCertDoesNotMatch) { | 13381 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionIfCertDoesNotMatch) { |
13343 const std::string url1 = "http://www.example.org/"; | 13382 const std::string url1 = "http://www.example.org/"; |
13344 const std::string url2 = "https://news.example.org/"; | 13383 const std::string url2 = "https://news.example.org/"; |
13345 const std::string ip_addr = "1.2.3.4"; | 13384 const std::string ip_addr = "1.2.3.4"; |
13346 | 13385 |
13386 // Second SpdyTestUtil instance for the second socket. | |
13387 SpdyTestUtil spdy_util_secure(GetProtocol(), GetDependenciesFromPriority()); | |
13388 | |
13347 // SPDY GET for HTTP URL (through SPDY proxy) | 13389 // SPDY GET for HTTP URL (through SPDY proxy) |
13348 scoped_ptr<SpdyHeaderBlock> headers( | 13390 scoped_ptr<SpdyHeaderBlock> headers( |
13349 spdy_util_.ConstructGetHeaderBlockForProxy("http://www.example.org/")); | 13391 spdy_util_.ConstructGetHeaderBlockForProxy("http://www.example.org/")); |
13350 scoped_ptr<SpdyFrame> req1( | 13392 scoped_ptr<SpdyFrame> req1( |
13351 spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true)); | 13393 spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true)); |
13352 | 13394 |
13353 MockWrite writes1[] = { | 13395 MockWrite writes1[] = { |
13354 CreateMockWrite(*req1, 0), | 13396 CreateMockWrite(*req1, 0), |
13355 }; | 13397 }; |
13356 | 13398 |
13357 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 13399 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
13358 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 13400 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true)); |
13359 MockRead reads1[] = { | 13401 MockRead reads1[] = { |
13360 CreateMockRead(*resp1, 1), | 13402 CreateMockRead(*resp1, 1), |
13361 CreateMockRead(*body1, 2), | 13403 CreateMockRead(*body1, 2), |
13362 MockRead(ASYNC, OK, 3) // EOF | 13404 MockRead(ASYNC, OK, 3) // EOF |
13363 }; | 13405 }; |
13364 | 13406 |
13365 scoped_ptr<DeterministicSocketData> data1( | 13407 scoped_ptr<DeterministicSocketData> data1( |
13366 new DeterministicSocketData(reads1, arraysize(reads1), | 13408 new DeterministicSocketData(reads1, arraysize(reads1), |
13367 writes1, arraysize(writes1))); | 13409 writes1, arraysize(writes1))); |
13368 IPAddressNumber ip; | 13410 IPAddressNumber ip; |
13369 ASSERT_TRUE(ParseIPLiteralToNumber(ip_addr, &ip)); | 13411 ASSERT_TRUE(ParseIPLiteralToNumber(ip_addr, &ip)); |
13370 IPEndPoint peer_addr = IPEndPoint(ip, 443); | 13412 IPEndPoint peer_addr = IPEndPoint(ip, 443); |
13371 MockConnect connect_data1(ASYNC, OK, peer_addr); | 13413 MockConnect connect_data1(ASYNC, OK, peer_addr); |
13372 data1->set_connect_data(connect_data1); | 13414 data1->set_connect_data(connect_data1); |
13373 | 13415 |
13374 // SPDY GET for HTTPS URL (direct) | 13416 // SPDY GET for HTTPS URL (direct) |
13375 scoped_ptr<SpdyFrame> req2( | 13417 scoped_ptr<SpdyFrame> req2( |
13376 spdy_util_.ConstructSpdyGet(url2.c_str(), false, 1, MEDIUM)); | 13418 spdy_util_secure.ConstructSpdyGet(url2.c_str(), false, 1, MEDIUM)); |
13377 | 13419 |
13378 MockWrite writes2[] = { | 13420 MockWrite writes2[] = { |
13379 CreateMockWrite(*req2, 0), | 13421 CreateMockWrite(*req2, 0), |
13380 }; | 13422 }; |
13381 | 13423 |
13382 scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 13424 scoped_ptr<SpdyFrame> resp2( |
13383 scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true)); | 13425 spdy_util_secure.ConstructSpdyGetSynReply(NULL, 0, 1)); |
13426 scoped_ptr<SpdyFrame> body2(spdy_util_secure.ConstructSpdyBodyFrame(1, true)); | |
13384 MockRead reads2[] = { | 13427 MockRead reads2[] = { |
13385 CreateMockRead(*resp2, 1), | 13428 CreateMockRead(*resp2, 1), |
13386 CreateMockRead(*body2, 2), | 13429 CreateMockRead(*body2, 2), |
13387 MockRead(ASYNC, OK, 3) // EOF | 13430 MockRead(ASYNC, OK, 3) // EOF |
13388 }; | 13431 }; |
13389 | 13432 |
13390 scoped_ptr<DeterministicSocketData> data2( | 13433 scoped_ptr<DeterministicSocketData> data2( |
13391 new DeterministicSocketData(reads2, arraysize(reads2), | 13434 new DeterministicSocketData(reads2, arraysize(reads2), |
13392 writes2, arraysize(writes2))); | 13435 writes2, arraysize(writes2))); |
13393 MockConnect connect_data2(ASYNC, OK); | 13436 MockConnect connect_data2(ASYNC, OK); |
13394 data2->set_connect_data(connect_data2); | 13437 data2->set_connect_data(connect_data2); |
13395 | 13438 |
13396 // Set up a proxy config that sends HTTP requests to a proxy, and | 13439 // Set up a proxy config that sends HTTP requests to a proxy, and |
13397 // all others direct. | 13440 // all others direct. |
13398 ProxyConfig proxy_config; | 13441 ProxyConfig proxy_config; |
13399 proxy_config.proxy_rules().ParseFromString("http=https://proxy:443"); | 13442 proxy_config.proxy_rules().ParseFromString("http=https://proxy:443"); |
13400 session_deps_.proxy_service.reset(new ProxyService( | 13443 session_deps_.proxy_service.reset(new ProxyService( |
13401 make_scoped_ptr(new ProxyConfigServiceFixed(proxy_config)), nullptr, | 13444 make_scoped_ptr(new ProxyConfigServiceFixed(proxy_config)), nullptr, |
13402 NULL)); | 13445 NULL)); |
13403 | 13446 |
13404 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy | 13447 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy |
13405 ssl1.SetNextProto(GetParam()); | 13448 ssl1.SetNextProto(GetProtocol()); |
13406 // Load a valid cert. Note, that this does not need to | 13449 // Load a valid cert. Note, that this does not need to |
13407 // be valid for proxy because the MockSSLClientSocket does | 13450 // be valid for proxy because the MockSSLClientSocket does |
13408 // not actually verify it. But SpdySession will use this | 13451 // not actually verify it. But SpdySession will use this |
13409 // to see if it is valid for the new origin | 13452 // to see if it is valid for the new origin |
13410 ssl1.cert = ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem"); | 13453 ssl1.cert = ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem"); |
13411 ASSERT_TRUE(ssl1.cert.get()); | 13454 ASSERT_TRUE(ssl1.cert.get()); |
13412 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1); | 13455 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1); |
13413 session_deps_.deterministic_socket_factory->AddSocketDataProvider( | 13456 session_deps_.deterministic_socket_factory->AddSocketDataProvider( |
13414 data1.get()); | 13457 data1.get()); |
13415 | 13458 |
13416 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server | 13459 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server |
13417 ssl2.SetNextProto(GetParam()); | 13460 ssl2.SetNextProto(GetProtocol()); |
13418 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2); | 13461 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2); |
13419 session_deps_.deterministic_socket_factory->AddSocketDataProvider( | 13462 session_deps_.deterministic_socket_factory->AddSocketDataProvider( |
13420 data2.get()); | 13463 data2.get()); |
13421 | 13464 |
13422 session_deps_.host_resolver.reset(new MockCachingHostResolver()); | 13465 session_deps_.host_resolver.reset(new MockCachingHostResolver()); |
13423 session_deps_.host_resolver->rules()->AddRule("news.example.org", ip_addr); | 13466 session_deps_.host_resolver->rules()->AddRule("news.example.org", ip_addr); |
13424 session_deps_.host_resolver->rules()->AddRule("proxy", ip_addr); | 13467 session_deps_.host_resolver->rules()->AddRule("proxy", ip_addr); |
13425 | 13468 |
13426 scoped_ptr<HttpNetworkSession> session( | 13469 scoped_ptr<HttpNetworkSession> session( |
13427 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_)); | 13470 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_)); |
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
13482 MockRead reads2[] = { | 13525 MockRead reads2[] = { |
13483 CreateMockRead(*resp2, 1), | 13526 CreateMockRead(*resp2, 1), |
13484 CreateMockRead(*body2, 2), | 13527 CreateMockRead(*body2, 2), |
13485 MockRead(ASYNC, OK, 3) // EOF | 13528 MockRead(ASYNC, OK, 3) // EOF |
13486 }; | 13529 }; |
13487 | 13530 |
13488 SequencedSocketData data2(reads2, arraysize(reads2), writes2, | 13531 SequencedSocketData data2(reads2, arraysize(reads2), writes2, |
13489 arraysize(writes2)); | 13532 arraysize(writes2)); |
13490 | 13533 |
13491 SSLSocketDataProvider ssl1(ASYNC, OK); | 13534 SSLSocketDataProvider ssl1(ASYNC, OK); |
13492 ssl1.SetNextProto(GetParam()); | 13535 ssl1.SetNextProto(GetProtocol()); |
13493 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); | 13536 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); |
13494 session_deps_.socket_factory->AddSocketDataProvider(&data1); | 13537 session_deps_.socket_factory->AddSocketDataProvider(&data1); |
13495 | 13538 |
13496 SSLSocketDataProvider ssl2(ASYNC, OK); | 13539 SSLSocketDataProvider ssl2(ASYNC, OK); |
13497 ssl2.SetNextProto(GetParam()); | 13540 ssl2.SetNextProto(GetProtocol()); |
13498 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 13541 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
13499 session_deps_.socket_factory->AddSocketDataProvider(&data2); | 13542 session_deps_.socket_factory->AddSocketDataProvider(&data2); |
13500 | 13543 |
13501 scoped_ptr<HttpNetworkSession> session( | 13544 scoped_ptr<HttpNetworkSession> session( |
13502 SpdySessionDependencies::SpdyCreateSession(&session_deps_)); | 13545 SpdySessionDependencies::SpdyCreateSession(&session_deps_)); |
13503 | 13546 |
13504 // Start the first transaction to set up the SpdySession and verify that | 13547 // Start the first transaction to set up the SpdySession and verify that |
13505 // connection was closed. | 13548 // connection was closed. |
13506 HttpRequestInfo request1; | 13549 HttpRequestInfo request1; |
13507 request1.method = "GET"; | 13550 request1.method = "GET"; |
(...skipping 25 matching lines...) Expand all Loading... | |
13533 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); | 13576 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); |
13534 ClientSocketPoolManager::set_max_sockets_per_pool( | 13577 ClientSocketPoolManager::set_max_sockets_per_pool( |
13535 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); | 13578 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); |
13536 | 13579 |
13537 // Use two different hosts with different IPs so they don't get pooled. | 13580 // Use two different hosts with different IPs so they don't get pooled. |
13538 session_deps_.host_resolver->rules()->AddRule("www.a.com", "10.0.0.1"); | 13581 session_deps_.host_resolver->rules()->AddRule("www.a.com", "10.0.0.1"); |
13539 session_deps_.host_resolver->rules()->AddRule("www.b.com", "10.0.0.2"); | 13582 session_deps_.host_resolver->rules()->AddRule("www.b.com", "10.0.0.2"); |
13540 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); | 13583 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); |
13541 | 13584 |
13542 SSLSocketDataProvider ssl1(ASYNC, OK); | 13585 SSLSocketDataProvider ssl1(ASYNC, OK); |
13543 ssl1.SetNextProto(GetParam()); | 13586 ssl1.SetNextProto(GetProtocol()); |
13544 SSLSocketDataProvider ssl2(ASYNC, OK); | 13587 SSLSocketDataProvider ssl2(ASYNC, OK); |
13545 ssl2.SetNextProto(GetParam()); | 13588 ssl2.SetNextProto(GetProtocol()); |
13546 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); | 13589 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); |
13547 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); | 13590 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); |
13548 | 13591 |
13549 scoped_ptr<SpdyFrame> host1_req(spdy_util_.ConstructSpdyGet( | 13592 scoped_ptr<SpdyFrame> host1_req(spdy_util_.ConstructSpdyGet( |
13550 "https://www.a.com", false, 1, DEFAULT_PRIORITY)); | 13593 "https://www.a.com", false, 1, DEFAULT_PRIORITY)); |
13551 MockWrite spdy1_writes[] = { | 13594 MockWrite spdy1_writes[] = { |
13552 CreateMockWrite(*host1_req, 0), | 13595 CreateMockWrite(*host1_req, 0), |
13553 }; | 13596 }; |
13554 scoped_ptr<SpdyFrame> host1_resp( | 13597 scoped_ptr<SpdyFrame> host1_resp( |
13555 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 13598 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); |
13556 scoped_ptr<SpdyFrame> host1_resp_body( | 13599 scoped_ptr<SpdyFrame> host1_resp_body( |
13557 spdy_util_.ConstructSpdyBodyFrame(1, true)); | 13600 spdy_util_.ConstructSpdyBodyFrame(1, true)); |
13558 MockRead spdy1_reads[] = { | 13601 MockRead spdy1_reads[] = { |
13559 CreateMockRead(*host1_resp, 1), | 13602 CreateMockRead(*host1_resp, 1), |
13560 CreateMockRead(*host1_resp_body, 2), | 13603 CreateMockRead(*host1_resp_body, 2), |
13561 MockRead(ASYNC, ERR_IO_PENDING, 3), | 13604 MockRead(ASYNC, ERR_IO_PENDING, 3), |
13562 }; | 13605 }; |
13563 | 13606 |
13607 // Use a separate test class for the separate SpdySession that will be | |
Bence
2015/11/12 01:33:29
optional: s/class/instance/
Randy Smith (Not in Mondays)
2015/11/12 01:59:31
Done (both locations).
| |
13608 // created. | |
13609 SpdyTestUtil spdy_util_2(GetProtocol(), GetDependenciesFromPriority()); | |
13564 scoped_ptr<SequencedSocketData> spdy1_data( | 13610 scoped_ptr<SequencedSocketData> spdy1_data( |
13565 new SequencedSocketData(spdy1_reads, arraysize(spdy1_reads), spdy1_writes, | 13611 new SequencedSocketData(spdy1_reads, arraysize(spdy1_reads), spdy1_writes, |
13566 arraysize(spdy1_writes))); | 13612 arraysize(spdy1_writes))); |
13567 session_deps_.socket_factory->AddSocketDataProvider(spdy1_data.get()); | 13613 session_deps_.socket_factory->AddSocketDataProvider(spdy1_data.get()); |
13568 | 13614 |
13569 scoped_ptr<SpdyFrame> host2_req(spdy_util_.ConstructSpdyGet( | 13615 scoped_ptr<SpdyFrame> host2_req(spdy_util_2.ConstructSpdyGet( |
13570 "https://www.b.com", false, 1, DEFAULT_PRIORITY)); | 13616 "https://www.b.com", false, 1, DEFAULT_PRIORITY)); |
13571 MockWrite spdy2_writes[] = { | 13617 MockWrite spdy2_writes[] = { |
13572 CreateMockWrite(*host2_req, 0), | 13618 CreateMockWrite(*host2_req, 0), |
13573 }; | 13619 }; |
13574 scoped_ptr<SpdyFrame> host2_resp( | 13620 scoped_ptr<SpdyFrame> host2_resp( |
13575 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); | 13621 spdy_util_2.ConstructSpdyGetSynReply(NULL, 0, 1)); |
13576 scoped_ptr<SpdyFrame> host2_resp_body( | 13622 scoped_ptr<SpdyFrame> host2_resp_body( |
13577 spdy_util_.ConstructSpdyBodyFrame(1, true)); | 13623 spdy_util_2.ConstructSpdyBodyFrame(1, true)); |
13578 MockRead spdy2_reads[] = { | 13624 MockRead spdy2_reads[] = { |
13579 CreateMockRead(*host2_resp, 1), | 13625 CreateMockRead(*host2_resp, 1), |
13580 CreateMockRead(*host2_resp_body, 2), | 13626 CreateMockRead(*host2_resp_body, 2), |
13581 MockRead(ASYNC, ERR_IO_PENDING, 3), | 13627 MockRead(ASYNC, ERR_IO_PENDING, 3), |
13582 }; | 13628 }; |
13583 | 13629 |
13584 scoped_ptr<SequencedSocketData> spdy2_data( | 13630 scoped_ptr<SequencedSocketData> spdy2_data( |
13585 new SequencedSocketData(spdy2_reads, arraysize(spdy2_reads), spdy2_writes, | 13631 new SequencedSocketData(spdy2_reads, arraysize(spdy2_reads), spdy2_writes, |
13586 arraysize(spdy2_writes))); | 13632 arraysize(spdy2_writes))); |
13587 session_deps_.socket_factory->AddSocketDataProvider(spdy2_data.get()); | 13633 session_deps_.socket_factory->AddSocketDataProvider(spdy2_data.get()); |
(...skipping 1779 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
15367 std::string response_data; | 15413 std::string response_data; |
15368 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data)); | 15414 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data)); |
15369 | 15415 |
15370 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), | 15416 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), |
15371 trans->GetTotalSentBytes()); | 15417 trans->GetTotalSentBytes()); |
15372 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), | 15418 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), |
15373 trans->GetTotalReceivedBytes()); | 15419 trans->GetTotalReceivedBytes()); |
15374 } | 15420 } |
15375 | 15421 |
15376 } // namespace net | 15422 } // namespace net |
OLD | NEW |