net/socket/websocket_transport_client_socket_pool_unittest.cc

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