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

Side by Side Diff: net/http/http_network_transaction_unittest.cc

Issue 1411383005: Initial implementation of RequestPriority-based HTTP/2 dependencies. (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master
Patch Set: Updated tests. Created 5 years, 1 month ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
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
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
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
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(TestCase,
Bence 2015/11/11 18:47:14 I am not familiar with the test name prefix conven
Randy Smith (Not in Mondays) 2015/11/11 23:25:59 Right, I had erroneously concluded that this was a
Bence 2015/11/12 01:33:29 I like it, thanks.
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
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
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
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
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_.OnStreamDestruction(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
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
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
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
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
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
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
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_.OnStreamDestruction(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
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
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
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_.OnStreamDestruction(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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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_.OnStreamDestruction(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
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 // host1_req will complete before host2_req starts.
12532 spdy_util_.OnStreamDestruction(1);
12499 scoped_ptr<SpdyFrame> host2_req( 12533 scoped_ptr<SpdyFrame> host2_req(
12500 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); 12534 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST));
12501 MockWrite spdy_writes[] = { 12535 MockWrite spdy_writes[] = {
12502 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), 12536 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3),
12503 }; 12537 };
12504 scoped_ptr<SpdyFrame> host1_resp( 12538 scoped_ptr<SpdyFrame> host1_resp(
12505 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 12539 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
12506 scoped_ptr<SpdyFrame> host1_resp_body( 12540 scoped_ptr<SpdyFrame> host1_resp_body(
12507 spdy_util_.ConstructSpdyBodyFrame(1, true)); 12541 spdy_util_.ConstructSpdyBodyFrame(1, true));
12508 scoped_ptr<SpdyFrame> host2_resp( 12542 scoped_ptr<SpdyFrame> host2_resp(
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after
12614 // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver. 12648 // Set up a special HttpNetworkSession with a OneTimeCachingHostResolver.
12615 OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443)); 12649 OneTimeCachingHostResolver host_resolver(HostPortPair("www.gmail.com", 443));
12616 HttpNetworkSession::Params params = 12650 HttpNetworkSession::Params params =
12617 SpdySessionDependencies::CreateSessionParams(&session_deps_); 12651 SpdySessionDependencies::CreateSessionParams(&session_deps_);
12618 params.host_resolver = &host_resolver; 12652 params.host_resolver = &host_resolver;
12619 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12653 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12620 SpdySessionPoolPeer pool_peer(session->spdy_session_pool()); 12654 SpdySessionPoolPeer pool_peer(session->spdy_session_pool());
12621 pool_peer.DisableDomainAuthenticationVerification(); 12655 pool_peer.DisableDomainAuthenticationVerification();
12622 12656
12623 SSLSocketDataProvider ssl(ASYNC, OK); 12657 SSLSocketDataProvider ssl(ASYNC, OK);
12624 ssl.SetNextProto(GetParam()); 12658 ssl.SetNextProto(GetProtocol());
12625 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 12659 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
12626 12660
12627 scoped_ptr<SpdyFrame> host1_req( 12661 scoped_ptr<SpdyFrame> host1_req(
12628 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST)); 12662 spdy_util_.ConstructSpdyGet("https://www.example.org", false, 1, LOWEST));
12663 // host1_req will complete before host2_req starts.
12664 spdy_util_.OnStreamDestruction(1);
12629 scoped_ptr<SpdyFrame> host2_req( 12665 scoped_ptr<SpdyFrame> host2_req(
12630 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST)); 12666 spdy_util_.ConstructSpdyGet("https://www.gmail.com", false, 3, LOWEST));
12631 MockWrite spdy_writes[] = { 12667 MockWrite spdy_writes[] = {
12632 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3), 12668 CreateMockWrite(*host1_req, 0), CreateMockWrite(*host2_req, 3),
12633 }; 12669 };
12634 scoped_ptr<SpdyFrame> host1_resp( 12670 scoped_ptr<SpdyFrame> host1_resp(
12635 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 12671 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
12636 scoped_ptr<SpdyFrame> host1_resp_body( 12672 scoped_ptr<SpdyFrame> host1_resp_body(
12637 spdy_util_.ConstructSpdyBodyFrame(1, true)); 12673 spdy_util_.ConstructSpdyBodyFrame(1, true));
12638 scoped_ptr<SpdyFrame> host2_resp( 12674 scoped_ptr<SpdyFrame> host2_resp(
(...skipping 105 matching lines...) Expand 10 before | Expand all | Expand 10 after
12744 MockRead reads2[] = { 12780 MockRead reads2[] = {
12745 MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"), 12781 MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
12746 MockRead(ASYNC, 2, "hello"), 12782 MockRead(ASYNC, 2, "hello"),
12747 MockRead(ASYNC, OK, 3), 12783 MockRead(ASYNC, OK, 3),
12748 }; 12784 };
12749 12785
12750 SequencedSocketData data2(reads2, arraysize(reads2), writes2, 12786 SequencedSocketData data2(reads2, arraysize(reads2), writes2,
12751 arraysize(writes2)); 12787 arraysize(writes2));
12752 12788
12753 SSLSocketDataProvider ssl(ASYNC, OK); 12789 SSLSocketDataProvider ssl(ASYNC, OK);
12754 ssl.SetNextProto(GetParam()); 12790 ssl.SetNextProto(GetProtocol());
12755 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 12791 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
12756 session_deps_.socket_factory->AddSocketDataProvider(&data1); 12792 session_deps_.socket_factory->AddSocketDataProvider(&data1);
12757 session_deps_.socket_factory->AddSocketDataProvider(&data2); 12793 session_deps_.socket_factory->AddSocketDataProvider(&data2);
12758 12794
12759 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12795 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12760 12796
12761 // Start the first transaction to set up the SpdySession 12797 // Start the first transaction to set up the SpdySession
12762 HttpRequestInfo request1; 12798 HttpRequestInfo request1;
12763 request1.method = "GET"; 12799 request1.method = "GET";
12764 request1.url = GURL(https_url); 12800 request1.url = GURL(https_url);
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after
12797 base::FilePath certs_dir = GetTestCertsDirectory(); 12833 base::FilePath certs_dir = GetTestCertsDirectory();
12798 scoped_refptr<X509Certificate> cert( 12834 scoped_refptr<X509Certificate> cert(
12799 ImportCertFromFile(certs_dir, "spdy_pooling.pem")); 12835 ImportCertFromFile(certs_dir, "spdy_pooling.pem"));
12800 ASSERT_TRUE(cert.get()); 12836 ASSERT_TRUE(cert.get());
12801 bool common_name_fallback_used; 12837 bool common_name_fallback_used;
12802 EXPECT_EQ(valid, 12838 EXPECT_EQ(valid,
12803 cert->VerifyNameMatch(origin.host(), &common_name_fallback_used)); 12839 cert->VerifyNameMatch(origin.host(), &common_name_fallback_used));
12804 EXPECT_TRUE( 12840 EXPECT_TRUE(
12805 cert->VerifyNameMatch(alternative.host(), &common_name_fallback_used)); 12841 cert->VerifyNameMatch(alternative.host(), &common_name_fallback_used));
12806 SSLSocketDataProvider ssl(ASYNC, OK); 12842 SSLSocketDataProvider ssl(ASYNC, OK);
12807 ssl.SetNextProto(GetParam()); 12843 ssl.SetNextProto(GetProtocol());
12808 ssl.cert = cert; 12844 ssl.cert = cert;
12809 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl); 12845 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl);
12810 12846
12811 // If pooling, then start a request to alternative first to create a 12847 // If pooling, then start a request to alternative first to create a
12812 // SpdySession. 12848 // SpdySession.
12813 std::string url0 = "https://www.example.org:443"; 12849 std::string url0 = "https://www.example.org:443";
12814 // Second request to origin, which has an alternative service, and could 12850 // 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. 12851 // open a connection to the alternative host or pool to the existing one.
12816 std::string url1("https://"); 12852 std::string url1("https://");
12817 url1.append(origin.host()); 12853 url1.append(origin.host());
12818 url1.append(":443"); 12854 url1.append(":443");
12819 12855
12820 scoped_ptr<SpdyFrame> req0; 12856 scoped_ptr<SpdyFrame> req0;
12821 scoped_ptr<SpdyFrame> req1; 12857 scoped_ptr<SpdyFrame> req1;
12822 scoped_ptr<SpdyFrame> resp0; 12858 scoped_ptr<SpdyFrame> resp0;
12823 scoped_ptr<SpdyFrame> body0; 12859 scoped_ptr<SpdyFrame> body0;
12824 scoped_ptr<SpdyFrame> resp1; 12860 scoped_ptr<SpdyFrame> resp1;
12825 scoped_ptr<SpdyFrame> body1; 12861 scoped_ptr<SpdyFrame> body1;
12826 std::vector<MockWrite> writes; 12862 std::vector<MockWrite> writes;
12827 std::vector<MockRead> reads; 12863 std::vector<MockRead> reads;
12828 12864
12829 if (pooling) { 12865 if (pooling) {
12830 req0.reset(spdy_util_.ConstructSpdyGet(url0.c_str(), false, 1, LOWEST)); 12866 req0.reset(spdy_util_.ConstructSpdyGet(url0.c_str(), false, 1, LOWEST));
12867 // Stream 1 is complete before stream 3 is created.
12868 spdy_util_.OnStreamDestruction(1);
12831 req1.reset(spdy_util_.ConstructSpdyGet(url1.c_str(), false, 3, LOWEST)); 12869 req1.reset(spdy_util_.ConstructSpdyGet(url1.c_str(), false, 3, LOWEST));
12870 spdy_util_.OnStreamDestruction(3);
12832 12871
12833 writes.push_back(CreateMockWrite(*req0, 0)); 12872 writes.push_back(CreateMockWrite(*req0, 0));
12834 writes.push_back(CreateMockWrite(*req1, 3)); 12873 writes.push_back(CreateMockWrite(*req1, 3));
12835 12874
12836 resp0.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 12875 resp0.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
12837 body0.reset(spdy_util_.ConstructSpdyBodyFrame(1, true)); 12876 body0.reset(spdy_util_.ConstructSpdyBodyFrame(1, true));
12838 resp1.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); 12877 resp1.reset(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
12839 body1.reset(spdy_util_.ConstructSpdyBodyFrame(3, true)); 12878 body1.reset(spdy_util_.ConstructSpdyBodyFrame(3, true));
12840 12879
12841 reads.push_back(CreateMockRead(*resp0, 1)); 12880 reads.push_back(CreateMockRead(*resp0, 1));
(...skipping 23 matching lines...) Expand all
12865 MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED); 12904 MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
12866 StaticSocketDataProvider data_refused; 12905 StaticSocketDataProvider data_refused;
12867 data_refused.set_connect_data(mock_connect); 12906 data_refused.set_connect_data(mock_connect);
12868 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); 12907 session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
12869 12908
12870 session_deps_.use_alternative_services = true; 12909 session_deps_.use_alternative_services = true;
12871 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 12910 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12872 base::WeakPtr<HttpServerProperties> http_server_properties = 12911 base::WeakPtr<HttpServerProperties> http_server_properties =
12873 session->http_server_properties(); 12912 session->http_server_properties();
12874 AlternativeService alternative_service( 12913 AlternativeService alternative_service(
12875 AlternateProtocolFromNextProto(GetParam()), alternative); 12914 AlternateProtocolFromNextProto(GetProtocol()), alternative);
12876 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 12915 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
12877 http_server_properties->SetAlternativeService(origin, alternative_service, 12916 http_server_properties->SetAlternativeService(origin, alternative_service,
12878 1.0, expiration); 12917 1.0, expiration);
12879 12918
12880 // First request to alternative. 12919 // First request to alternative.
12881 if (pooling) { 12920 if (pooling) {
12882 scoped_ptr<HttpTransaction> trans0( 12921 scoped_ptr<HttpTransaction> trans0(
12883 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 12922 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
12884 HttpRequestInfo request0; 12923 HttpRequestInfo request0;
12885 request0.method = "GET"; 12924 request0.method = "GET";
(...skipping 28 matching lines...) Expand all
12914 } else { 12953 } else {
12915 if (pooling) { 12954 if (pooling) {
12916 EXPECT_EQ(ERR_CONNECTION_REFUSED, rv); 12955 EXPECT_EQ(ERR_CONNECTION_REFUSED, rv);
12917 } else { 12956 } else {
12918 EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv); 12957 EXPECT_EQ(ERR_ALTERNATIVE_CERT_NOT_VALID_FOR_ORIGIN, rv);
12919 } 12958 }
12920 } 12959 }
12921 } 12960 }
12922 }; 12961 };
12923 12962
12924 INSTANTIATE_TEST_CASE_P(NextProto, 12963 INSTANTIATE_TEST_CASE_P(TestCase,
12925 AltSvcCertificateVerificationTest, 12964 AltSvcCertificateVerificationTest,
12926 testing::Values(kProtoSPDY31, 12965 testing::Values(kTestCaseSPDY31,
12927 kProtoHTTP2)); 12966 kTestCaseHTTP2NoPriorityDependencies,
12967 kTestCaseHTTP2PriorityDependencies));
12928 12968
12929 // The alternative service host must exhibit a certificate that is valid for the 12969 // 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 12970 // origin host. Test that this is enforced when pooling to an existing
12931 // connection. 12971 // connection.
12932 TEST_P(AltSvcCertificateVerificationTest, PoolingValid) { 12972 TEST_P(AltSvcCertificateVerificationTest, PoolingValid) {
12933 Run(true, true); 12973 Run(true, true);
12934 } 12974 }
12935 12975
12936 TEST_P(AltSvcCertificateVerificationTest, PoolingInvalid) { 12976 TEST_P(AltSvcCertificateVerificationTest, PoolingInvalid) {
12937 Run(true, false); 12977 Run(true, false);
(...skipping 31 matching lines...) Expand 10 before | Expand all | Expand 10 after
12969 StaticSocketDataProvider data_refused; 13009 StaticSocketDataProvider data_refused;
12970 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED)); 13010 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
12971 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); 13011 session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
12972 13012
12973 // Set up alternative service for origin. 13013 // Set up alternative service for origin.
12974 session_deps_.use_alternative_services = true; 13014 session_deps_.use_alternative_services = true;
12975 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 13015 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
12976 base::WeakPtr<HttpServerProperties> http_server_properties = 13016 base::WeakPtr<HttpServerProperties> http_server_properties =
12977 session->http_server_properties(); 13017 session->http_server_properties();
12978 AlternativeService alternative_service( 13018 AlternativeService alternative_service(
12979 AlternateProtocolFromNextProto(GetParam()), alternative); 13019 AlternateProtocolFromNextProto(GetProtocol()), alternative);
12980 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 13020 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
12981 http_server_properties->SetAlternativeService(origin, alternative_service, 13021 http_server_properties->SetAlternativeService(origin, alternative_service,
12982 1.0, expiration); 13022 1.0, expiration);
12983 13023
12984 scoped_ptr<HttpTransaction> trans( 13024 scoped_ptr<HttpTransaction> trans(
12985 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 13025 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
12986 HttpRequestInfo request; 13026 HttpRequestInfo request;
12987 request.method = "GET"; 13027 request.method = "GET";
12988 request.url = GURL("https://origin.example.org:443"); 13028 request.url = GURL("https://origin.example.org:443");
12989 request.load_flags = 0; 13029 request.load_flags = 0;
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after
13042 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads), 13082 StaticSocketDataProvider http_data(http_reads, arraysize(http_reads),
13043 http_writes, arraysize(http_writes)); 13083 http_writes, arraysize(http_writes));
13044 session_deps_.socket_factory->AddSocketDataProvider(&http_data); 13084 session_deps_.socket_factory->AddSocketDataProvider(&http_data);
13045 13085
13046 // Set up alternative service for origin. 13086 // Set up alternative service for origin.
13047 session_deps_.use_alternative_services = true; 13087 session_deps_.use_alternative_services = true;
13048 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 13088 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
13049 base::WeakPtr<HttpServerProperties> http_server_properties = 13089 base::WeakPtr<HttpServerProperties> http_server_properties =
13050 session->http_server_properties(); 13090 session->http_server_properties();
13051 AlternativeService alternative_service( 13091 AlternativeService alternative_service(
13052 AlternateProtocolFromNextProto(GetParam()), alternative); 13092 AlternateProtocolFromNextProto(GetProtocol()), alternative);
13053 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 13093 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
13054 http_server_properties->SetAlternativeService(origin, alternative_service, 13094 http_server_properties->SetAlternativeService(origin, alternative_service,
13055 1.0, expiration); 13095 1.0, expiration);
13056 13096
13057 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get()); 13097 HttpNetworkTransaction trans1(DEFAULT_PRIORITY, session.get());
13058 HttpRequestInfo request1; 13098 HttpRequestInfo request1;
13059 request1.method = "GET"; 13099 request1.method = "GET";
13060 request1.url = GURL("https://origin.example.org:443"); 13100 request1.url = GURL("https://origin.example.org:443");
13061 request1.load_flags = 0; 13101 request1.load_flags = 0;
13062 TestCompletionCallback callback1; 13102 TestCompletionCallback callback1;
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after
13151 StaticSocketDataProvider data_refused; 13191 StaticSocketDataProvider data_refused;
13152 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED)); 13192 data_refused.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
13153 session_deps_.socket_factory->AddSocketDataProvider(&data_refused); 13193 session_deps_.socket_factory->AddSocketDataProvider(&data_refused);
13154 13194
13155 // Set up alternative service for origin. 13195 // Set up alternative service for origin.
13156 session_deps_.use_alternative_services = true; 13196 session_deps_.use_alternative_services = true;
13157 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 13197 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
13158 base::WeakPtr<HttpServerProperties> http_server_properties = 13198 base::WeakPtr<HttpServerProperties> http_server_properties =
13159 session->http_server_properties(); 13199 session->http_server_properties();
13160 AlternativeService alternative_service( 13200 AlternativeService alternative_service(
13161 AlternateProtocolFromNextProto(GetParam()), alternative); 13201 AlternateProtocolFromNextProto(GetProtocol()), alternative);
13162 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1); 13202 base::Time expiration = base::Time::Now() + base::TimeDelta::FromDays(1);
13163 http_server_properties->SetAlternativeService(origin, alternative_service, 13203 http_server_properties->SetAlternativeService(origin, alternative_service,
13164 1.0, expiration); 13204 1.0, expiration);
13165 13205
13166 // First transaction to alternative to open an HTTP/1.1 socket. 13206 // First transaction to alternative to open an HTTP/1.1 socket.
13167 scoped_ptr<HttpTransaction> trans1( 13207 scoped_ptr<HttpTransaction> trans1(
13168 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get())); 13208 new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
13169 HttpRequestInfo request1; 13209 HttpRequestInfo request1;
13170 request1.method = "GET"; 13210 request1.method = "GET";
13171 request1.url = GURL(alternative_url); 13211 request1.url = GURL(alternative_url);
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after
13220 EXPECT_FALSE(response3->was_fetched_via_spdy); 13260 EXPECT_FALSE(response3->was_fetched_via_spdy);
13221 std::string response_data3; 13261 std::string response_data3;
13222 ASSERT_EQ(OK, ReadTransaction(trans3.get(), &response_data3)); 13262 ASSERT_EQ(OK, ReadTransaction(trans3.get(), &response_data3));
13223 EXPECT_EQ("second HTTP/1.1 response from alternative", response_data3); 13263 EXPECT_EQ("second HTTP/1.1 response from alternative", response_data3);
13224 } 13264 }
13225 13265
13226 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionForHttpOverTunnel) { 13266 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionForHttpOverTunnel) {
13227 const std::string https_url = "https://www.example.org:8080/"; 13267 const std::string https_url = "https://www.example.org:8080/";
13228 const std::string http_url = "http://www.example.org:8080/"; 13268 const std::string http_url = "http://www.example.org:8080/";
13229 13269
13270 // Separate SPDY util classes for naked and wrapped requests.
13271 SpdyTestUtil spdy_util_wrapped(GetProtocol(), GetDependenciesFromPriority());
13272
13230 // SPDY GET for HTTPS URL (through CONNECT tunnel) 13273 // SPDY GET for HTTPS URL (through CONNECT tunnel)
13231 const HostPortPair host_port_pair("www.example.org", 8080); 13274 const HostPortPair host_port_pair("www.example.org", 8080);
13232 scoped_ptr<SpdyFrame> connect( 13275 scoped_ptr<SpdyFrame> connect(
13233 spdy_util_.ConstructSpdyConnect(NULL, 0, 1, LOWEST, host_port_pair)); 13276 spdy_util_.ConstructSpdyConnect(NULL, 0, 1, LOWEST, host_port_pair));
13234 scoped_ptr<SpdyFrame> req1( 13277 scoped_ptr<SpdyFrame> req1(
13235 spdy_util_.ConstructSpdyGet(https_url.c_str(), false, 1, LOWEST)); 13278 spdy_util_wrapped.ConstructSpdyGet(https_url.c_str(), false, 1, LOWEST));
13236 scoped_ptr<SpdyFrame> wrapped_req1( 13279 scoped_ptr<SpdyFrame> wrapped_req1(
13237 spdy_util_.ConstructWrappedSpdyFrame(req1, 1)); 13280 spdy_util_.ConstructWrappedSpdyFrame(req1, 1));
13238 13281
13239 // SPDY GET for HTTP URL (through the proxy, but not the tunnel). 13282 // SPDY GET for HTTP URL (through the proxy, but not the tunnel).
13240 SpdyHeaderBlock req2_block; 13283 SpdyHeaderBlock req2_block;
13241 spdy_util_.MaybeAddVersionHeader(&req2_block); 13284 spdy_util_.MaybeAddVersionHeader(&req2_block);
13242 req2_block[spdy_util_.GetMethodKey()] = "GET"; 13285 req2_block[spdy_util_.GetMethodKey()] = "GET";
13243 req2_block[spdy_util_.GetHostKey()] = "www.example.org:8080"; 13286 req2_block[spdy_util_.GetHostKey()] = "www.example.org:8080";
13244 req2_block[spdy_util_.GetSchemeKey()] = "http"; 13287 req2_block[spdy_util_.GetSchemeKey()] = "http";
13245 req2_block[spdy_util_.GetPathKey()] = "/"; 13288 req2_block[spdy_util_.GetPathKey()] = "/";
13246 scoped_ptr<SpdyFrame> req2( 13289 scoped_ptr<SpdyFrame> req2(
13247 spdy_util_.ConstructSpdySyn(3, req2_block, MEDIUM, false, true)); 13290 spdy_util_.ConstructSpdySyn(3, req2_block, MEDIUM, false, true));
13248 13291
13249 MockWrite writes1[] = { 13292 MockWrite writes1[] = {
13250 CreateMockWrite(*connect, 0), 13293 CreateMockWrite(*connect, 0),
13251 CreateMockWrite(*wrapped_req1, 2), 13294 CreateMockWrite(*wrapped_req1, 2),
13252 CreateMockWrite(*req2, 5), 13295 CreateMockWrite(*req2, 5),
13253 }; 13296 };
13254 13297
13255 scoped_ptr<SpdyFrame> conn_resp( 13298 scoped_ptr<SpdyFrame> conn_resp(
13256 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 13299 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
13257 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 13300 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
13258 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true)); 13301 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
13259 scoped_ptr<SpdyFrame> wrapped_resp1( 13302 scoped_ptr<SpdyFrame> wrapped_resp1(
13260 spdy_util_.ConstructWrappedSpdyFrame(resp1, 1)); 13303 spdy_util_wrapped.ConstructWrappedSpdyFrame(resp1, 1));
13261 scoped_ptr<SpdyFrame> wrapped_body1( 13304 scoped_ptr<SpdyFrame> wrapped_body1(
13262 spdy_util_.ConstructWrappedSpdyFrame(body1, 1)); 13305 spdy_util_wrapped.ConstructWrappedSpdyFrame(body1, 1));
13263 scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3)); 13306 scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
13264 scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true)); 13307 scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true));
13265 MockRead reads1[] = { 13308 MockRead reads1[] = {
13266 CreateMockRead(*conn_resp, 1), 13309 CreateMockRead(*conn_resp, 1),
13267 CreateMockRead(*wrapped_resp1, 3), 13310 CreateMockRead(*wrapped_resp1, 3),
13268 CreateMockRead(*wrapped_body1, 4), 13311 CreateMockRead(*wrapped_body1, 4),
13269 CreateMockRead(*resp2, 6), 13312 CreateMockRead(*resp2, 6),
13270 CreateMockRead(*body2, 7), 13313 CreateMockRead(*body2, 7),
13271 MockRead(ASYNC, ERR_IO_PENDING, 8) 13314 MockRead(ASYNC, ERR_IO_PENDING, 8)
13272 }; 13315 };
13273 13316
13274 DeterministicSocketData data1(reads1, arraysize(reads1), 13317 DeterministicSocketData data1(reads1, arraysize(reads1),
13275 writes1, arraysize(writes1)); 13318 writes1, arraysize(writes1));
13276 MockConnect connect_data1(ASYNC, OK); 13319 MockConnect connect_data1(ASYNC, OK);
13277 data1.set_connect_data(connect_data1); 13320 data1.set_connect_data(connect_data1);
13278 13321
13279 session_deps_.proxy_service = 13322 session_deps_.proxy_service =
13280 ProxyService::CreateFixedFromPacResult("HTTPS proxy:70"); 13323 ProxyService::CreateFixedFromPacResult("HTTPS proxy:70");
13281 TestNetLog log; 13324 TestNetLog log;
13282 session_deps_.net_log = &log; 13325 session_deps_.net_log = &log;
13283 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy 13326 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy
13284 ssl1.SetNextProto(GetParam()); 13327 ssl1.SetNextProto(GetProtocol());
13285 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1); 13328 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1);
13286 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server 13329 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server
13287 ssl2.SetNextProto(GetParam()); 13330 ssl2.SetNextProto(GetProtocol());
13288 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2); 13331 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2);
13289 session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data1); 13332 session_deps_.deterministic_socket_factory->AddSocketDataProvider(&data1);
13290 13333
13291 scoped_ptr<HttpNetworkSession> session( 13334 scoped_ptr<HttpNetworkSession> session(
13292 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_)); 13335 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
13293 13336
13294 // Start the first transaction to set up the SpdySession 13337 // Start the first transaction to set up the SpdySession
13295 HttpRequestInfo request1; 13338 HttpRequestInfo request1;
13296 request1.method = "GET"; 13339 request1.method = "GET";
13297 request1.url = GURL(https_url); 13340 request1.url = GURL(https_url);
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after
13337 13380
13338 // Test that in the case where we have a SPDY session to a SPDY proxy 13381 // 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 13382 // that we do not pool other origins that resolve to the same IP when
13340 // the certificate does not match the new origin. 13383 // the certificate does not match the new origin.
13341 // http://crbug.com/134690 13384 // http://crbug.com/134690
13342 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionIfCertDoesNotMatch) { 13385 TEST_P(HttpNetworkTransactionTest, DoNotUseSpdySessionIfCertDoesNotMatch) {
13343 const std::string url1 = "http://www.example.org/"; 13386 const std::string url1 = "http://www.example.org/";
13344 const std::string url2 = "https://news.example.org/"; 13387 const std::string url2 = "https://news.example.org/";
13345 const std::string ip_addr = "1.2.3.4"; 13388 const std::string ip_addr = "1.2.3.4";
13346 13389
13390 // Second SpdyTestUtil instance for the second socket.
13391 SpdyTestUtil spdy_util_secure(GetProtocol(), GetDependenciesFromPriority());
13392
13347 // SPDY GET for HTTP URL (through SPDY proxy) 13393 // SPDY GET for HTTP URL (through SPDY proxy)
13348 scoped_ptr<SpdyHeaderBlock> headers( 13394 scoped_ptr<SpdyHeaderBlock> headers(
13349 spdy_util_.ConstructGetHeaderBlockForProxy("http://www.example.org/")); 13395 spdy_util_.ConstructGetHeaderBlockForProxy("http://www.example.org/"));
13350 scoped_ptr<SpdyFrame> req1( 13396 scoped_ptr<SpdyFrame> req1(
13351 spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true)); 13397 spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true));
13352 13398
13353 MockWrite writes1[] = { 13399 MockWrite writes1[] = {
13354 CreateMockWrite(*req1, 0), 13400 CreateMockWrite(*req1, 0),
13355 }; 13401 };
13356 13402
13357 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 13403 scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
13358 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true)); 13404 scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
13359 MockRead reads1[] = { 13405 MockRead reads1[] = {
13360 CreateMockRead(*resp1, 1), 13406 CreateMockRead(*resp1, 1),
13361 CreateMockRead(*body1, 2), 13407 CreateMockRead(*body1, 2),
13362 MockRead(ASYNC, OK, 3) // EOF 13408 MockRead(ASYNC, OK, 3) // EOF
13363 }; 13409 };
13364 13410
13365 scoped_ptr<DeterministicSocketData> data1( 13411 scoped_ptr<DeterministicSocketData> data1(
13366 new DeterministicSocketData(reads1, arraysize(reads1), 13412 new DeterministicSocketData(reads1, arraysize(reads1),
13367 writes1, arraysize(writes1))); 13413 writes1, arraysize(writes1)));
13368 IPAddressNumber ip; 13414 IPAddressNumber ip;
13369 ASSERT_TRUE(ParseIPLiteralToNumber(ip_addr, &ip)); 13415 ASSERT_TRUE(ParseIPLiteralToNumber(ip_addr, &ip));
13370 IPEndPoint peer_addr = IPEndPoint(ip, 443); 13416 IPEndPoint peer_addr = IPEndPoint(ip, 443);
13371 MockConnect connect_data1(ASYNC, OK, peer_addr); 13417 MockConnect connect_data1(ASYNC, OK, peer_addr);
13372 data1->set_connect_data(connect_data1); 13418 data1->set_connect_data(connect_data1);
13373 13419
13374 // SPDY GET for HTTPS URL (direct) 13420 // SPDY GET for HTTPS URL (direct)
13375 scoped_ptr<SpdyFrame> req2( 13421 scoped_ptr<SpdyFrame> req2(
13376 spdy_util_.ConstructSpdyGet(url2.c_str(), false, 1, MEDIUM)); 13422 spdy_util_secure.ConstructSpdyGet(url2.c_str(), false, 1, MEDIUM));
13377 13423
13378 MockWrite writes2[] = { 13424 MockWrite writes2[] = {
13379 CreateMockWrite(*req2, 0), 13425 CreateMockWrite(*req2, 0),
13380 }; 13426 };
13381 13427
13382 scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 13428 scoped_ptr<SpdyFrame> resp2(
13383 scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true)); 13429 spdy_util_secure.ConstructSpdyGetSynReply(NULL, 0, 1));
13430 scoped_ptr<SpdyFrame> body2(spdy_util_secure.ConstructSpdyBodyFrame(1, true));
13384 MockRead reads2[] = { 13431 MockRead reads2[] = {
13385 CreateMockRead(*resp2, 1), 13432 CreateMockRead(*resp2, 1),
13386 CreateMockRead(*body2, 2), 13433 CreateMockRead(*body2, 2),
13387 MockRead(ASYNC, OK, 3) // EOF 13434 MockRead(ASYNC, OK, 3) // EOF
13388 }; 13435 };
13389 13436
13390 scoped_ptr<DeterministicSocketData> data2( 13437 scoped_ptr<DeterministicSocketData> data2(
13391 new DeterministicSocketData(reads2, arraysize(reads2), 13438 new DeterministicSocketData(reads2, arraysize(reads2),
13392 writes2, arraysize(writes2))); 13439 writes2, arraysize(writes2)));
13393 MockConnect connect_data2(ASYNC, OK); 13440 MockConnect connect_data2(ASYNC, OK);
13394 data2->set_connect_data(connect_data2); 13441 data2->set_connect_data(connect_data2);
13395 13442
13396 // Set up a proxy config that sends HTTP requests to a proxy, and 13443 // Set up a proxy config that sends HTTP requests to a proxy, and
13397 // all others direct. 13444 // all others direct.
13398 ProxyConfig proxy_config; 13445 ProxyConfig proxy_config;
13399 proxy_config.proxy_rules().ParseFromString("http=https://proxy:443"); 13446 proxy_config.proxy_rules().ParseFromString("http=https://proxy:443");
13400 session_deps_.proxy_service.reset(new ProxyService( 13447 session_deps_.proxy_service.reset(new ProxyService(
13401 make_scoped_ptr(new ProxyConfigServiceFixed(proxy_config)), nullptr, 13448 make_scoped_ptr(new ProxyConfigServiceFixed(proxy_config)), nullptr,
13402 NULL)); 13449 NULL));
13403 13450
13404 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy 13451 SSLSocketDataProvider ssl1(ASYNC, OK); // to the proxy
13405 ssl1.SetNextProto(GetParam()); 13452 ssl1.SetNextProto(GetProtocol());
13406 // Load a valid cert. Note, that this does not need to 13453 // Load a valid cert. Note, that this does not need to
13407 // be valid for proxy because the MockSSLClientSocket does 13454 // be valid for proxy because the MockSSLClientSocket does
13408 // not actually verify it. But SpdySession will use this 13455 // not actually verify it. But SpdySession will use this
13409 // to see if it is valid for the new origin 13456 // to see if it is valid for the new origin
13410 ssl1.cert = ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem"); 13457 ssl1.cert = ImportCertFromFile(GetTestCertsDirectory(), "ok_cert.pem");
13411 ASSERT_TRUE(ssl1.cert.get()); 13458 ASSERT_TRUE(ssl1.cert.get());
13412 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1); 13459 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl1);
13413 session_deps_.deterministic_socket_factory->AddSocketDataProvider( 13460 session_deps_.deterministic_socket_factory->AddSocketDataProvider(
13414 data1.get()); 13461 data1.get());
13415 13462
13416 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server 13463 SSLSocketDataProvider ssl2(ASYNC, OK); // to the server
13417 ssl2.SetNextProto(GetParam()); 13464 ssl2.SetNextProto(GetProtocol());
13418 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2); 13465 session_deps_.deterministic_socket_factory->AddSSLSocketDataProvider(&ssl2);
13419 session_deps_.deterministic_socket_factory->AddSocketDataProvider( 13466 session_deps_.deterministic_socket_factory->AddSocketDataProvider(
13420 data2.get()); 13467 data2.get());
13421 13468
13422 session_deps_.host_resolver.reset(new MockCachingHostResolver()); 13469 session_deps_.host_resolver.reset(new MockCachingHostResolver());
13423 session_deps_.host_resolver->rules()->AddRule("news.example.org", ip_addr); 13470 session_deps_.host_resolver->rules()->AddRule("news.example.org", ip_addr);
13424 session_deps_.host_resolver->rules()->AddRule("proxy", ip_addr); 13471 session_deps_.host_resolver->rules()->AddRule("proxy", ip_addr);
13425 13472
13426 scoped_ptr<HttpNetworkSession> session( 13473 scoped_ptr<HttpNetworkSession> session(
13427 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_)); 13474 SpdySessionDependencies::SpdyCreateSessionDeterministic(&session_deps_));
(...skipping 54 matching lines...) Expand 10 before | Expand all | Expand 10 after
13482 MockRead reads2[] = { 13529 MockRead reads2[] = {
13483 CreateMockRead(*resp2, 1), 13530 CreateMockRead(*resp2, 1),
13484 CreateMockRead(*body2, 2), 13531 CreateMockRead(*body2, 2),
13485 MockRead(ASYNC, OK, 3) // EOF 13532 MockRead(ASYNC, OK, 3) // EOF
13486 }; 13533 };
13487 13534
13488 SequencedSocketData data2(reads2, arraysize(reads2), writes2, 13535 SequencedSocketData data2(reads2, arraysize(reads2), writes2,
13489 arraysize(writes2)); 13536 arraysize(writes2));
13490 13537
13491 SSLSocketDataProvider ssl1(ASYNC, OK); 13538 SSLSocketDataProvider ssl1(ASYNC, OK);
13492 ssl1.SetNextProto(GetParam()); 13539 ssl1.SetNextProto(GetProtocol());
13493 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); 13540 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1);
13494 session_deps_.socket_factory->AddSocketDataProvider(&data1); 13541 session_deps_.socket_factory->AddSocketDataProvider(&data1);
13495 13542
13496 SSLSocketDataProvider ssl2(ASYNC, OK); 13543 SSLSocketDataProvider ssl2(ASYNC, OK);
13497 ssl2.SetNextProto(GetParam()); 13544 ssl2.SetNextProto(GetProtocol());
13498 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); 13545 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
13499 session_deps_.socket_factory->AddSocketDataProvider(&data2); 13546 session_deps_.socket_factory->AddSocketDataProvider(&data2);
13500 13547
13501 scoped_ptr<HttpNetworkSession> session( 13548 scoped_ptr<HttpNetworkSession> session(
13502 SpdySessionDependencies::SpdyCreateSession(&session_deps_)); 13549 SpdySessionDependencies::SpdyCreateSession(&session_deps_));
13503 13550
13504 // Start the first transaction to set up the SpdySession and verify that 13551 // Start the first transaction to set up the SpdySession and verify that
13505 // connection was closed. 13552 // connection was closed.
13506 HttpRequestInfo request1; 13553 HttpRequestInfo request1;
13507 request1.method = "GET"; 13554 request1.method = "GET";
(...skipping 25 matching lines...) Expand all
13533 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); 13580 HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
13534 ClientSocketPoolManager::set_max_sockets_per_pool( 13581 ClientSocketPoolManager::set_max_sockets_per_pool(
13535 HttpNetworkSession::NORMAL_SOCKET_POOL, 1); 13582 HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
13536 13583
13537 // Use two different hosts with different IPs so they don't get pooled. 13584 // 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"); 13585 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"); 13586 session_deps_.host_resolver->rules()->AddRule("www.b.com", "10.0.0.2");
13540 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_)); 13587 scoped_ptr<HttpNetworkSession> session(CreateSession(&session_deps_));
13541 13588
13542 SSLSocketDataProvider ssl1(ASYNC, OK); 13589 SSLSocketDataProvider ssl1(ASYNC, OK);
13543 ssl1.SetNextProto(GetParam()); 13590 ssl1.SetNextProto(GetProtocol());
13544 SSLSocketDataProvider ssl2(ASYNC, OK); 13591 SSLSocketDataProvider ssl2(ASYNC, OK);
13545 ssl2.SetNextProto(GetParam()); 13592 ssl2.SetNextProto(GetProtocol());
13546 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1); 13593 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl1);
13547 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2); 13594 session_deps_.socket_factory->AddSSLSocketDataProvider(&ssl2);
13548 13595
13549 scoped_ptr<SpdyFrame> host1_req(spdy_util_.ConstructSpdyGet( 13596 scoped_ptr<SpdyFrame> host1_req(spdy_util_.ConstructSpdyGet(
13550 "https://www.a.com", false, 1, DEFAULT_PRIORITY)); 13597 "https://www.a.com", false, 1, DEFAULT_PRIORITY));
13551 MockWrite spdy1_writes[] = { 13598 MockWrite spdy1_writes[] = {
13552 CreateMockWrite(*host1_req, 0), 13599 CreateMockWrite(*host1_req, 0),
13553 }; 13600 };
13554 scoped_ptr<SpdyFrame> host1_resp( 13601 scoped_ptr<SpdyFrame> host1_resp(
13555 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1)); 13602 spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
13556 scoped_ptr<SpdyFrame> host1_resp_body( 13603 scoped_ptr<SpdyFrame> host1_resp_body(
13557 spdy_util_.ConstructSpdyBodyFrame(1, true)); 13604 spdy_util_.ConstructSpdyBodyFrame(1, true));
13605 spdy_util_.OnStreamDestruction(1);
13558 MockRead spdy1_reads[] = { 13606 MockRead spdy1_reads[] = {
13559 CreateMockRead(*host1_resp, 1), 13607 CreateMockRead(*host1_resp, 1),
13560 CreateMockRead(*host1_resp_body, 2), 13608 CreateMockRead(*host1_resp_body, 2),
13561 MockRead(ASYNC, ERR_IO_PENDING, 3), 13609 MockRead(ASYNC, ERR_IO_PENDING, 3),
13562 }; 13610 };
13563 13611
13564 scoped_ptr<SequencedSocketData> spdy1_data( 13612 scoped_ptr<SequencedSocketData> spdy1_data(
13565 new SequencedSocketData(spdy1_reads, arraysize(spdy1_reads), spdy1_writes, 13613 new SequencedSocketData(spdy1_reads, arraysize(spdy1_reads), spdy1_writes,
13566 arraysize(spdy1_writes))); 13614 arraysize(spdy1_writes)));
13567 session_deps_.socket_factory->AddSocketDataProvider(spdy1_data.get()); 13615 session_deps_.socket_factory->AddSocketDataProvider(spdy1_data.get());
(...skipping 1799 matching lines...) Expand 10 before | Expand all | Expand 10 after
15367 std::string response_data; 15415 std::string response_data;
15368 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data)); 15416 EXPECT_EQ(OK, ReadTransaction(trans.get(), &response_data));
15369 15417
15370 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)), 15418 EXPECT_EQ(CountWriteBytes(data_writes, arraysize(data_writes)),
15371 trans->GetTotalSentBytes()); 15419 trans->GetTotalSentBytes());
15372 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)), 15420 EXPECT_EQ(CountReadBytes(data_reads, arraysize(data_reads)),
15373 trans->GetTotalReceivedBytes()); 15421 trans->GetTotalReceivedBytes());
15374 } 15422 }
15375 15423
15376 } // namespace net 15424 } // namespace net
OLDNEW
« no previous file with comments | « no previous file | net/http/http_proxy_client_socket_pool_unittest.cc » ('j') | net/http/http_proxy_client_socket_pool_unittest.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698