1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/socket/transport_client_socket_pool.h" 6 7 #include "base/bind.h" 8 #include "base/bind_helpers.h" 9 #include "base/callback.h" 10 #include "base/compiler_specific.h" 11 #include "base/logging.h" 12 #include "base/message_loop/message_loop.h" 13 #include "base/threading/platform_thread.h" 14 #include "net/base/capturing_net_log.h" 15 #include "net/base/ip_endpoint.h" 16 #include "net/base/load_timing_info.h" 17 #include "net/base/load_timing_info_test_util.h" 18 #include "net/base/net_errors.h" 19 #include "net/base/net_util.h" 20 #include "net/base/test_completion_callback.h" 21 #include "net/dns/mock_host_resolver.h" 22 #include "net/socket/client_socket_factory.h" 23 #include "net/socket/client_socket_handle.h" 24 #include "net/socket/client_socket_pool_histograms.h" 25 #include "net/socket/socket_test_util.h" 26 #include "net/socket/stream_socket.h" 27 #include "testing/gtest/include/gtest/gtest.h" 28 29 namespace net { 30 31 using internal::ClientSocketPoolBaseHelper; 32 33 namespace { 34 35 const int kMaxSockets = 32; 36 const int kMaxSocketsPerGroup = 6; 37 const net::RequestPriority kDefaultPriority = LOW; 38 39 // Make sure |handle| sets load times correctly when it has been assigned a 40 // reused socket. 41 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) { 42 LoadTimingInfo load_timing_info; 43 // Only pass true in as |is_reused|, as in general, HttpStream types should 44 // have stricter concepts of reuse than socket pools. 45 EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info)); 46 47 EXPECT_TRUE(load_timing_info.socket_reused); 48 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 49 50 ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing); 51 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); 52 } 53 54 // Make sure |handle| sets load times correctly when it has been assigned a 55 // fresh socket. Also runs TestLoadTimingInfoConnectedReused, since the owner 56 // of a connection where |is_reused| is false may consider the connection 57 // reused. 58 void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) { 59 EXPECT_FALSE(handle.is_reused()); 60 61 LoadTimingInfo load_timing_info; 62 EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info)); 63 64 EXPECT_FALSE(load_timing_info.socket_reused); 65 EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id); 66 67 ExpectConnectTimingHasTimes(load_timing_info.connect_timing, 68 CONNECT_TIMING_HAS_DNS_TIMES); 69 ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info); 70 71 TestLoadTimingInfoConnectedReused(handle); 72 } 73 74 void SetIPv4Address(IPEndPoint* address) { 75 IPAddressNumber number; 76 CHECK(ParseIPLiteralToNumber("1.1.1.1", &number)); 77 *address = IPEndPoint(number, 80); 78 } 79 80 void SetIPv6Address(IPEndPoint* address) { 81 IPAddressNumber number; 82 CHECK(ParseIPLiteralToNumber("1:abcd::3:4:ff", &number)); 83 *address = IPEndPoint(number, 80); 84 } 85 86 class MockClientSocket : public StreamSocket { 87 public: 88 MockClientSocket(const AddressList& addrlist, net::NetLog* net_log) 89 : connected_(false), 90 addrlist_(addrlist), 91 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) { 92 } 93 94 // StreamSocket implementation. 95 virtual int Connect(const CompletionCallback& callback) OVERRIDE { 96 connected_ = true; 97 return OK; 98 } 99 virtual void Disconnect() OVERRIDE { 100 connected_ = false; 101 } 102 virtual bool IsConnected() const OVERRIDE { 103 return connected_; 104 } 105 virtual bool IsConnectedAndIdle() const OVERRIDE { 106 return connected_; 107 } 108 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { 109 return ERR_UNEXPECTED; 110 } 111 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { 112 if (!connected_) 113 return ERR_SOCKET_NOT_CONNECTED; 114 if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4) 115 SetIPv4Address(address); 116 else 117 SetIPv6Address(address); 118 return OK; 119 } 120 virtual const BoundNetLog& NetLog() const OVERRIDE { 121 return net_log_; 122 } 123 124 virtual void SetSubresourceSpeculation() OVERRIDE {} 125 virtual void SetOmniboxSpeculation() OVERRIDE {} 126 virtual bool WasEverUsed() const OVERRIDE { return false; } 127 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } 128 virtual bool WasNpnNegotiated() const OVERRIDE { 129 return false; 130 } 131 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { 132 return kProtoUnknown; 133 } 134 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { 135 return false; 136 } 137 138 // Socket implementation. 139 virtual int Read(IOBuffer* buf, int buf_len, 140 const CompletionCallback& callback) OVERRIDE { 141 return ERR_FAILED; 142 } 143 virtual int Write(IOBuffer* buf, int buf_len, 144 const CompletionCallback& callback) OVERRIDE { 145 return ERR_FAILED; 146 } 147 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } 148 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } 149 150 private: 151 bool connected_; 152 const AddressList addrlist_; 153 BoundNetLog net_log_; 154 }; 155 156 class MockFailingClientSocket : public StreamSocket { 157 public: 158 MockFailingClientSocket(const AddressList& addrlist, net::NetLog* net_log) 159 : addrlist_(addrlist), 160 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) { 161 } 162 163 // StreamSocket implementation. 164 virtual int Connect(const CompletionCallback& callback) OVERRIDE { 165 return ERR_CONNECTION_FAILED; 166 } 167 168 virtual void Disconnect() OVERRIDE {} 169 170 virtual bool IsConnected() const OVERRIDE { 171 return false; 172 } 173 virtual bool IsConnectedAndIdle() const OVERRIDE { 174 return false; 175 } 176 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { 177 return ERR_UNEXPECTED; 178 } 179 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { 180 return ERR_UNEXPECTED; 181 } 182 virtual const BoundNetLog& NetLog() const OVERRIDE { 183 return net_log_; 184 } 185 186 virtual void SetSubresourceSpeculation() OVERRIDE {} 187 virtual void SetOmniboxSpeculation() OVERRIDE {} 188 virtual bool WasEverUsed() const OVERRIDE { return false; } 189 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } 190 virtual bool WasNpnNegotiated() const OVERRIDE { 191 return false; 192 } 193 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { 194 return kProtoUnknown; 195 } 196 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { 197 return false; 198 } 199 200 // Socket implementation. 201 virtual int Read(IOBuffer* buf, int buf_len, 202 const CompletionCallback& callback) OVERRIDE { 203 return ERR_FAILED; 204 } 205 206 virtual int Write(IOBuffer* buf, int buf_len, 207 const CompletionCallback& callback) OVERRIDE { 208 return ERR_FAILED; 209 } 210 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } 211 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } 212 213 private: 214 const AddressList addrlist_; 215 BoundNetLog net_log_; 216 }; 217 218 class MockPendingClientSocket : public StreamSocket { 219 public: 220 // |should_connect| indicates whether the socket should successfully complete 221 // or fail. 222 // |should_stall| indicates that this socket should never connect. 223 // |delay_ms| is the delay, in milliseconds, before simulating a connect. 224 MockPendingClientSocket( 225 const AddressList& addrlist, 226 bool should_connect, 227 bool should_stall, 228 base::TimeDelta delay, 229 net::NetLog* net_log) 230 : weak_factory_(this), 231 should_connect_(should_connect), 232 should_stall_(should_stall), 233 delay_(delay), 234 is_connected_(false), 235 addrlist_(addrlist), 236 net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) { 237 } 238 239 // StreamSocket implementation. 240 virtual int Connect(const CompletionCallback& callback) OVERRIDE { 241 base::MessageLoop::current()->PostDelayedTask( 242 FROM_HERE, 243 base::Bind(&MockPendingClientSocket::DoCallback, 244 weak_factory_.GetWeakPtr(), callback), 245 delay_); 246 return ERR_IO_PENDING; 247 } 248 249 virtual void Disconnect() OVERRIDE {} 250 251 virtual bool IsConnected() const OVERRIDE { 252 return is_connected_; 253 } 254 virtual bool IsConnectedAndIdle() const OVERRIDE { 255 return is_connected_; 256 } 257 virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE { 258 return ERR_UNEXPECTED; 259 } 260 virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE { 261 if (!is_connected_) 262 return ERR_SOCKET_NOT_CONNECTED; 263 if (addrlist_.front().GetFamily() == ADDRESS_FAMILY_IPV4) 264 SetIPv4Address(address); 265 else 266 SetIPv6Address(address); 267 return OK; 268 } 269 virtual const BoundNetLog& NetLog() const OVERRIDE { 270 return net_log_; 271 } 272 273 virtual void SetSubresourceSpeculation() OVERRIDE {} 274 virtual void SetOmniboxSpeculation() OVERRIDE {} 275 virtual bool WasEverUsed() const OVERRIDE { return false; } 276 virtual bool UsingTCPFastOpen() const OVERRIDE { return false; } 277 virtual bool WasNpnNegotiated() const OVERRIDE { 278 return false; 279 } 280 virtual NextProto GetNegotiatedProtocol() const OVERRIDE { 281 return kProtoUnknown; 282 } 283 virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { 284 return false; 285 } 286 287 // Socket implementation. 288 virtual int Read(IOBuffer* buf, int buf_len, 289 const CompletionCallback& callback) OVERRIDE { 290 return ERR_FAILED; 291 } 292 293 virtual int Write(IOBuffer* buf, int buf_len, 294 const CompletionCallback& callback) OVERRIDE { 295 return ERR_FAILED; 296 } 297 virtual bool SetReceiveBufferSize(int32 size) OVERRIDE { return true; } 298 virtual bool SetSendBufferSize(int32 size) OVERRIDE { return true; } 299 300 private: 301 void DoCallback(const CompletionCallback& callback) { 302 if (should_stall_) 303 return; 304 305 if (should_connect_) { 306 is_connected_ = true; 307 callback.Run(OK); 308 } else { 309 is_connected_ = false; 310 callback.Run(ERR_CONNECTION_FAILED); 311 } 312 } 313 314 base::WeakPtrFactory<MockPendingClientSocket> weak_factory_; 315 bool should_connect_; 316 bool should_stall_; 317 base::TimeDelta delay_; 318 bool is_connected_; 319 const AddressList addrlist_; 320 BoundNetLog net_log_; 321 }; 322 323 class MockClientSocketFactory : public ClientSocketFactory { 324 public: 325 enum ClientSocketType { 326 MOCK_CLIENT_SOCKET, 327 MOCK_FAILING_CLIENT_SOCKET, 328 MOCK_PENDING_CLIENT_SOCKET, 329 MOCK_PENDING_FAILING_CLIENT_SOCKET, 330 // A delayed socket will pause before connecting through the message loop. 331 MOCK_DELAYED_CLIENT_SOCKET, 332 // A stalled socket that never connects at all. 333 MOCK_STALLED_CLIENT_SOCKET, 334 }; 335 336 explicit MockClientSocketFactory(NetLog* net_log) 337 : net_log_(net_log), allocation_count_(0), 338 client_socket_type_(MOCK_CLIENT_SOCKET), client_socket_types_(NULL), 339 client_socket_index_(0), client_socket_index_max_(0), 340 delay_(base::TimeDelta::FromMilliseconds( 341 ClientSocketPool::kMaxConnectRetryIntervalMs)) {} 342 343 virtual DatagramClientSocket* CreateDatagramClientSocket( 344 DatagramSocket::BindType bind_type, 345 const RandIntCallback& rand_int_cb, 346 NetLog* net_log, 347 const NetLog::Source& source) OVERRIDE { 348 NOTREACHED(); 349 return NULL; 350 } 351 352 virtual StreamSocket* CreateTransportClientSocket( 353 const AddressList& addresses, 354 NetLog* /* net_log */, 355 const NetLog::Source& /* source */) OVERRIDE { 356 allocation_count_++; 357 358 ClientSocketType type = client_socket_type_; 359 if (client_socket_types_ && 360 client_socket_index_ < client_socket_index_max_) { 361 type = client_socket_types_[client_socket_index_++]; 362 } 363 364 switch (type) { 365 case MOCK_CLIENT_SOCKET: 366 return new MockClientSocket(addresses, net_log_); 367 case MOCK_FAILING_CLIENT_SOCKET: 368 return new MockFailingClientSocket(addresses, net_log_); 369 case MOCK_PENDING_CLIENT_SOCKET: 370 return new MockPendingClientSocket( 371 addresses, true, false, base::TimeDelta(), net_log_); 372 case MOCK_PENDING_FAILING_CLIENT_SOCKET: 373 return new MockPendingClientSocket( 374 addresses, false, false, base::TimeDelta(), net_log_); 375 case MOCK_DELAYED_CLIENT_SOCKET: 376 return new MockPendingClientSocket( 377 addresses, true, false, delay_, net_log_); 378 case MOCK_STALLED_CLIENT_SOCKET: 379 return new MockPendingClientSocket( 380 addresses, true, true, base::TimeDelta(), net_log_); 381 default: 382 NOTREACHED(); 383 return new MockClientSocket(addresses, net_log_); 384 } 385 } 386 387 virtual SSLClientSocket* CreateSSLClientSocket( 388 ClientSocketHandle* transport_socket, 389 const HostPortPair& host_and_port, 390 const SSLConfig& ssl_config, 391 const SSLClientSocketContext& context) OVERRIDE { 392 NOTIMPLEMENTED(); 393 return NULL; 394 } 395 396 virtual void ClearSSLSessionCache() OVERRIDE { 397 NOTIMPLEMENTED(); 398 } 399 400 int allocation_count() const { return allocation_count_; } 401 402 // Set the default ClientSocketType. 403 void set_client_socket_type(ClientSocketType type) { 404 client_socket_type_ = type; 405 } 406 407 // Set a list of ClientSocketTypes to be used. 408 void set_client_socket_types(ClientSocketType* type_list, int num_types) { 409 DCHECK_GT(num_types, 0); 410 client_socket_types_ = type_list; 411 client_socket_index_ = 0; 412 client_socket_index_max_ = num_types; 413 } 414 415 void set_delay(base::TimeDelta delay) { delay_ = delay; } 416 417 private: 418 NetLog* net_log_; 419 int allocation_count_; 420 ClientSocketType client_socket_type_; 421 ClientSocketType* client_socket_types_; 422 int client_socket_index_; 423 int client_socket_index_max_; 424 base::TimeDelta delay_; 425 }; 426 427 class TransportClientSocketPoolTest : public testing::Test { 428 protected: 429 TransportClientSocketPoolTest() 430 : connect_backup_jobs_enabled_( 431 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true)), 432 params_( 433 new TransportSocketParams(HostPortPair("www.google.com", 80), 434 kDefaultPriority, false, false, 435 OnHostResolutionCallback())), 436 low_params_( 437 new TransportSocketParams(HostPortPair("www.google.com", 80), 438 LOW, false, false, 439 OnHostResolutionCallback())), 440 histograms_(new ClientSocketPoolHistograms("TCPUnitTest")), 441 host_resolver_(new MockHostResolver), 442 client_socket_factory_(&net_log_), 443 pool_(kMaxSockets, 444 kMaxSocketsPerGroup, 445 histograms_.get(), 446 host_resolver_.get(), 447 &client_socket_factory_, 448 NULL) { 449 } 450 451 virtual ~TransportClientSocketPoolTest() { 452 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled( 453 connect_backup_jobs_enabled_); 454 } 455 456 int StartRequest(const std::string& group_name, RequestPriority priority) { 457 scoped_refptr<TransportSocketParams> params(new TransportSocketParams( 458 HostPortPair("www.google.com", 80), MEDIUM, false, false, 459 OnHostResolutionCallback())); 460 return test_base_.StartRequestUsingPool( 461 &pool_, group_name, priority, params); 462 } 463 464 int GetOrderOfRequest(size_t index) { 465 return test_base_.GetOrderOfRequest(index); 466 } 467 468 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) { 469 return test_base_.ReleaseOneConnection(keep_alive); 470 } 471 472 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) { 473 test_base_.ReleaseAllConnections(keep_alive); 474 } 475 476 ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); } 477 size_t completion_count() const { return test_base_.completion_count(); } 478 479 bool connect_backup_jobs_enabled_; 480 CapturingNetLog net_log_; 481 scoped_refptr<TransportSocketParams> params_; 482 scoped_refptr<TransportSocketParams> low_params_; 483 scoped_ptr<ClientSocketPoolHistograms> histograms_; 484 scoped_ptr<MockHostResolver> host_resolver_; 485 MockClientSocketFactory client_socket_factory_; 486 TransportClientSocketPool pool_; 487 ClientSocketPoolTest test_base_; 488 }; 489 490 TEST(TransportConnectJobTest, MakeAddrListStartWithIPv4) { 491 IPAddressNumber ip_number; 492 ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.1", &ip_number)); 493 IPEndPoint addrlist_v4_1(ip_number, 80); 494 ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.2", &ip_number)); 495 IPEndPoint addrlist_v4_2(ip_number, 80); 496 ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::64", &ip_number)); 497 IPEndPoint addrlist_v6_1(ip_number, 80); 498 ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::66", &ip_number)); 499 IPEndPoint addrlist_v6_2(ip_number, 80); 500 501 AddressList addrlist; 502 503 // Test 1: IPv4 only. Expect no change. 504 addrlist.clear(); 505 addrlist.push_back(addrlist_v4_1); 506 addrlist.push_back(addrlist_v4_2); 507 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 508 ASSERT_EQ(2u, addrlist.size()); 509 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 510 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); 511 512 // Test 2: IPv6 only. Expect no change. 513 addrlist.clear(); 514 addrlist.push_back(addrlist_v6_1); 515 addrlist.push_back(addrlist_v6_2); 516 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 517 ASSERT_EQ(2u, addrlist.size()); 518 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[0].GetFamily()); 519 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily()); 520 521 // Test 3: IPv4 then IPv6. Expect no change. 522 addrlist.clear(); 523 addrlist.push_back(addrlist_v4_1); 524 addrlist.push_back(addrlist_v4_2); 525 addrlist.push_back(addrlist_v6_1); 526 addrlist.push_back(addrlist_v6_2); 527 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 528 ASSERT_EQ(4u, addrlist.size()); 529 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 530 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); 531 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily()); 532 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); 533 534 // Test 4: IPv6, IPv4, IPv6, IPv4. Expect first IPv6 moved to the end. 535 addrlist.clear(); 536 addrlist.push_back(addrlist_v6_1); 537 addrlist.push_back(addrlist_v4_1); 538 addrlist.push_back(addrlist_v6_2); 539 addrlist.push_back(addrlist_v4_2); 540 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 541 ASSERT_EQ(4u, addrlist.size()); 542 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 543 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily()); 544 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[2].GetFamily()); 545 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); 546 547 // Test 5: IPv6, IPv6, IPv4, IPv4. Expect first two IPv6's moved to the end. 548 addrlist.clear(); 549 addrlist.push_back(addrlist_v6_1); 550 addrlist.push_back(addrlist_v6_2); 551 addrlist.push_back(addrlist_v4_1); 552 addrlist.push_back(addrlist_v4_2); 553 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 554 ASSERT_EQ(4u, addrlist.size()); 555 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 556 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); 557 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily()); 558 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); 559 } 560 561 TEST_F(TransportClientSocketPoolTest, Basic) { 562 TestCompletionCallback callback; 563 ClientSocketHandle handle; 564 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_, 565 BoundNetLog()); 566 EXPECT_EQ(ERR_IO_PENDING, rv); 567 EXPECT_FALSE(handle.is_initialized()); 568 EXPECT_FALSE(handle.socket()); 569 570 EXPECT_EQ(OK, callback.WaitForResult()); 571 EXPECT_TRUE(handle.is_initialized()); 572 EXPECT_TRUE(handle.socket()); 573 TestLoadTimingInfoConnectedNotReused(handle); 574 } 575 576 TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) { 577 host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name"); 578 TestCompletionCallback callback; 579 ClientSocketHandle handle; 580 HostPortPair host_port_pair("unresolvable.host.name", 80); 581 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( 582 host_port_pair, kDefaultPriority, false, false, 583 OnHostResolutionCallback())); 584 EXPECT_EQ(ERR_IO_PENDING, 585 handle.Init("a", dest, kDefaultPriority, callback.callback(), 586 &pool_, BoundNetLog())); 587 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult()); 588 } 589 590 TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) { 591 client_socket_factory_.set_client_socket_type( 592 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET); 593 TestCompletionCallback callback; 594 ClientSocketHandle handle; 595 EXPECT_EQ(ERR_IO_PENDING, 596 handle.Init("a", params_, kDefaultPriority, callback.callback(), 597 &pool_, BoundNetLog())); 598 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 599 600 // Make the host resolutions complete synchronously this time. 601 host_resolver_->set_synchronous_mode(true); 602 EXPECT_EQ(ERR_CONNECTION_FAILED, 603 handle.Init("a", params_, kDefaultPriority, callback.callback(), 604 &pool_, BoundNetLog())); 605 } 606 607 TEST_F(TransportClientSocketPoolTest, PendingRequests) { 608 // First request finishes asynchronously. 609 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 610 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); 611 612 // Make all subsequent host resolutions complete synchronously. 613 host_resolver_->set_synchronous_mode(true); 614 615 // Rest of them finish synchronously, until we reach the per-group limit. 616 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 617 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 618 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 619 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 620 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 621 622 // The rest are pending since we've used all active sockets. 623 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 624 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 625 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 626 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 627 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 628 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 629 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 630 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 631 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 632 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 633 634 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); 635 636 EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count()); 637 638 // One initial asynchronous request and then 10 pending requests. 639 EXPECT_EQ(11U, completion_count()); 640 641 // First part of requests, all with the same priority, finishes in FIFO order. 642 EXPECT_EQ(1, GetOrderOfRequest(1)); 643 EXPECT_EQ(2, GetOrderOfRequest(2)); 644 EXPECT_EQ(3, GetOrderOfRequest(3)); 645 EXPECT_EQ(4, GetOrderOfRequest(4)); 646 EXPECT_EQ(5, GetOrderOfRequest(5)); 647 EXPECT_EQ(6, GetOrderOfRequest(6)); 648 649 // Make sure that rest of the requests complete in the order of priority. 650 EXPECT_EQ(7, GetOrderOfRequest(7)); 651 EXPECT_EQ(14, GetOrderOfRequest(8)); 652 EXPECT_EQ(15, GetOrderOfRequest(9)); 653 EXPECT_EQ(10, GetOrderOfRequest(10)); 654 EXPECT_EQ(13, GetOrderOfRequest(11)); 655 EXPECT_EQ(8, GetOrderOfRequest(12)); 656 EXPECT_EQ(16, GetOrderOfRequest(13)); 657 EXPECT_EQ(11, GetOrderOfRequest(14)); 658 EXPECT_EQ(12, GetOrderOfRequest(15)); 659 EXPECT_EQ(9, GetOrderOfRequest(16)); 660 661 // Make sure we test order of all requests made. 662 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); 663 } 664 665 TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) { 666 // First request finishes asynchronously. 667 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 668 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); 669 670 // Make all subsequent host resolutions complete synchronously. 671 host_resolver_->set_synchronous_mode(true); 672 673 // Rest of them finish synchronously, until we reach the per-group limit. 674 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 675 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 676 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 677 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 678 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 679 680 // The rest are pending since we've used all active sockets. 681 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 682 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 683 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 684 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 685 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 686 687 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 688 689 // The pending requests should finish successfully. 690 EXPECT_EQ(OK, (*requests())[6]->WaitForResult()); 691 EXPECT_EQ(OK, (*requests())[7]->WaitForResult()); 692 EXPECT_EQ(OK, (*requests())[8]->WaitForResult()); 693 EXPECT_EQ(OK, (*requests())[9]->WaitForResult()); 694 EXPECT_EQ(OK, (*requests())[10]->WaitForResult()); 695 696 EXPECT_EQ(static_cast<int>(requests()->size()), 697 client_socket_factory_.allocation_count()); 698 699 // First asynchronous request, and then last 5 pending requests. 700 EXPECT_EQ(6U, completion_count()); 701 } 702 703 // This test will start up a RequestSocket() and then immediately Cancel() it. 704 // The pending host resolution will eventually complete, and destroy the 705 // ClientSocketPool which will crash if the group was not cleared properly. 706 TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) { 707 TestCompletionCallback callback; 708 ClientSocketHandle handle; 709 EXPECT_EQ(ERR_IO_PENDING, 710 handle.Init("a", params_, kDefaultPriority, callback.callback(), 711 &pool_, BoundNetLog())); 712 handle.Reset(); 713 } 714 715 TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) { 716 ClientSocketHandle handle; 717 TestCompletionCallback callback; 718 ClientSocketHandle handle2; 719 TestCompletionCallback callback2; 720 721 EXPECT_EQ(ERR_IO_PENDING, 722 handle.Init("a", params_, kDefaultPriority, callback.callback(), 723 &pool_, BoundNetLog())); 724 EXPECT_EQ(ERR_IO_PENDING, 725 handle2.Init("a", params_, kDefaultPriority, callback2.callback(), 726 &pool_, BoundNetLog())); 727 728 handle.Reset(); 729 730 EXPECT_EQ(OK, callback2.WaitForResult()); 731 handle2.Reset(); 732 } 733 734 TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) { 735 client_socket_factory_.set_client_socket_type( 736 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); 737 ClientSocketHandle handle; 738 TestCompletionCallback callback; 739 EXPECT_EQ(ERR_IO_PENDING, 740 handle.Init("a", params_, kDefaultPriority, callback.callback(), 741 &pool_, BoundNetLog())); 742 743 handle.Reset(); 744 745 TestCompletionCallback callback2; 746 EXPECT_EQ(ERR_IO_PENDING, 747 handle.Init("a", params_, kDefaultPriority, callback2.callback(), 748 &pool_, BoundNetLog())); 749 750 host_resolver_->set_synchronous_mode(true); 751 // At this point, handle has two ConnectingSockets out for it. Due to the 752 // setting the mock resolver into synchronous mode, the host resolution for 753 // both will return in the same loop of the MessageLoop. The client socket 754 // is a pending socket, so the Connect() will asynchronously complete on the 755 // next loop of the MessageLoop. That means that the first 756 // ConnectingSocket will enter OnIOComplete, and then the second one will. 757 // If the first one is not cancelled, it will advance the load state, and 758 // then the second one will crash. 759 760 EXPECT_EQ(OK, callback2.WaitForResult()); 761 EXPECT_FALSE(callback.have_result()); 762 763 handle.Reset(); 764 } 765 766 TEST_F(TransportClientSocketPoolTest, CancelRequest) { 767 // First request finishes asynchronously. 768 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 769 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); 770 771 // Make all subsequent host resolutions complete synchronously. 772 host_resolver_->set_synchronous_mode(true); 773 774 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 775 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 776 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 777 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 778 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 779 780 // Reached per-group limit, queue up requests. 781 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 782 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 783 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 784 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 785 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 786 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 787 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 788 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 789 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 790 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 791 792 // Cancel a request. 793 size_t index_to_cancel = kMaxSocketsPerGroup + 2; 794 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized()); 795 (*requests())[index_to_cancel]->handle()->Reset(); 796 797 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); 798 799 EXPECT_EQ(kMaxSocketsPerGroup, 800 client_socket_factory_.allocation_count()); 801 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count()); 802 803 EXPECT_EQ(1, GetOrderOfRequest(1)); 804 EXPECT_EQ(2, GetOrderOfRequest(2)); 805 EXPECT_EQ(3, GetOrderOfRequest(3)); 806 EXPECT_EQ(4, GetOrderOfRequest(4)); 807 EXPECT_EQ(5, GetOrderOfRequest(5)); 808 EXPECT_EQ(6, GetOrderOfRequest(6)); 809 EXPECT_EQ(14, GetOrderOfRequest(7)); 810 EXPECT_EQ(7, GetOrderOfRequest(8)); 811 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, 812 GetOrderOfRequest(9)); // Canceled request. 813 EXPECT_EQ(9, GetOrderOfRequest(10)); 814 EXPECT_EQ(10, GetOrderOfRequest(11)); 815 EXPECT_EQ(11, GetOrderOfRequest(12)); 816 EXPECT_EQ(8, GetOrderOfRequest(13)); 817 EXPECT_EQ(12, GetOrderOfRequest(14)); 818 EXPECT_EQ(13, GetOrderOfRequest(15)); 819 EXPECT_EQ(15, GetOrderOfRequest(16)); 820 821 // Make sure we test order of all requests made. 822 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); 823 } 824 825 class RequestSocketCallback : public TestCompletionCallbackBase { 826 public: 827 RequestSocketCallback(ClientSocketHandle* handle, 828 TransportClientSocketPool* pool) 829 : handle_(handle), 830 pool_(pool), 831 within_callback_(false), 832 callback_(base::Bind(&RequestSocketCallback::OnComplete, 833 base::Unretained(this))) { 834 } 835 836 virtual ~RequestSocketCallback() {} 837 838 const CompletionCallback& callback() const { return callback_; } 839 840 private: 841 void OnComplete(int result) { 842 SetResult(result); 843 ASSERT_EQ(OK, result); 844 845 if (!within_callback_) { 846 // Don't allow reuse of the socket. Disconnect it and then release it and 847 // run through the MessageLoop once to get it completely released. 848 handle_->socket()->Disconnect(); 849 handle_->Reset(); 850 { 851 base::MessageLoop::ScopedNestableTaskAllower allow( 852 base::MessageLoop::current()); 853 base::MessageLoop::current()->RunUntilIdle(); 854 } 855 within_callback_ = true; 856 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( 857 HostPortPair("www.google.com", 80), LOWEST, false, false, 858 OnHostResolutionCallback())); 859 int rv = handle_->Init("a", dest, LOWEST, callback(), pool_, 860 BoundNetLog()); 861 EXPECT_EQ(OK, rv); 862 } 863 } 864 865 ClientSocketHandle* const handle_; 866 TransportClientSocketPool* const pool_; 867 bool within_callback_; 868 CompletionCallback callback_; 869 870 DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback); 871 }; 872 873 TEST_F(TransportClientSocketPoolTest, RequestTwice) { 874 ClientSocketHandle handle; 875 RequestSocketCallback callback(&handle, &pool_); 876 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( 877 HostPortPair("www.google.com", 80), LOWEST, false, false, 878 OnHostResolutionCallback())); 879 int rv = handle.Init("a", dest, LOWEST, callback.callback(), &pool_, 880 BoundNetLog()); 881 ASSERT_EQ(ERR_IO_PENDING, rv); 882 883 // The callback is going to request "www.google.com". We want it to complete 884 // synchronously this time. 885 host_resolver_->set_synchronous_mode(true); 886 887 EXPECT_EQ(OK, callback.WaitForResult()); 888 889 handle.Reset(); 890 } 891 892 // Make sure that pending requests get serviced after active requests get 893 // cancelled. 894 TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) { 895 client_socket_factory_.set_client_socket_type( 896 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); 897 898 // Queue up all the requests 899 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 900 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 901 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 902 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 903 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 904 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 905 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 906 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 907 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 908 909 // Now, kMaxSocketsPerGroup requests should be active. Let's cancel them. 910 ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size())); 911 for (int i = 0; i < kMaxSocketsPerGroup; i++) 912 (*requests())[i]->handle()->Reset(); 913 914 // Let's wait for the rest to complete now. 915 for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) { 916 EXPECT_EQ(OK, (*requests())[i]->WaitForResult()); 917 (*requests())[i]->handle()->Reset(); 918 } 919 920 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count()); 921 } 922 923 // Make sure that pending requests get serviced after active requests fail. 924 TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) { 925 client_socket_factory_.set_client_socket_type( 926 MockClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET); 927 928 const int kNumRequests = 2 * kMaxSocketsPerGroup + 1; 929 ASSERT_LE(kNumRequests, kMaxSockets); // Otherwise the test will hang. 930 931 // Queue up all the requests 932 for (int i = 0; i < kNumRequests; i++) 933 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 934 935 for (int i = 0; i < kNumRequests; i++) 936 EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult()); 937 } 938 939 TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) { 940 TestCompletionCallback callback; 941 ClientSocketHandle handle; 942 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_, 943 BoundNetLog()); 944 EXPECT_EQ(ERR_IO_PENDING, rv); 945 EXPECT_FALSE(handle.is_initialized()); 946 EXPECT_FALSE(handle.socket()); 947 948 EXPECT_EQ(OK, callback.WaitForResult()); 949 EXPECT_TRUE(handle.is_initialized()); 950 EXPECT_TRUE(handle.socket()); 951 TestLoadTimingInfoConnectedNotReused(handle); 952 953 handle.Reset(); 954 // Need to run all pending to release the socket back to the pool. 955 base::MessageLoop::current()->RunUntilIdle(); 956 957 // Now we should have 1 idle socket. 958 EXPECT_EQ(1, pool_.IdleSocketCount()); 959 960 rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_, 961 BoundNetLog()); 962 EXPECT_EQ(OK, rv); 963 EXPECT_EQ(0, pool_.IdleSocketCount()); 964 TestLoadTimingInfoConnectedReused(handle); 965 } 966 967 TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) { 968 TestCompletionCallback callback; 969 ClientSocketHandle handle; 970 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool_, 971 BoundNetLog()); 972 EXPECT_EQ(ERR_IO_PENDING, rv); 973 EXPECT_FALSE(handle.is_initialized()); 974 EXPECT_FALSE(handle.socket()); 975 976 EXPECT_EQ(OK, callback.WaitForResult()); 977 EXPECT_TRUE(handle.is_initialized()); 978 EXPECT_TRUE(handle.socket()); 979 980 handle.Reset(); 981 982 // Need to run all pending to release the socket back to the pool. 983 base::MessageLoop::current()->RunUntilIdle(); 984 985 // Now we should have 1 idle socket. 986 EXPECT_EQ(1, pool_.IdleSocketCount()); 987 988 // After an IP address change, we should have 0 idle sockets. 989 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 990 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. 991 992 EXPECT_EQ(0, pool_.IdleSocketCount()); 993 } 994 995 TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) { 996 // Case 1 tests the first socket stalling, and the backup connecting. 997 MockClientSocketFactory::ClientSocketType case1_types[] = { 998 // The first socket will not connect. 999 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, 1000 // The second socket will connect more quickly. 1001 MockClientSocketFactory::MOCK_CLIENT_SOCKET 1002 }; 1003 1004 // Case 2 tests the first socket being slow, so that we start the 1005 // second connect, but the second connect stalls, and we still 1006 // complete the first. 1007 MockClientSocketFactory::ClientSocketType case2_types[] = { 1008 // The first socket will connect, although delayed. 1009 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, 1010 // The second socket will not connect. 1011 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET 1012 }; 1013 1014 MockClientSocketFactory::ClientSocketType* cases[2] = { 1015 case1_types, 1016 case2_types 1017 }; 1018 1019 for (size_t index = 0; index < arraysize(cases); ++index) { 1020 client_socket_factory_.set_client_socket_types(cases[index], 2); 1021 1022 EXPECT_EQ(0, pool_.IdleSocketCount()); 1023 1024 TestCompletionCallback callback; 1025 ClientSocketHandle handle; 1026 int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_, 1027 BoundNetLog()); 1028 EXPECT_EQ(ERR_IO_PENDING, rv); 1029 EXPECT_FALSE(handle.is_initialized()); 1030 EXPECT_FALSE(handle.socket()); 1031 1032 // Create the first socket, set the timer. 1033 base::MessageLoop::current()->RunUntilIdle(); 1034 1035 // Wait for the backup socket timer to fire. 1036 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 1037 ClientSocketPool::kMaxConnectRetryIntervalMs + 50)); 1038 1039 // Let the appropriate socket connect. 1040 base::MessageLoop::current()->RunUntilIdle(); 1041 1042 EXPECT_EQ(OK, callback.WaitForResult()); 1043 EXPECT_TRUE(handle.is_initialized()); 1044 EXPECT_TRUE(handle.socket()); 1045 1046 // One socket is stalled, the other is active. 1047 EXPECT_EQ(0, pool_.IdleSocketCount()); 1048 handle.Reset(); 1049 1050 // Close all pending connect jobs and existing sockets. 1051 pool_.FlushWithError(ERR_NETWORK_CHANGED); 1052 } 1053 } 1054 1055 // Test the case where a socket took long enough to start the creation 1056 // of the backup socket, but then we cancelled the request after that. 1057 TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) { 1058 client_socket_factory_.set_client_socket_type( 1059 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET); 1060 1061 enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT }; 1062 1063 for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) { 1064 EXPECT_EQ(0, pool_.IdleSocketCount()); 1065 1066 TestCompletionCallback callback; 1067 ClientSocketHandle handle; 1068 int rv = handle.Init("c", low_params_, LOW, callback.callback(), &pool_, 1069 BoundNetLog()); 1070 EXPECT_EQ(ERR_IO_PENDING, rv); 1071 EXPECT_FALSE(handle.is_initialized()); 1072 EXPECT_FALSE(handle.socket()); 1073 1074 // Create the first socket, set the timer. 1075 base::MessageLoop::current()->RunUntilIdle(); 1076 1077 if (index == CANCEL_AFTER_WAIT) { 1078 // Wait for the backup socket timer to fire. 1079 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 1080 ClientSocketPool::kMaxConnectRetryIntervalMs)); 1081 } 1082 1083 // Let the appropriate socket connect. 1084 base::MessageLoop::current()->RunUntilIdle(); 1085 1086 handle.Reset(); 1087 1088 EXPECT_FALSE(callback.have_result()); 1089 EXPECT_FALSE(handle.is_initialized()); 1090 EXPECT_FALSE(handle.socket()); 1091 1092 // One socket is stalled, the other is active. 1093 EXPECT_EQ(0, pool_.IdleSocketCount()); 1094 } 1095 } 1096 1097 // Test the case where a socket took long enough to start the creation 1098 // of the backup socket and never completes, and then the backup 1099 // connection fails. 1100 TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) { 1101 MockClientSocketFactory::ClientSocketType case_types[] = { 1102 // The first socket will not connect. 1103 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, 1104 // The second socket will fail immediately. 1105 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET 1106 }; 1107 1108 client_socket_factory_.set_client_socket_types(case_types, 2); 1109 1110 EXPECT_EQ(0, pool_.IdleSocketCount()); 1111 1112 TestCompletionCallback callback; 1113 ClientSocketHandle handle; 1114 int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_, 1115 BoundNetLog()); 1116 EXPECT_EQ(ERR_IO_PENDING, rv); 1117 EXPECT_FALSE(handle.is_initialized()); 1118 EXPECT_FALSE(handle.socket()); 1119 1120 // Create the first socket, set the timer. 1121 base::MessageLoop::current()->RunUntilIdle(); 1122 1123 // Wait for the backup socket timer to fire. 1124 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 1125 ClientSocketPool::kMaxConnectRetryIntervalMs)); 1126 1127 // Let the second connect be synchronous. Otherwise, the emulated 1128 // host resolution takes an extra trip through the message loop. 1129 host_resolver_->set_synchronous_mode(true); 1130 1131 // Let the appropriate socket connect. 1132 base::MessageLoop::current()->RunUntilIdle(); 1133 1134 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 1135 EXPECT_FALSE(handle.is_initialized()); 1136 EXPECT_FALSE(handle.socket()); 1137 EXPECT_EQ(0, pool_.IdleSocketCount()); 1138 handle.Reset(); 1139 1140 // Reset for the next case. 1141 host_resolver_->set_synchronous_mode(false); 1142 } 1143 1144 // Test the case where a socket took long enough to start the creation 1145 // of the backup socket and eventually completes, but the backup socket 1146 // fails. 1147 TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) { 1148 MockClientSocketFactory::ClientSocketType case_types[] = { 1149 // The first socket will connect, although delayed. 1150 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, 1151 // The second socket will not connect. 1152 MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET 1153 }; 1154 1155 client_socket_factory_.set_client_socket_types(case_types, 2); 1156 client_socket_factory_.set_delay(base::TimeDelta::FromSeconds(5)); 1157 1158 EXPECT_EQ(0, pool_.IdleSocketCount()); 1159 1160 TestCompletionCallback callback; 1161 ClientSocketHandle handle; 1162 int rv = handle.Init("b", low_params_, LOW, callback.callback(), &pool_, 1163 BoundNetLog()); 1164 EXPECT_EQ(ERR_IO_PENDING, rv); 1165 EXPECT_FALSE(handle.is_initialized()); 1166 EXPECT_FALSE(handle.socket()); 1167 1168 // Create the first socket, set the timer. 1169 base::MessageLoop::current()->RunUntilIdle(); 1170 1171 // Wait for the backup socket timer to fire. 1172 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 1173 ClientSocketPool::kMaxConnectRetryIntervalMs)); 1174 1175 // Let the second connect be synchronous. Otherwise, the emulated 1176 // host resolution takes an extra trip through the message loop. 1177 host_resolver_->set_synchronous_mode(true); 1178 1179 // Let the appropriate socket connect. 1180 base::MessageLoop::current()->RunUntilIdle(); 1181 1182 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 1183 EXPECT_FALSE(handle.is_initialized()); 1184 EXPECT_FALSE(handle.socket()); 1185 handle.Reset(); 1186 1187 // Reset for the next case. 1188 host_resolver_->set_synchronous_mode(false); 1189 } 1190 1191 // Test the case of the IPv6 address stalling, and falling back to the IPv4 1192 // socket which finishes first. 1193 TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) { 1194 // Create a pool without backup jobs. 1195 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 1196 TransportClientSocketPool pool(kMaxSockets, 1197 kMaxSocketsPerGroup, 1198 histograms_.get(), 1199 host_resolver_.get(), 1200 &client_socket_factory_, 1201 NULL); 1202 1203 MockClientSocketFactory::ClientSocketType case_types[] = { 1204 // This is the IPv6 socket. 1205 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, 1206 // This is the IPv4 socket. 1207 MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET 1208 }; 1209 1210 client_socket_factory_.set_client_socket_types(case_types, 2); 1211 1212 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. 1213 host_resolver_->rules() 1214 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); 1215 1216 TestCompletionCallback callback; 1217 ClientSocketHandle handle; 1218 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, 1219 BoundNetLog()); 1220 EXPECT_EQ(ERR_IO_PENDING, rv); 1221 EXPECT_FALSE(handle.is_initialized()); 1222 EXPECT_FALSE(handle.socket()); 1223 1224 EXPECT_EQ(OK, callback.WaitForResult()); 1225 EXPECT_TRUE(handle.is_initialized()); 1226 EXPECT_TRUE(handle.socket()); 1227 IPEndPoint endpoint; 1228 handle.socket()->GetLocalAddress(&endpoint); 1229 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); 1230 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 1231 } 1232 1233 // Test the case of the IPv6 address being slow, thus falling back to trying to 1234 // connect to the IPv4 address, but having the connect to the IPv6 address 1235 // finish first. 1236 TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) { 1237 // Create a pool without backup jobs. 1238 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 1239 TransportClientSocketPool pool(kMaxSockets, 1240 kMaxSocketsPerGroup, 1241 histograms_.get(), 1242 host_resolver_.get(), 1243 &client_socket_factory_, 1244 NULL); 1245 1246 MockClientSocketFactory::ClientSocketType case_types[] = { 1247 // This is the IPv6 socket. 1248 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, 1249 // This is the IPv4 socket. 1250 MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET 1251 }; 1252 1253 client_socket_factory_.set_client_socket_types(case_types, 2); 1254 client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds( 1255 TransportConnectJob::kIPv6FallbackTimerInMs + 50)); 1256 1257 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. 1258 host_resolver_->rules() 1259 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); 1260 1261 TestCompletionCallback callback; 1262 ClientSocketHandle handle; 1263 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, 1264 BoundNetLog()); 1265 EXPECT_EQ(ERR_IO_PENDING, rv); 1266 EXPECT_FALSE(handle.is_initialized()); 1267 EXPECT_FALSE(handle.socket()); 1268 1269 EXPECT_EQ(OK, callback.WaitForResult()); 1270 EXPECT_TRUE(handle.is_initialized()); 1271 EXPECT_TRUE(handle.socket()); 1272 IPEndPoint endpoint; 1273 handle.socket()->GetLocalAddress(&endpoint); 1274 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); 1275 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 1276 } 1277 1278 TEST_F(TransportClientSocketPoolTest, IPv6NoIPv4AddressesToFallbackTo) { 1279 // Create a pool without backup jobs. 1280 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 1281 TransportClientSocketPool pool(kMaxSockets, 1282 kMaxSocketsPerGroup, 1283 histograms_.get(), 1284 host_resolver_.get(), 1285 &client_socket_factory_, 1286 NULL); 1287 1288 client_socket_factory_.set_client_socket_type( 1289 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); 1290 1291 // Resolve an AddressList with only IPv6 addresses. 1292 host_resolver_->rules() 1293 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string()); 1294 1295 TestCompletionCallback callback; 1296 ClientSocketHandle handle; 1297 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, 1298 BoundNetLog()); 1299 EXPECT_EQ(ERR_IO_PENDING, rv); 1300 EXPECT_FALSE(handle.is_initialized()); 1301 EXPECT_FALSE(handle.socket()); 1302 1303 EXPECT_EQ(OK, callback.WaitForResult()); 1304 EXPECT_TRUE(handle.is_initialized()); 1305 EXPECT_TRUE(handle.socket()); 1306 IPEndPoint endpoint; 1307 handle.socket()->GetLocalAddress(&endpoint); 1308 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); 1309 EXPECT_EQ(1, client_socket_factory_.allocation_count()); 1310 } 1311 1312 TEST_F(TransportClientSocketPoolTest, IPv4HasNoFallback) { 1313 // Create a pool without backup jobs. 1314 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 1315 TransportClientSocketPool pool(kMaxSockets, 1316 kMaxSocketsPerGroup, 1317 histograms_.get(), 1318 host_resolver_.get(), 1319 &client_socket_factory_, 1320 NULL); 1321 1322 client_socket_factory_.set_client_socket_type( 1323 MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); 1324 1325 // Resolve an AddressList with only IPv4 addresses. 1326 host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string()); 1327 1328 TestCompletionCallback callback; 1329 ClientSocketHandle handle; 1330 int rv = handle.Init("a", low_params_, LOW, callback.callback(), &pool, 1331 BoundNetLog()); 1332 EXPECT_EQ(ERR_IO_PENDING, rv); 1333 EXPECT_FALSE(handle.is_initialized()); 1334 EXPECT_FALSE(handle.socket()); 1335 1336 EXPECT_EQ(OK, callback.WaitForResult()); 1337 EXPECT_TRUE(handle.is_initialized()); 1338 EXPECT_TRUE(handle.socket()); 1339 IPEndPoint endpoint; 1340 handle.socket()->GetLocalAddress(&endpoint); 1341 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); 1342 EXPECT_EQ(1, client_socket_factory_.allocation_count()); 1343 } 1344 1345 } // namespace 1346 1347 } // namespace net 1348
