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/message_loop/message_loop.h" 11#include "base/threading/platform_thread.h" 12#include "net/base/capturing_net_log.h" 13#include "net/base/ip_endpoint.h" 14#include "net/base/load_timing_info.h" 15#include "net/base/load_timing_info_test_util.h" 16#include "net/base/net_errors.h" 17#include "net/base/net_util.h" 18#include "net/base/test_completion_callback.h" 19#include "net/dns/mock_host_resolver.h" 20#include "net/socket/client_socket_handle.h" 21#include "net/socket/client_socket_pool_histograms.h" 22#include "net/socket/socket_test_util.h" 23#include "net/socket/stream_socket.h" 24#include "net/socket/transport_client_socket_pool_test_util.h" 25#include "testing/gtest/include/gtest/gtest.h" 26 27namespace net { 28 29using internal::ClientSocketPoolBaseHelper; 30 31namespace { 32 33const int kMaxSockets = 32; 34const int kMaxSocketsPerGroup = 6; 35const RequestPriority kDefaultPriority = LOW; 36 37class TransportClientSocketPoolTest : public testing::Test { 38 protected: 39 TransportClientSocketPoolTest() 40 : connect_backup_jobs_enabled_( 41 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true)), 42 params_( 43 new TransportSocketParams( 44 HostPortPair("www.google.com", 80), 45 false, 46 false, 47 OnHostResolutionCallback(), 48 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)), 49 histograms_(new ClientSocketPoolHistograms("TCPUnitTest")), 50 host_resolver_(new MockHostResolver), 51 client_socket_factory_(&net_log_), 52 pool_(kMaxSockets, 53 kMaxSocketsPerGroup, 54 histograms_.get(), 55 host_resolver_.get(), 56 &client_socket_factory_, 57 NULL) { 58 } 59 60 virtual ~TransportClientSocketPoolTest() { 61 internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled( 62 connect_backup_jobs_enabled_); 63 } 64 65 scoped_refptr<TransportSocketParams> CreateParamsForTCPFastOpen() { 66 return new TransportSocketParams(HostPortPair("www.google.com", 80), 67 false, false, OnHostResolutionCallback(), 68 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DESIRED); 69 } 70 71 int StartRequest(const std::string& group_name, RequestPriority priority) { 72 scoped_refptr<TransportSocketParams> params(new TransportSocketParams( 73 HostPortPair("www.google.com", 80), false, false, 74 OnHostResolutionCallback(), 75 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); 76 return test_base_.StartRequestUsingPool( 77 &pool_, group_name, priority, params); 78 } 79 80 int GetOrderOfRequest(size_t index) { 81 return test_base_.GetOrderOfRequest(index); 82 } 83 84 bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) { 85 return test_base_.ReleaseOneConnection(keep_alive); 86 } 87 88 void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) { 89 test_base_.ReleaseAllConnections(keep_alive); 90 } 91 92 ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); } 93 size_t completion_count() const { return test_base_.completion_count(); } 94 95 bool connect_backup_jobs_enabled_; 96 CapturingNetLog net_log_; 97 scoped_refptr<TransportSocketParams> params_; 98 scoped_ptr<ClientSocketPoolHistograms> histograms_; 99 scoped_ptr<MockHostResolver> host_resolver_; 100 MockTransportClientSocketFactory client_socket_factory_; 101 TransportClientSocketPool pool_; 102 ClientSocketPoolTest test_base_; 103 104 private: 105 DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPoolTest); 106}; 107 108TEST(TransportConnectJobTest, MakeAddrListStartWithIPv4) { 109 IPAddressNumber ip_number; 110 ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.1", &ip_number)); 111 IPEndPoint addrlist_v4_1(ip_number, 80); 112 ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.2", &ip_number)); 113 IPEndPoint addrlist_v4_2(ip_number, 80); 114 ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::64", &ip_number)); 115 IPEndPoint addrlist_v6_1(ip_number, 80); 116 ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::66", &ip_number)); 117 IPEndPoint addrlist_v6_2(ip_number, 80); 118 119 AddressList addrlist; 120 121 // Test 1: IPv4 only. Expect no change. 122 addrlist.clear(); 123 addrlist.push_back(addrlist_v4_1); 124 addrlist.push_back(addrlist_v4_2); 125 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 126 ASSERT_EQ(2u, addrlist.size()); 127 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 128 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); 129 130 // Test 2: IPv6 only. Expect no change. 131 addrlist.clear(); 132 addrlist.push_back(addrlist_v6_1); 133 addrlist.push_back(addrlist_v6_2); 134 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 135 ASSERT_EQ(2u, addrlist.size()); 136 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[0].GetFamily()); 137 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily()); 138 139 // Test 3: IPv4 then IPv6. Expect no change. 140 addrlist.clear(); 141 addrlist.push_back(addrlist_v4_1); 142 addrlist.push_back(addrlist_v4_2); 143 addrlist.push_back(addrlist_v6_1); 144 addrlist.push_back(addrlist_v6_2); 145 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 146 ASSERT_EQ(4u, addrlist.size()); 147 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 148 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); 149 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily()); 150 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); 151 152 // Test 4: IPv6, IPv4, IPv6, IPv4. Expect first IPv6 moved to the end. 153 addrlist.clear(); 154 addrlist.push_back(addrlist_v6_1); 155 addrlist.push_back(addrlist_v4_1); 156 addrlist.push_back(addrlist_v6_2); 157 addrlist.push_back(addrlist_v4_2); 158 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 159 ASSERT_EQ(4u, addrlist.size()); 160 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 161 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily()); 162 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[2].GetFamily()); 163 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); 164 165 // Test 5: IPv6, IPv6, IPv4, IPv4. Expect first two IPv6's moved to the end. 166 addrlist.clear(); 167 addrlist.push_back(addrlist_v6_1); 168 addrlist.push_back(addrlist_v6_2); 169 addrlist.push_back(addrlist_v4_1); 170 addrlist.push_back(addrlist_v4_2); 171 TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist); 172 ASSERT_EQ(4u, addrlist.size()); 173 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily()); 174 EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily()); 175 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily()); 176 EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily()); 177} 178 179TEST_F(TransportClientSocketPoolTest, Basic) { 180 TestCompletionCallback callback; 181 ClientSocketHandle handle; 182 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, 183 BoundNetLog()); 184 EXPECT_EQ(ERR_IO_PENDING, rv); 185 EXPECT_FALSE(handle.is_initialized()); 186 EXPECT_FALSE(handle.socket()); 187 188 EXPECT_EQ(OK, callback.WaitForResult()); 189 EXPECT_TRUE(handle.is_initialized()); 190 EXPECT_TRUE(handle.socket()); 191 TestLoadTimingInfoConnectedNotReused(handle); 192} 193 194// Make sure that TransportConnectJob passes on its priority to its 195// HostResolver request on Init. 196TEST_F(TransportClientSocketPoolTest, SetResolvePriorityOnInit) { 197 for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) { 198 RequestPriority priority = static_cast<RequestPriority>(i); 199 TestCompletionCallback callback; 200 ClientSocketHandle handle; 201 EXPECT_EQ(ERR_IO_PENDING, 202 handle.Init("a", params_, priority, callback.callback(), &pool_, 203 BoundNetLog())); 204 EXPECT_EQ(priority, host_resolver_->last_request_priority()); 205 } 206} 207 208TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) { 209 host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name"); 210 TestCompletionCallback callback; 211 ClientSocketHandle handle; 212 HostPortPair host_port_pair("unresolvable.host.name", 80); 213 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( 214 host_port_pair, false, false, OnHostResolutionCallback(), 215 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); 216 EXPECT_EQ(ERR_IO_PENDING, 217 handle.Init("a", dest, kDefaultPriority, callback.callback(), 218 &pool_, BoundNetLog())); 219 EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult()); 220} 221 222TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) { 223 client_socket_factory_.set_default_client_socket_type( 224 MockTransportClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET); 225 TestCompletionCallback callback; 226 ClientSocketHandle handle; 227 EXPECT_EQ(ERR_IO_PENDING, 228 handle.Init("a", params_, kDefaultPriority, callback.callback(), 229 &pool_, BoundNetLog())); 230 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 231 232 // Make the host resolutions complete synchronously this time. 233 host_resolver_->set_synchronous_mode(true); 234 EXPECT_EQ(ERR_CONNECTION_FAILED, 235 handle.Init("a", params_, kDefaultPriority, callback.callback(), 236 &pool_, BoundNetLog())); 237} 238 239TEST_F(TransportClientSocketPoolTest, PendingRequests) { 240 // First request finishes asynchronously. 241 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 242 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); 243 244 // Make all subsequent host resolutions complete synchronously. 245 host_resolver_->set_synchronous_mode(true); 246 247 // Rest of them finish synchronously, until we reach the per-group limit. 248 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 249 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 250 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 251 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 252 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 253 254 // The rest are pending since we've used all active sockets. 255 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 256 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 257 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 258 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 259 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 260 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 261 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 262 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 263 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 264 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 265 266 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); 267 268 EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count()); 269 270 // One initial asynchronous request and then 10 pending requests. 271 EXPECT_EQ(11U, completion_count()); 272 273 // First part of requests, all with the same priority, finishes in FIFO order. 274 EXPECT_EQ(1, GetOrderOfRequest(1)); 275 EXPECT_EQ(2, GetOrderOfRequest(2)); 276 EXPECT_EQ(3, GetOrderOfRequest(3)); 277 EXPECT_EQ(4, GetOrderOfRequest(4)); 278 EXPECT_EQ(5, GetOrderOfRequest(5)); 279 EXPECT_EQ(6, GetOrderOfRequest(6)); 280 281 // Make sure that rest of the requests complete in the order of priority. 282 EXPECT_EQ(7, GetOrderOfRequest(7)); 283 EXPECT_EQ(14, GetOrderOfRequest(8)); 284 EXPECT_EQ(15, GetOrderOfRequest(9)); 285 EXPECT_EQ(10, GetOrderOfRequest(10)); 286 EXPECT_EQ(13, GetOrderOfRequest(11)); 287 EXPECT_EQ(8, GetOrderOfRequest(12)); 288 EXPECT_EQ(16, GetOrderOfRequest(13)); 289 EXPECT_EQ(11, GetOrderOfRequest(14)); 290 EXPECT_EQ(12, GetOrderOfRequest(15)); 291 EXPECT_EQ(9, GetOrderOfRequest(16)); 292 293 // Make sure we test order of all requests made. 294 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); 295} 296 297TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) { 298 // First request finishes asynchronously. 299 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 300 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); 301 302 // Make all subsequent host resolutions complete synchronously. 303 host_resolver_->set_synchronous_mode(true); 304 305 // Rest of them finish synchronously, until we reach the per-group limit. 306 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 307 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 308 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 309 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 310 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 311 312 // The rest are pending since we've used all active sockets. 313 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 314 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 315 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 316 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 317 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 318 319 ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE); 320 321 // The pending requests should finish successfully. 322 EXPECT_EQ(OK, (*requests())[6]->WaitForResult()); 323 EXPECT_EQ(OK, (*requests())[7]->WaitForResult()); 324 EXPECT_EQ(OK, (*requests())[8]->WaitForResult()); 325 EXPECT_EQ(OK, (*requests())[9]->WaitForResult()); 326 EXPECT_EQ(OK, (*requests())[10]->WaitForResult()); 327 328 EXPECT_EQ(static_cast<int>(requests()->size()), 329 client_socket_factory_.allocation_count()); 330 331 // First asynchronous request, and then last 5 pending requests. 332 EXPECT_EQ(6U, completion_count()); 333} 334 335// This test will start up a RequestSocket() and then immediately Cancel() it. 336// The pending host resolution will eventually complete, and destroy the 337// ClientSocketPool which will crash if the group was not cleared properly. 338TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) { 339 TestCompletionCallback callback; 340 ClientSocketHandle handle; 341 EXPECT_EQ(ERR_IO_PENDING, 342 handle.Init("a", params_, kDefaultPriority, callback.callback(), 343 &pool_, BoundNetLog())); 344 handle.Reset(); 345} 346 347TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) { 348 ClientSocketHandle handle; 349 TestCompletionCallback callback; 350 ClientSocketHandle handle2; 351 TestCompletionCallback callback2; 352 353 EXPECT_EQ(ERR_IO_PENDING, 354 handle.Init("a", params_, kDefaultPriority, callback.callback(), 355 &pool_, BoundNetLog())); 356 EXPECT_EQ(ERR_IO_PENDING, 357 handle2.Init("a", params_, kDefaultPriority, callback2.callback(), 358 &pool_, BoundNetLog())); 359 360 handle.Reset(); 361 362 EXPECT_EQ(OK, callback2.WaitForResult()); 363 handle2.Reset(); 364} 365 366TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) { 367 client_socket_factory_.set_default_client_socket_type( 368 MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); 369 ClientSocketHandle handle; 370 TestCompletionCallback callback; 371 EXPECT_EQ(ERR_IO_PENDING, 372 handle.Init("a", params_, kDefaultPriority, callback.callback(), 373 &pool_, BoundNetLog())); 374 375 handle.Reset(); 376 377 TestCompletionCallback callback2; 378 EXPECT_EQ(ERR_IO_PENDING, 379 handle.Init("a", params_, kDefaultPriority, callback2.callback(), 380 &pool_, BoundNetLog())); 381 382 host_resolver_->set_synchronous_mode(true); 383 // At this point, handle has two ConnectingSockets out for it. Due to the 384 // setting the mock resolver into synchronous mode, the host resolution for 385 // both will return in the same loop of the MessageLoop. The client socket 386 // is a pending socket, so the Connect() will asynchronously complete on the 387 // next loop of the MessageLoop. That means that the first 388 // ConnectingSocket will enter OnIOComplete, and then the second one will. 389 // If the first one is not cancelled, it will advance the load state, and 390 // then the second one will crash. 391 392 EXPECT_EQ(OK, callback2.WaitForResult()); 393 EXPECT_FALSE(callback.have_result()); 394 395 handle.Reset(); 396} 397 398TEST_F(TransportClientSocketPoolTest, CancelRequest) { 399 // First request finishes asynchronously. 400 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 401 EXPECT_EQ(OK, (*requests())[0]->WaitForResult()); 402 403 // Make all subsequent host resolutions complete synchronously. 404 host_resolver_->set_synchronous_mode(true); 405 406 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 407 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 408 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 409 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 410 EXPECT_EQ(OK, StartRequest("a", kDefaultPriority)); 411 412 // Reached per-group limit, queue up requests. 413 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 414 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 415 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 416 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 417 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM)); 418 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 419 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST)); 420 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 421 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW)); 422 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST)); 423 424 // Cancel a request. 425 size_t index_to_cancel = kMaxSocketsPerGroup + 2; 426 EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized()); 427 (*requests())[index_to_cancel]->handle()->Reset(); 428 429 ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE); 430 431 EXPECT_EQ(kMaxSocketsPerGroup, 432 client_socket_factory_.allocation_count()); 433 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count()); 434 435 EXPECT_EQ(1, GetOrderOfRequest(1)); 436 EXPECT_EQ(2, GetOrderOfRequest(2)); 437 EXPECT_EQ(3, GetOrderOfRequest(3)); 438 EXPECT_EQ(4, GetOrderOfRequest(4)); 439 EXPECT_EQ(5, GetOrderOfRequest(5)); 440 EXPECT_EQ(6, GetOrderOfRequest(6)); 441 EXPECT_EQ(14, GetOrderOfRequest(7)); 442 EXPECT_EQ(7, GetOrderOfRequest(8)); 443 EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound, 444 GetOrderOfRequest(9)); // Canceled request. 445 EXPECT_EQ(9, GetOrderOfRequest(10)); 446 EXPECT_EQ(10, GetOrderOfRequest(11)); 447 EXPECT_EQ(11, GetOrderOfRequest(12)); 448 EXPECT_EQ(8, GetOrderOfRequest(13)); 449 EXPECT_EQ(12, GetOrderOfRequest(14)); 450 EXPECT_EQ(13, GetOrderOfRequest(15)); 451 EXPECT_EQ(15, GetOrderOfRequest(16)); 452 453 // Make sure we test order of all requests made. 454 EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17)); 455} 456 457class RequestSocketCallback : public TestCompletionCallbackBase { 458 public: 459 RequestSocketCallback(ClientSocketHandle* handle, 460 TransportClientSocketPool* pool) 461 : handle_(handle), 462 pool_(pool), 463 within_callback_(false), 464 callback_(base::Bind(&RequestSocketCallback::OnComplete, 465 base::Unretained(this))) { 466 } 467 468 virtual ~RequestSocketCallback() {} 469 470 const CompletionCallback& callback() const { return callback_; } 471 472 private: 473 void OnComplete(int result) { 474 SetResult(result); 475 ASSERT_EQ(OK, result); 476 477 if (!within_callback_) { 478 // Don't allow reuse of the socket. Disconnect it and then release it and 479 // run through the MessageLoop once to get it completely released. 480 handle_->socket()->Disconnect(); 481 handle_->Reset(); 482 { 483 base::MessageLoop::ScopedNestableTaskAllower allow( 484 base::MessageLoop::current()); 485 base::MessageLoop::current()->RunUntilIdle(); 486 } 487 within_callback_ = true; 488 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( 489 HostPortPair("www.google.com", 80), false, false, 490 OnHostResolutionCallback(), 491 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); 492 int rv = handle_->Init("a", dest, LOWEST, callback(), pool_, 493 BoundNetLog()); 494 EXPECT_EQ(OK, rv); 495 } 496 } 497 498 ClientSocketHandle* const handle_; 499 TransportClientSocketPool* const pool_; 500 bool within_callback_; 501 CompletionCallback callback_; 502 503 DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback); 504}; 505 506TEST_F(TransportClientSocketPoolTest, RequestTwice) { 507 ClientSocketHandle handle; 508 RequestSocketCallback callback(&handle, &pool_); 509 scoped_refptr<TransportSocketParams> dest(new TransportSocketParams( 510 HostPortPair("www.google.com", 80), false, false, 511 OnHostResolutionCallback(), 512 TransportSocketParams::COMBINE_CONNECT_AND_WRITE_DEFAULT)); 513 int rv = handle.Init("a", dest, LOWEST, callback.callback(), &pool_, 514 BoundNetLog()); 515 ASSERT_EQ(ERR_IO_PENDING, rv); 516 517 // The callback is going to request "www.google.com". We want it to complete 518 // synchronously this time. 519 host_resolver_->set_synchronous_mode(true); 520 521 EXPECT_EQ(OK, callback.WaitForResult()); 522 523 handle.Reset(); 524} 525 526// Make sure that pending requests get serviced after active requests get 527// cancelled. 528TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) { 529 client_socket_factory_.set_default_client_socket_type( 530 MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET); 531 532 // Queue up all the requests 533 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 534 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 535 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 536 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 537 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 538 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 539 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 540 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 541 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 542 543 // Now, kMaxSocketsPerGroup requests should be active. Let's cancel them. 544 ASSERT_LE(kMaxSocketsPerGroup, static_cast<int>(requests()->size())); 545 for (int i = 0; i < kMaxSocketsPerGroup; i++) 546 (*requests())[i]->handle()->Reset(); 547 548 // Let's wait for the rest to complete now. 549 for (size_t i = kMaxSocketsPerGroup; i < requests()->size(); ++i) { 550 EXPECT_EQ(OK, (*requests())[i]->WaitForResult()); 551 (*requests())[i]->handle()->Reset(); 552 } 553 554 EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count()); 555} 556 557// Make sure that pending requests get serviced after active requests fail. 558TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) { 559 client_socket_factory_.set_default_client_socket_type( 560 MockTransportClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET); 561 562 const int kNumRequests = 2 * kMaxSocketsPerGroup + 1; 563 ASSERT_LE(kNumRequests, kMaxSockets); // Otherwise the test will hang. 564 565 // Queue up all the requests 566 for (int i = 0; i < kNumRequests; i++) 567 EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority)); 568 569 for (int i = 0; i < kNumRequests; i++) 570 EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult()); 571} 572 573TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) { 574 TestCompletionCallback callback; 575 ClientSocketHandle handle; 576 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, 577 BoundNetLog()); 578 EXPECT_EQ(ERR_IO_PENDING, rv); 579 EXPECT_FALSE(handle.is_initialized()); 580 EXPECT_FALSE(handle.socket()); 581 582 EXPECT_EQ(OK, callback.WaitForResult()); 583 EXPECT_TRUE(handle.is_initialized()); 584 EXPECT_TRUE(handle.socket()); 585 TestLoadTimingInfoConnectedNotReused(handle); 586 587 handle.Reset(); 588 // Need to run all pending to release the socket back to the pool. 589 base::MessageLoop::current()->RunUntilIdle(); 590 591 // Now we should have 1 idle socket. 592 EXPECT_EQ(1, pool_.IdleSocketCount()); 593 594 rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, 595 BoundNetLog()); 596 EXPECT_EQ(OK, rv); 597 EXPECT_EQ(0, pool_.IdleSocketCount()); 598 TestLoadTimingInfoConnectedReused(handle); 599} 600 601TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) { 602 TestCompletionCallback callback; 603 ClientSocketHandle handle; 604 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_, 605 BoundNetLog()); 606 EXPECT_EQ(ERR_IO_PENDING, rv); 607 EXPECT_FALSE(handle.is_initialized()); 608 EXPECT_FALSE(handle.socket()); 609 610 EXPECT_EQ(OK, callback.WaitForResult()); 611 EXPECT_TRUE(handle.is_initialized()); 612 EXPECT_TRUE(handle.socket()); 613 614 handle.Reset(); 615 616 // Need to run all pending to release the socket back to the pool. 617 base::MessageLoop::current()->RunUntilIdle(); 618 619 // Now we should have 1 idle socket. 620 EXPECT_EQ(1, pool_.IdleSocketCount()); 621 622 // After an IP address change, we should have 0 idle sockets. 623 NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 624 base::MessageLoop::current()->RunUntilIdle(); // Notification happens async. 625 626 EXPECT_EQ(0, pool_.IdleSocketCount()); 627} 628 629TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) { 630 // Case 1 tests the first socket stalling, and the backup connecting. 631 MockTransportClientSocketFactory::ClientSocketType case1_types[] = { 632 // The first socket will not connect. 633 MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, 634 // The second socket will connect more quickly. 635 MockTransportClientSocketFactory::MOCK_CLIENT_SOCKET 636 }; 637 638 // Case 2 tests the first socket being slow, so that we start the 639 // second connect, but the second connect stalls, and we still 640 // complete the first. 641 MockTransportClientSocketFactory::ClientSocketType case2_types[] = { 642 // The first socket will connect, although delayed. 643 MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, 644 // The second socket will not connect. 645 MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET 646 }; 647 648 MockTransportClientSocketFactory::ClientSocketType* cases[2] = { 649 case1_types, 650 case2_types 651 }; 652 653 for (size_t index = 0; index < arraysize(cases); ++index) { 654 client_socket_factory_.set_client_socket_types(cases[index], 2); 655 656 EXPECT_EQ(0, pool_.IdleSocketCount()); 657 658 TestCompletionCallback callback; 659 ClientSocketHandle handle; 660 int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_, 661 BoundNetLog()); 662 EXPECT_EQ(ERR_IO_PENDING, rv); 663 EXPECT_FALSE(handle.is_initialized()); 664 EXPECT_FALSE(handle.socket()); 665 666 // Create the first socket, set the timer. 667 base::MessageLoop::current()->RunUntilIdle(); 668 669 // Wait for the backup socket timer to fire. 670 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 671 ClientSocketPool::kMaxConnectRetryIntervalMs + 50)); 672 673 // Let the appropriate socket connect. 674 base::MessageLoop::current()->RunUntilIdle(); 675 676 EXPECT_EQ(OK, callback.WaitForResult()); 677 EXPECT_TRUE(handle.is_initialized()); 678 EXPECT_TRUE(handle.socket()); 679 680 // One socket is stalled, the other is active. 681 EXPECT_EQ(0, pool_.IdleSocketCount()); 682 handle.Reset(); 683 684 // Close all pending connect jobs and existing sockets. 685 pool_.FlushWithError(ERR_NETWORK_CHANGED); 686 } 687} 688 689// Test the case where a socket took long enough to start the creation 690// of the backup socket, but then we cancelled the request after that. 691TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) { 692 client_socket_factory_.set_default_client_socket_type( 693 MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET); 694 695 enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT }; 696 697 for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) { 698 EXPECT_EQ(0, pool_.IdleSocketCount()); 699 700 TestCompletionCallback callback; 701 ClientSocketHandle handle; 702 int rv = handle.Init("c", params_, LOW, callback.callback(), &pool_, 703 BoundNetLog()); 704 EXPECT_EQ(ERR_IO_PENDING, rv); 705 EXPECT_FALSE(handle.is_initialized()); 706 EXPECT_FALSE(handle.socket()); 707 708 // Create the first socket, set the timer. 709 base::MessageLoop::current()->RunUntilIdle(); 710 711 if (index == CANCEL_AFTER_WAIT) { 712 // Wait for the backup socket timer to fire. 713 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 714 ClientSocketPool::kMaxConnectRetryIntervalMs)); 715 } 716 717 // Let the appropriate socket connect. 718 base::MessageLoop::current()->RunUntilIdle(); 719 720 handle.Reset(); 721 722 EXPECT_FALSE(callback.have_result()); 723 EXPECT_FALSE(handle.is_initialized()); 724 EXPECT_FALSE(handle.socket()); 725 726 // One socket is stalled, the other is active. 727 EXPECT_EQ(0, pool_.IdleSocketCount()); 728 } 729} 730 731// Test the case where a socket took long enough to start the creation 732// of the backup socket and never completes, and then the backup 733// connection fails. 734TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) { 735 MockTransportClientSocketFactory::ClientSocketType case_types[] = { 736 // The first socket will not connect. 737 MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, 738 // The second socket will fail immediately. 739 MockTransportClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET 740 }; 741 742 client_socket_factory_.set_client_socket_types(case_types, 2); 743 744 EXPECT_EQ(0, pool_.IdleSocketCount()); 745 746 TestCompletionCallback callback; 747 ClientSocketHandle handle; 748 int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_, 749 BoundNetLog()); 750 EXPECT_EQ(ERR_IO_PENDING, rv); 751 EXPECT_FALSE(handle.is_initialized()); 752 EXPECT_FALSE(handle.socket()); 753 754 // Create the first socket, set the timer. 755 base::MessageLoop::current()->RunUntilIdle(); 756 757 // Wait for the backup socket timer to fire. 758 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 759 ClientSocketPool::kMaxConnectRetryIntervalMs)); 760 761 // Let the second connect be synchronous. Otherwise, the emulated 762 // host resolution takes an extra trip through the message loop. 763 host_resolver_->set_synchronous_mode(true); 764 765 // Let the appropriate socket connect. 766 base::MessageLoop::current()->RunUntilIdle(); 767 768 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 769 EXPECT_FALSE(handle.is_initialized()); 770 EXPECT_FALSE(handle.socket()); 771 EXPECT_EQ(0, pool_.IdleSocketCount()); 772 handle.Reset(); 773 774 // Reset for the next case. 775 host_resolver_->set_synchronous_mode(false); 776} 777 778// Test the case where a socket took long enough to start the creation 779// of the backup socket and eventually completes, but the backup socket 780// fails. 781TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) { 782 MockTransportClientSocketFactory::ClientSocketType case_types[] = { 783 // The first socket will connect, although delayed. 784 MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, 785 // The second socket will not connect. 786 MockTransportClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET 787 }; 788 789 client_socket_factory_.set_client_socket_types(case_types, 2); 790 client_socket_factory_.set_delay(base::TimeDelta::FromSeconds(5)); 791 792 EXPECT_EQ(0, pool_.IdleSocketCount()); 793 794 TestCompletionCallback callback; 795 ClientSocketHandle handle; 796 int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_, 797 BoundNetLog()); 798 EXPECT_EQ(ERR_IO_PENDING, rv); 799 EXPECT_FALSE(handle.is_initialized()); 800 EXPECT_FALSE(handle.socket()); 801 802 // Create the first socket, set the timer. 803 base::MessageLoop::current()->RunUntilIdle(); 804 805 // Wait for the backup socket timer to fire. 806 base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds( 807 ClientSocketPool::kMaxConnectRetryIntervalMs)); 808 809 // Let the second connect be synchronous. Otherwise, the emulated 810 // host resolution takes an extra trip through the message loop. 811 host_resolver_->set_synchronous_mode(true); 812 813 // Let the appropriate socket connect. 814 base::MessageLoop::current()->RunUntilIdle(); 815 816 EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult()); 817 EXPECT_FALSE(handle.is_initialized()); 818 EXPECT_FALSE(handle.socket()); 819 handle.Reset(); 820 821 // Reset for the next case. 822 host_resolver_->set_synchronous_mode(false); 823} 824 825// Test the case of the IPv6 address stalling, and falling back to the IPv4 826// socket which finishes first. 827TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) { 828 // Create a pool without backup jobs. 829 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 830 TransportClientSocketPool pool(kMaxSockets, 831 kMaxSocketsPerGroup, 832 histograms_.get(), 833 host_resolver_.get(), 834 &client_socket_factory_, 835 NULL); 836 837 MockTransportClientSocketFactory::ClientSocketType case_types[] = { 838 // This is the IPv6 socket. 839 MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, 840 // This is the IPv4 socket. 841 MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET 842 }; 843 844 client_socket_factory_.set_client_socket_types(case_types, 2); 845 846 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. 847 host_resolver_->rules() 848 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); 849 850 TestCompletionCallback callback; 851 ClientSocketHandle handle; 852 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, 853 BoundNetLog()); 854 EXPECT_EQ(ERR_IO_PENDING, rv); 855 EXPECT_FALSE(handle.is_initialized()); 856 EXPECT_FALSE(handle.socket()); 857 858 EXPECT_EQ(OK, callback.WaitForResult()); 859 EXPECT_TRUE(handle.is_initialized()); 860 EXPECT_TRUE(handle.socket()); 861 IPEndPoint endpoint; 862 handle.socket()->GetLocalAddress(&endpoint); 863 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); 864 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 865} 866 867// Test the case of the IPv6 address being slow, thus falling back to trying to 868// connect to the IPv4 address, but having the connect to the IPv6 address 869// finish first. 870TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) { 871 // Create a pool without backup jobs. 872 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 873 TransportClientSocketPool pool(kMaxSockets, 874 kMaxSocketsPerGroup, 875 histograms_.get(), 876 host_resolver_.get(), 877 &client_socket_factory_, 878 NULL); 879 880 MockTransportClientSocketFactory::ClientSocketType case_types[] = { 881 // This is the IPv6 socket. 882 MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET, 883 // This is the IPv4 socket. 884 MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET 885 }; 886 887 client_socket_factory_.set_client_socket_types(case_types, 2); 888 client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds( 889 TransportConnectJobHelper::kIPv6FallbackTimerInMs + 50)); 890 891 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. 892 host_resolver_->rules() 893 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); 894 895 TestCompletionCallback callback; 896 ClientSocketHandle handle; 897 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, 898 BoundNetLog()); 899 EXPECT_EQ(ERR_IO_PENDING, rv); 900 EXPECT_FALSE(handle.is_initialized()); 901 EXPECT_FALSE(handle.socket()); 902 903 EXPECT_EQ(OK, callback.WaitForResult()); 904 EXPECT_TRUE(handle.is_initialized()); 905 EXPECT_TRUE(handle.socket()); 906 IPEndPoint endpoint; 907 handle.socket()->GetLocalAddress(&endpoint); 908 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); 909 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 910} 911 912TEST_F(TransportClientSocketPoolTest, IPv6NoIPv4AddressesToFallbackTo) { 913 // Create a pool without backup jobs. 914 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 915 TransportClientSocketPool pool(kMaxSockets, 916 kMaxSocketsPerGroup, 917 histograms_.get(), 918 host_resolver_.get(), 919 &client_socket_factory_, 920 NULL); 921 922 client_socket_factory_.set_default_client_socket_type( 923 MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); 924 925 // Resolve an AddressList with only IPv6 addresses. 926 host_resolver_->rules() 927 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string()); 928 929 TestCompletionCallback callback; 930 ClientSocketHandle handle; 931 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, 932 BoundNetLog()); 933 EXPECT_EQ(ERR_IO_PENDING, rv); 934 EXPECT_FALSE(handle.is_initialized()); 935 EXPECT_FALSE(handle.socket()); 936 937 EXPECT_EQ(OK, callback.WaitForResult()); 938 EXPECT_TRUE(handle.is_initialized()); 939 EXPECT_TRUE(handle.socket()); 940 IPEndPoint endpoint; 941 handle.socket()->GetLocalAddress(&endpoint); 942 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); 943 EXPECT_EQ(1, client_socket_factory_.allocation_count()); 944} 945 946TEST_F(TransportClientSocketPoolTest, IPv4HasNoFallback) { 947 // Create a pool without backup jobs. 948 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 949 TransportClientSocketPool pool(kMaxSockets, 950 kMaxSocketsPerGroup, 951 histograms_.get(), 952 host_resolver_.get(), 953 &client_socket_factory_, 954 NULL); 955 956 client_socket_factory_.set_default_client_socket_type( 957 MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); 958 959 // Resolve an AddressList with only IPv4 addresses. 960 host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string()); 961 962 TestCompletionCallback callback; 963 ClientSocketHandle handle; 964 int rv = handle.Init("a", params_, LOW, callback.callback(), &pool, 965 BoundNetLog()); 966 EXPECT_EQ(ERR_IO_PENDING, rv); 967 EXPECT_FALSE(handle.is_initialized()); 968 EXPECT_FALSE(handle.socket()); 969 970 EXPECT_EQ(OK, callback.WaitForResult()); 971 EXPECT_TRUE(handle.is_initialized()); 972 EXPECT_TRUE(handle.socket()); 973 IPEndPoint endpoint; 974 handle.socket()->GetLocalAddress(&endpoint); 975 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); 976 EXPECT_EQ(1, client_socket_factory_.allocation_count()); 977} 978 979// Test that if TCP FastOpen is enabled, it is set on the socket 980// when we have only an IPv4 address. 981TEST_F(TransportClientSocketPoolTest, TCPFastOpenOnIPv4WithNoFallback) { 982 // Create a pool without backup jobs. 983 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 984 TransportClientSocketPool pool(kMaxSockets, 985 kMaxSocketsPerGroup, 986 histograms_.get(), 987 host_resolver_.get(), 988 &client_socket_factory_, 989 NULL); 990 client_socket_factory_.set_default_client_socket_type( 991 MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); 992 // Resolve an AddressList with only IPv4 addresses. 993 host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string()); 994 995 TestCompletionCallback callback; 996 ClientSocketHandle handle; 997 // Enable TCP FastOpen in TransportSocketParams. 998 scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen(); 999 handle.Init("a", params, LOW, callback.callback(), &pool, BoundNetLog()); 1000 EXPECT_EQ(OK, callback.WaitForResult()); 1001 EXPECT_TRUE(handle.socket()->UsingTCPFastOpen()); 1002} 1003 1004// Test that if TCP FastOpen is enabled, it is set on the socket 1005// when we have only IPv6 addresses. 1006TEST_F(TransportClientSocketPoolTest, TCPFastOpenOnIPv6WithNoFallback) { 1007 // Create a pool without backup jobs. 1008 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 1009 TransportClientSocketPool pool(kMaxSockets, 1010 kMaxSocketsPerGroup, 1011 histograms_.get(), 1012 host_resolver_.get(), 1013 &client_socket_factory_, 1014 NULL); 1015 client_socket_factory_.set_default_client_socket_type( 1016 MockTransportClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); 1017 // Resolve an AddressList with only IPv6 addresses. 1018 host_resolver_->rules() 1019 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string()); 1020 1021 TestCompletionCallback callback; 1022 ClientSocketHandle handle; 1023 // Enable TCP FastOpen in TransportSocketParams. 1024 scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen(); 1025 handle.Init("a", params, LOW, callback.callback(), &pool, BoundNetLog()); 1026 EXPECT_EQ(OK, callback.WaitForResult()); 1027 EXPECT_TRUE(handle.socket()->UsingTCPFastOpen()); 1028} 1029 1030// Test that if TCP FastOpen is enabled, it does not do anything when there 1031// is a IPv6 address with fallback to an IPv4 address. This test tests the case 1032// when the IPv6 connect fails and the IPv4 one succeeds. 1033TEST_F(TransportClientSocketPoolTest, 1034 NoTCPFastOpenOnIPv6FailureWithIPv4Fallback) { 1035 // Create a pool without backup jobs. 1036 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 1037 TransportClientSocketPool pool(kMaxSockets, 1038 kMaxSocketsPerGroup, 1039 histograms_.get(), 1040 host_resolver_.get(), 1041 &client_socket_factory_, 1042 NULL); 1043 1044 MockTransportClientSocketFactory::ClientSocketType case_types[] = { 1045 // This is the IPv6 socket. 1046 MockTransportClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET, 1047 // This is the IPv4 socket. 1048 MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET 1049 }; 1050 client_socket_factory_.set_client_socket_types(case_types, 2); 1051 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. 1052 host_resolver_->rules() 1053 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); 1054 1055 TestCompletionCallback callback; 1056 ClientSocketHandle handle; 1057 // Enable TCP FastOpen in TransportSocketParams. 1058 scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen(); 1059 handle.Init("a", params, LOW, callback.callback(), &pool, BoundNetLog()); 1060 EXPECT_EQ(OK, callback.WaitForResult()); 1061 // Verify that the socket used is connected to the fallback IPv4 address. 1062 IPEndPoint endpoint; 1063 handle.socket()->GetLocalAddress(&endpoint); 1064 EXPECT_EQ(kIPv4AddressSize, endpoint.address().size()); 1065 EXPECT_EQ(2, client_socket_factory_.allocation_count()); 1066 // Verify that TCP FastOpen was not turned on for the socket. 1067 EXPECT_FALSE(handle.socket()->UsingTCPFastOpen()); 1068} 1069 1070// Test that if TCP FastOpen is enabled, it does not do anything when there 1071// is a IPv6 address with fallback to an IPv4 address. This test tests the case 1072// when the IPv6 connect succeeds. 1073TEST_F(TransportClientSocketPoolTest, 1074 NoTCPFastOpenOnIPv6SuccessWithIPv4Fallback) { 1075 // Create a pool without backup jobs. 1076 ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false); 1077 TransportClientSocketPool pool(kMaxSockets, 1078 kMaxSocketsPerGroup, 1079 histograms_.get(), 1080 host_resolver_.get(), 1081 &client_socket_factory_, 1082 NULL); 1083 1084 MockTransportClientSocketFactory::ClientSocketType case_types[] = { 1085 // This is the IPv6 socket. 1086 MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET, 1087 // This is the IPv4 socket. 1088 MockTransportClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET 1089 }; 1090 client_socket_factory_.set_client_socket_types(case_types, 2); 1091 // Resolve an AddressList with a IPv6 address first and then a IPv4 address. 1092 host_resolver_->rules() 1093 ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); 1094 1095 TestCompletionCallback callback; 1096 ClientSocketHandle handle; 1097 // Enable TCP FastOpen in TransportSocketParams. 1098 scoped_refptr<TransportSocketParams> params = CreateParamsForTCPFastOpen(); 1099 handle.Init("a", params, LOW, callback.callback(), &pool, BoundNetLog()); 1100 EXPECT_EQ(OK, callback.WaitForResult()); 1101 // Verify that the socket used is connected to the IPv6 address. 1102 IPEndPoint endpoint; 1103 handle.socket()->GetLocalAddress(&endpoint); 1104 EXPECT_EQ(kIPv6AddressSize, endpoint.address().size()); 1105 EXPECT_EQ(1, client_socket_factory_.allocation_count()); 1106 // Verify that TCP FastOpen was not turned on for the socket. 1107 EXPECT_FALSE(handle.socket()->UsingTCPFastOpen()); 1108} 1109 1110} // namespace 1111 1112} // namespace net 1113