net/socket/client_socket_pool_base_unittest.cc

   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/client_socket_pool_base.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/callback.h"
  12 #include "base/memory/ref_counted.h"
  13 #include "base/memory/scoped_vector.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/run_loop.h"
  17 #include "base/strings/string_number_conversions.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/threading/platform_thread.h"
  20 #include "base/values.h"
  21 #include "net/base/load_timing_info.h"
  22 #include "net/base/load_timing_info_test_util.h"
  23 #include "net/base/net_errors.h"
  24 #include "net/base/net_log.h"
  25 #include "net/base/net_log_unittest.h"
  26 #include "net/base/request_priority.h"
  27 #include "net/base/test_completion_callback.h"
  28 #include "net/http/http_response_headers.h"
  29 #include "net/socket/client_socket_factory.h"
  30 #include "net/socket/client_socket_handle.h"
  31 #include "net/socket/client_socket_pool_histograms.h"
  32 #include "net/socket/socket_test_util.h"
  33 #include "net/socket/ssl_client_socket.h"
  34 #include "net/socket/stream_socket.h"
  35 #include "net/udp/datagram_client_socket.h"
  36 #include "testing/gmock/include/gmock/gmock.h"
  37 #include "testing/gtest/include/gtest/gtest.h"
  38
  39 using ::testing::Invoke;
  40 using ::testing::Return;
  41
  42 namespace net {
  43
  44 namespace {
  45
  46 const int kDefaultMaxSockets = 4;
  47 const int kDefaultMaxSocketsPerGroup = 2;
  48
  49 // Make sure |handle| sets load times correctly when it has been assigned a
  50 // reused socket.
  51 void TestLoadTimingInfoConnectedReused(const ClientSocketHandle& handle) {
  52   LoadTimingInfo load_timing_info;
  53   // Only pass true in as |is_reused|, as in general, HttpStream types should
  54   // have stricter concepts of reuse than socket pools.
  55   EXPECT_TRUE(handle.GetLoadTimingInfo(true, &load_timing_info));
  56
  57   EXPECT_EQ(true, load_timing_info.socket_reused);
  58   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
  59
  60   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
  61   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  62 }
  63
  64 // Make sure |handle| sets load times correctly when it has been assigned a
  65 // fresh socket. Also runs TestLoadTimingInfoConnectedReused, since the owner
  66 // of a connection where |is_reused| is false may consider the connection
  67 // reused.
  68 void TestLoadTimingInfoConnectedNotReused(const ClientSocketHandle& handle) {
  69   EXPECT_FALSE(handle.is_reused());
  70
  71   LoadTimingInfo load_timing_info;
  72   EXPECT_TRUE(handle.GetLoadTimingInfo(false, &load_timing_info));
  73
  74   EXPECT_FALSE(load_timing_info.socket_reused);
  75   EXPECT_NE(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
  76
  77   ExpectConnectTimingHasTimes(load_timing_info.connect_timing,
  78                               CONNECT_TIMING_HAS_CONNECT_TIMES_ONLY);
  79   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  80
  81   TestLoadTimingInfoConnectedReused(handle);
  82 }
  83
  84 // Make sure |handle| sets load times correctly, in the case that it does not
  85 // currently have a socket.
  86 void TestLoadTimingInfoNotConnected(const ClientSocketHandle& handle) {
  87   // Should only be set to true once a socket is assigned, if at all.
  88   EXPECT_FALSE(handle.is_reused());
  89
  90   LoadTimingInfo load_timing_info;
  91   EXPECT_FALSE(handle.GetLoadTimingInfo(false, &load_timing_info));
  92
  93   EXPECT_FALSE(load_timing_info.socket_reused);
  94   EXPECT_EQ(NetLog::Source::kInvalidId, load_timing_info.socket_log_id);
  95
  96   ExpectConnectTimingHasNoTimes(load_timing_info.connect_timing);
  97   ExpectLoadTimingHasOnlyConnectionTimes(load_timing_info);
  98 }
  99
 100 class TestSocketParams : public base::RefCounted<TestSocketParams> {
 101  public:
 102   explicit TestSocketParams(bool ignore_limits)
 103       : ignore_limits_(ignore_limits) {}
 104
 105   bool ignore_limits() { return ignore_limits_; }
 106
 107  private:
 108   friend class base::RefCounted<TestSocketParams>;
 109   ~TestSocketParams() {}
 110
 111   const bool ignore_limits_;
 112 };
 113 typedef ClientSocketPoolBase<TestSocketParams> TestClientSocketPoolBase;
 114
 115 class MockClientSocket : public StreamSocket {
 116  public:
 117   explicit MockClientSocket(net::NetLog* net_log)
 118       : connected_(false),
 119         has_unread_data_(false),
 120         net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
 121         was_used_to_convey_data_(false) {
 122   }
 123
 124   // Sets whether the socket has unread data. If true, the next call to Read()
 125   // will return 1 byte and IsConnectedAndIdle() will return false.
 126   void set_has_unread_data(bool has_unread_data) {
 127     has_unread_data_ = has_unread_data;
 128   }
 129
 130   // Socket implementation.
 131   virtual int Read(
 132       IOBuffer* /* buf */, int len,
 133       const CompletionCallback& /* callback */) OVERRIDE {
 134     if (has_unread_data_ && len > 0) {
 135       has_unread_data_ = false;
 136       was_used_to_convey_data_ = true;
 137       return 1;
 138     }
 139     return ERR_UNEXPECTED;
 140   }
 141
 142   virtual int Write(
 143       IOBuffer* /* buf */, int len,
 144       const CompletionCallback& /* callback */) OVERRIDE {
 145     was_used_to_convey_data_ = true;
 146     return len;
 147   }
 148   virtual int SetReceiveBufferSize(int32 size) OVERRIDE { return OK; }
 149   virtual int SetSendBufferSize(int32 size) OVERRIDE { return OK; }
 150
 151   // StreamSocket implementation.
 152   virtual int Connect(const CompletionCallback& callback) OVERRIDE {
 153     connected_ = true;
 154     return OK;
 155   }
 156
 157   virtual void Disconnect() OVERRIDE { connected_ = false; }
 158   virtual bool IsConnected() const OVERRIDE { return connected_; }
 159   virtual bool IsConnectedAndIdle() const OVERRIDE {
 160     return connected_ && !has_unread_data_;
 161   }
 162
 163   virtual int GetPeerAddress(IPEndPoint* /* address */) const OVERRIDE {
 164     return ERR_UNEXPECTED;
 165   }
 166
 167   virtual int GetLocalAddress(IPEndPoint* /* address */) const OVERRIDE {
 168     return ERR_UNEXPECTED;
 169   }
 170
 171   virtual const BoundNetLog& NetLog() const OVERRIDE {
 172     return net_log_;
 173   }
 174
 175   virtual void SetSubresourceSpeculation() OVERRIDE {}
 176   virtual void SetOmniboxSpeculation() OVERRIDE {}
 177   virtual bool WasEverUsed() const OVERRIDE {
 178     return was_used_to_convey_data_;
 179   }
 180   virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
 181   virtual bool WasNpnNegotiated() const OVERRIDE {
 182     return false;
 183   }
 184   virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
 185     return kProtoUnknown;
 186   }
 187   virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
 188     return false;
 189   }
 190
 191  private:
 192   bool connected_;
 193   bool has_unread_data_;
 194   BoundNetLog net_log_;
 195   bool was_used_to_convey_data_;
 196
 197   DISALLOW_COPY_AND_ASSIGN(MockClientSocket);
 198 };
 199
 200 class TestConnectJob;
 201
 202 class MockClientSocketFactory : public ClientSocketFactory {
 203  public:
 204   MockClientSocketFactory() : allocation_count_(0) {}
 205
 206   virtual scoped_ptr<DatagramClientSocket> CreateDatagramClientSocket(
 207       DatagramSocket::BindType bind_type,
 208       const RandIntCallback& rand_int_cb,
 209       NetLog* net_log,
 210       const NetLog::Source& source) OVERRIDE {
 211     NOTREACHED();
 212     return scoped_ptr<DatagramClientSocket>();
 213   }
 214
 215   virtual scoped_ptr<StreamSocket> CreateTransportClientSocket(
 216       const AddressList& addresses,
 217       NetLog* /* net_log */,
 218       const NetLog::Source& /*source*/) OVERRIDE {
 219     allocation_count_++;
 220     return scoped_ptr<StreamSocket>();
 221   }
 222
 223   virtual scoped_ptr<SSLClientSocket> CreateSSLClientSocket(
 224       scoped_ptr<ClientSocketHandle> transport_socket,
 225       const HostPortPair& host_and_port,
 226       const SSLConfig& ssl_config,
 227       const SSLClientSocketContext& context) OVERRIDE {
 228     NOTIMPLEMENTED();
 229     return scoped_ptr<SSLClientSocket>();
 230   }
 231
 232   virtual void ClearSSLSessionCache() OVERRIDE {
 233     NOTIMPLEMENTED();
 234   }
 235
 236   void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); }
 237
 238   void SignalJobs();
 239
 240   void SignalJob(size_t job);
 241
 242   void SetJobLoadState(size_t job, LoadState load_state);
 243
 244   int allocation_count() const { return allocation_count_; }
 245
 246  private:
 247   int allocation_count_;
 248   std::vector<TestConnectJob*> waiting_jobs_;
 249 };
 250
 251 class TestConnectJob : public ConnectJob {
 252  public:
 253   enum JobType {
 254     kMockJob,
 255     kMockFailingJob,
 256     kMockPendingJob,
 257     kMockPendingFailingJob,
 258     kMockWaitingJob,
 259     kMockRecoverableJob,
 260     kMockPendingRecoverableJob,
 261     kMockAdditionalErrorStateJob,
 262     kMockPendingAdditionalErrorStateJob,
 263     kMockUnreadDataJob,
 264   };
 265
 266   // The kMockPendingJob uses a slight delay before allowing the connect
 267   // to complete.
 268   static const int kPendingConnectDelay = 2;
 269
 270   TestConnectJob(JobType job_type,
 271                  const std::string& group_name,
 272                  const TestClientSocketPoolBase::Request& request,
 273                  base::TimeDelta timeout_duration,
 274                  ConnectJob::Delegate* delegate,
 275                  MockClientSocketFactory* client_socket_factory,
 276                  NetLog* net_log)
 277       : ConnectJob(group_name, timeout_duration, request.priority(), delegate,
 278                    BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
 279         job_type_(job_type),
 280         client_socket_factory_(client_socket_factory),
 281         load_state_(LOAD_STATE_IDLE),
 282         store_additional_error_state_(false),
 283         weak_factory_(this) {
 284   }
 285
 286   void Signal() {
 287     DoConnect(waiting_success_, true /* async */, false /* recoverable */);
 288   }
 289
 290   void set_load_state(LoadState load_state) { load_state_ = load_state; }
 291
 292   // From ConnectJob:
 293
 294   virtual LoadState GetLoadState() const OVERRIDE { return load_state_; }
 295
 296   virtual void GetAdditionalErrorState(ClientSocketHandle* handle) OVERRIDE {
 297     if (store_additional_error_state_) {
 298       // Set all of the additional error state fields in some way.
 299       handle->set_is_ssl_error(true);
 300       HttpResponseInfo info;
 301       info.headers = new HttpResponseHeaders(std::string());
 302       handle->set_ssl_error_response_info(info);
 303     }
 304   }
 305
 306  private:
 307   // From ConnectJob:
 308
 309   virtual int ConnectInternal() OVERRIDE {
 310     AddressList ignored;
 311     client_socket_factory_->CreateTransportClientSocket(
 312         ignored, NULL, net::NetLog::Source());
 313     SetSocket(
 314         scoped_ptr<StreamSocket>(new MockClientSocket(net_log().net_log())));
 315     switch (job_type_) {
 316       case kMockJob:
 317         return DoConnect(true /* successful */, false /* sync */,
 318                          false /* recoverable */);
 319       case kMockFailingJob:
 320         return DoConnect(false /* error */, false /* sync */,
 321                          false /* recoverable */);
 322       case kMockPendingJob:
 323         set_load_state(LOAD_STATE_CONNECTING);
 324
 325         // Depending on execution timings, posting a delayed task can result
 326         // in the task getting executed the at the earliest possible
 327         // opportunity or only after returning once from the message loop and
 328         // then a second call into the message loop. In order to make behavior
 329         // more deterministic, we change the default delay to 2ms. This should
 330         // always require us to wait for the second call into the message loop.
 331         //
 332         // N.B. The correct fix for this and similar timing problems is to
 333         // abstract time for the purpose of unittests. Unfortunately, we have
 334         // a lot of third-party components that directly call the various
 335         // time functions, so this change would be rather invasive.
 336         base::MessageLoop::current()->PostDelayedTask(
 337             FROM_HERE,
 338             base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
 339                        weak_factory_.GetWeakPtr(),
 340                        true /* successful */,
 341                        true /* async */,
 342                        false /* recoverable */),
 343             base::TimeDelta::FromMilliseconds(kPendingConnectDelay));
 344         return ERR_IO_PENDING;
 345       case kMockPendingFailingJob:
 346         set_load_state(LOAD_STATE_CONNECTING);
 347         base::MessageLoop::current()->PostDelayedTask(
 348             FROM_HERE,
 349             base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
 350                        weak_factory_.GetWeakPtr(),
 351                        false /* error */,
 352                        true  /* async */,
 353                        false /* recoverable */),
 354             base::TimeDelta::FromMilliseconds(2));
 355         return ERR_IO_PENDING;
 356       case kMockWaitingJob:
 357         set_load_state(LOAD_STATE_CONNECTING);
 358         client_socket_factory_->WaitForSignal(this);
 359         waiting_success_ = true;
 360         return ERR_IO_PENDING;
 361       case kMockRecoverableJob:
 362         return DoConnect(false /* error */, false /* sync */,
 363                          true /* recoverable */);
 364       case kMockPendingRecoverableJob:
 365         set_load_state(LOAD_STATE_CONNECTING);
 366         base::MessageLoop::current()->PostDelayedTask(
 367             FROM_HERE,
 368             base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
 369                        weak_factory_.GetWeakPtr(),
 370                        false /* error */,
 371                        true  /* async */,
 372                        true  /* recoverable */),
 373             base::TimeDelta::FromMilliseconds(2));
 374         return ERR_IO_PENDING;
 375       case kMockAdditionalErrorStateJob:
 376         store_additional_error_state_ = true;
 377         return DoConnect(false /* error */, false /* sync */,
 378                          false /* recoverable */);
 379       case kMockPendingAdditionalErrorStateJob:
 380         set_load_state(LOAD_STATE_CONNECTING);
 381         store_additional_error_state_ = true;
 382         base::MessageLoop::current()->PostDelayedTask(
 383             FROM_HERE,
 384             base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
 385                        weak_factory_.GetWeakPtr(),
 386                        false /* error */,
 387                        true  /* async */,
 388                        false /* recoverable */),
 389             base::TimeDelta::FromMilliseconds(2));
 390         return ERR_IO_PENDING;
 391       case kMockUnreadDataJob: {
 392         int ret = DoConnect(true /* successful */, false /* sync */,
 393                             false /* recoverable */);
 394         static_cast<MockClientSocket*>(socket())->set_has_unread_data(true);
 395         return ret;
 396       }
 397       default:
 398         NOTREACHED();
 399         SetSocket(scoped_ptr<StreamSocket>());
 400         return ERR_FAILED;
 401     }
 402   }
 403
 404   int DoConnect(bool succeed, bool was_async, bool recoverable) {
 405     int result = OK;
 406     if (succeed) {
 407       socket()->Connect(CompletionCallback());
 408     } else if (recoverable) {
 409       result = ERR_PROXY_AUTH_REQUESTED;
 410     } else {
 411       result = ERR_CONNECTION_FAILED;
 412       SetSocket(scoped_ptr<StreamSocket>());
 413     }
 414
 415     if (was_async)
 416       NotifyDelegateOfCompletion(result);
 417     return result;
 418   }
 419
 420   bool waiting_success_;
 421   const JobType job_type_;
 422   MockClientSocketFactory* const client_socket_factory_;
 423   LoadState load_state_;
 424   bool store_additional_error_state_;
 425
 426   base::WeakPtrFactory<TestConnectJob> weak_factory_;
 427
 428   DISALLOW_COPY_AND_ASSIGN(TestConnectJob);
 429 };
 430
 431 class TestConnectJobFactory
 432     : public TestClientSocketPoolBase::ConnectJobFactory {
 433  public:
 434   TestConnectJobFactory(MockClientSocketFactory* client_socket_factory,
 435                         NetLog* net_log)
 436       : job_type_(TestConnectJob::kMockJob),
 437         job_types_(NULL),
 438         client_socket_factory_(client_socket_factory),
 439         net_log_(net_log) {
 440   }
 441
 442   virtual ~TestConnectJobFactory() {}
 443
 444   void set_job_type(TestConnectJob::JobType job_type) { job_type_ = job_type; }
 445
 446   void set_job_types(std::list<TestConnectJob::JobType>* job_types) {
 447     job_types_ = job_types;
 448     CHECK(!job_types_->empty());
 449   }
 450
 451   void set_timeout_duration(base::TimeDelta timeout_duration) {
 452     timeout_duration_ = timeout_duration;
 453   }
 454
 455   // ConnectJobFactory implementation.
 456
 457   virtual scoped_ptr<ConnectJob> NewConnectJob(
 458       const std::string& group_name,
 459       const TestClientSocketPoolBase::Request& request,
 460       ConnectJob::Delegate* delegate) const OVERRIDE {
 461     EXPECT_TRUE(!job_types_ || !job_types_->empty());
 462     TestConnectJob::JobType job_type = job_type_;
 463     if (job_types_ && !job_types_->empty()) {
 464       job_type = job_types_->front();
 465       job_types_->pop_front();
 466     }
 467     return scoped_ptr<ConnectJob>(new TestConnectJob(job_type,
 468                                                      group_name,
 469                                                      request,
 470                                                      timeout_duration_,
 471                                                      delegate,
 472                                                      client_socket_factory_,
 473                                                      net_log_));
 474   }
 475
 476   virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
 477     return timeout_duration_;
 478   }
 479
 480  private:
 481   TestConnectJob::JobType job_type_;
 482   std::list<TestConnectJob::JobType>* job_types_;
 483   base::TimeDelta timeout_duration_;
 484   MockClientSocketFactory* const client_socket_factory_;
 485   NetLog* net_log_;
 486
 487   DISALLOW_COPY_AND_ASSIGN(TestConnectJobFactory);
 488 };
 489
 490 class TestClientSocketPool : public ClientSocketPool {
 491  public:
 492   typedef TestSocketParams SocketParams;
 493
 494   TestClientSocketPool(
 495       int max_sockets,
 496       int max_sockets_per_group,
 497       ClientSocketPoolHistograms* histograms,
 498       base::TimeDelta unused_idle_socket_timeout,
 499       base::TimeDelta used_idle_socket_timeout,
 500       TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory)
 501       : base_(NULL, max_sockets, max_sockets_per_group, histograms,
 502               unused_idle_socket_timeout, used_idle_socket_timeout,
 503               connect_job_factory) {}
 504
 505   virtual ~TestClientSocketPool() {}
 506
 507   virtual int RequestSocket(
 508       const std::string& group_name,
 509       const void* params,
 510       net::RequestPriority priority,
 511       ClientSocketHandle* handle,
 512       const CompletionCallback& callback,
 513       const BoundNetLog& net_log) OVERRIDE {
 514     const scoped_refptr<TestSocketParams>* casted_socket_params =
 515         static_cast<const scoped_refptr<TestSocketParams>*>(params);
 516     return base_.RequestSocket(group_name, *casted_socket_params, priority,
 517                                handle, callback, net_log);
 518   }
 519
 520   virtual void RequestSockets(const std::string& group_name,
 521                               const void* params,
 522                               int num_sockets,
 523                               const BoundNetLog& net_log) OVERRIDE {
 524     const scoped_refptr<TestSocketParams>* casted_params =
 525         static_cast<const scoped_refptr<TestSocketParams>*>(params);
 526
 527     base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
 528   }
 529
 530   virtual void CancelRequest(
 531       const std::string& group_name,
 532       ClientSocketHandle* handle) OVERRIDE {
 533     base_.CancelRequest(group_name, handle);
 534   }
 535
 536   virtual void ReleaseSocket(
 537       const std::string& group_name,
 538       scoped_ptr<StreamSocket> socket,
 539       int id) OVERRIDE {
 540     base_.ReleaseSocket(group_name, socket.Pass(), id);
 541   }
 542
 543   virtual void FlushWithError(int error) OVERRIDE {
 544     base_.FlushWithError(error);
 545   }
 546
 547   virtual bool IsStalled() const OVERRIDE {
 548     return base_.IsStalled();
 549   }
 550
 551   virtual void CloseIdleSockets() OVERRIDE {
 552     base_.CloseIdleSockets();
 553   }
 554
 555   virtual int IdleSocketCount() const OVERRIDE {
 556     return base_.idle_socket_count();
 557   }
 558
 559   virtual int IdleSocketCountInGroup(
 560       const std::string& group_name) const OVERRIDE {
 561     return base_.IdleSocketCountInGroup(group_name);
 562   }
 563
 564   virtual LoadState GetLoadState(
 565       const std::string& group_name,
 566       const ClientSocketHandle* handle) const OVERRIDE {
 567     return base_.GetLoadState(group_name, handle);
 568   }
 569
 570   virtual void AddHigherLayeredPool(HigherLayeredPool* higher_pool) OVERRIDE {
 571     base_.AddHigherLayeredPool(higher_pool);
 572   }
 573
 574   virtual void RemoveHigherLayeredPool(
 575       HigherLayeredPool* higher_pool) OVERRIDE {
 576     base_.RemoveHigherLayeredPool(higher_pool);
 577   }
 578
 579   virtual base::DictionaryValue* GetInfoAsValue(
 580       const std::string& name,
 581       const std::string& type,
 582       bool include_nested_pools) const OVERRIDE {
 583     return base_.GetInfoAsValue(name, type);
 584   }
 585
 586   virtual base::TimeDelta ConnectionTimeout() const OVERRIDE {
 587     return base_.ConnectionTimeout();
 588   }
 589
 590   virtual ClientSocketPoolHistograms* histograms() const OVERRIDE {
 591     return base_.histograms();
 592   }
 593
 594   const TestClientSocketPoolBase* base() const { return &base_; }
 595
 596   int NumUnassignedConnectJobsInGroup(const std::string& group_name) const {
 597     return base_.NumUnassignedConnectJobsInGroup(group_name);
 598   }
 599
 600   int NumConnectJobsInGroup(const std::string& group_name) const {
 601     return base_.NumConnectJobsInGroup(group_name);
 602   }
 603
 604   int NumActiveSocketsInGroup(const std::string& group_name) const {
 605     return base_.NumActiveSocketsInGroup(group_name);
 606   }
 607
 608   bool HasGroup(const std::string& group_name) const {
 609     return base_.HasGroup(group_name);
 610   }
 611
 612   void CleanupTimedOutIdleSockets() { base_.CleanupIdleSockets(false); }
 613
 614   void EnableConnectBackupJobs() { base_.EnableConnectBackupJobs(); }
 615
 616   bool CloseOneIdleConnectionInHigherLayeredPool() {
 617     return base_.CloseOneIdleConnectionInHigherLayeredPool();
 618   }
 619
 620  private:
 621   TestClientSocketPoolBase base_;
 622
 623   DISALLOW_COPY_AND_ASSIGN(TestClientSocketPool);
 624 };
 625
 626 }  // namespace
 627
 628 namespace {
 629
 630 void MockClientSocketFactory::SignalJobs() {
 631   for (std::vector<TestConnectJob*>::iterator it = waiting_jobs_.begin();
 632        it != waiting_jobs_.end(); ++it) {
 633     (*it)->Signal();
 634   }
 635   waiting_jobs_.clear();
 636 }
 637
 638 void MockClientSocketFactory::SignalJob(size_t job) {
 639   ASSERT_LT(job, waiting_jobs_.size());
 640   waiting_jobs_[job]->Signal();
 641   waiting_jobs_.erase(waiting_jobs_.begin() + job);
 642 }
 643
 644 void MockClientSocketFactory::SetJobLoadState(size_t job,
 645                                               LoadState load_state) {
 646   ASSERT_LT(job, waiting_jobs_.size());
 647   waiting_jobs_[job]->set_load_state(load_state);
 648 }
 649
 650 class TestConnectJobDelegate : public ConnectJob::Delegate {
 651  public:
 652   TestConnectJobDelegate()
 653       : have_result_(false), waiting_for_result_(false), result_(OK) {}
 654   virtual ~TestConnectJobDelegate() {}
 655
 656   virtual void OnConnectJobComplete(int result, ConnectJob* job) OVERRIDE {
 657     result_ = result;
 658     scoped_ptr<ConnectJob> owned_job(job);
 659     scoped_ptr<StreamSocket> socket = owned_job->PassSocket();
 660     // socket.get() should be NULL iff result != OK
 661     EXPECT_EQ(socket == NULL, result != OK);
 662     have_result_ = true;
 663     if (waiting_for_result_)
 664       base::MessageLoop::current()->Quit();
 665   }
 666
 667   int WaitForResult() {
 668     DCHECK(!waiting_for_result_);
 669     while (!have_result_) {
 670       waiting_for_result_ = true;
 671       base::MessageLoop::current()->Run();
 672       waiting_for_result_ = false;
 673     }
 674     have_result_ = false;  // auto-reset for next callback
 675     return result_;
 676   }
 677
 678  private:
 679   bool have_result_;
 680   bool waiting_for_result_;
 681   int result_;
 682 };
 683
 684 class ClientSocketPoolBaseTest : public testing::Test {
 685  protected:
 686   ClientSocketPoolBaseTest()
 687       : params_(new TestSocketParams(false /* ignore_limits */)),
 688         histograms_("ClientSocketPoolTest") {
 689     connect_backup_jobs_enabled_ =
 690         internal::ClientSocketPoolBaseHelper::connect_backup_jobs_enabled();
 691     internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true);
 692     cleanup_timer_enabled_ =
 693         internal::ClientSocketPoolBaseHelper::cleanup_timer_enabled();
 694   }
 695
 696   virtual ~ClientSocketPoolBaseTest() {
 697     internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
 698         connect_backup_jobs_enabled_);
 699     internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(
 700         cleanup_timer_enabled_);
 701   }
 702
 703   void CreatePool(int max_sockets, int max_sockets_per_group) {
 704     CreatePoolWithIdleTimeouts(
 705         max_sockets,
 706         max_sockets_per_group,
 707         ClientSocketPool::unused_idle_socket_timeout(),
 708         ClientSocketPool::used_idle_socket_timeout());
 709   }
 710
 711   void CreatePoolWithIdleTimeouts(
 712       int max_sockets, int max_sockets_per_group,
 713       base::TimeDelta unused_idle_socket_timeout,
 714       base::TimeDelta used_idle_socket_timeout) {
 715     DCHECK(!pool_.get());
 716     connect_job_factory_ = new TestConnectJobFactory(&client_socket_factory_,
 717                                                      &net_log_);
 718     pool_.reset(new TestClientSocketPool(max_sockets,
 719                                          max_sockets_per_group,
 720                                          &histograms_,
 721                                          unused_idle_socket_timeout,
 722                                          used_idle_socket_timeout,
 723                                          connect_job_factory_));
 724   }
 725
 726   int StartRequestWithParams(
 727       const std::string& group_name,
 728       RequestPriority priority,
 729       const scoped_refptr<TestSocketParams>& params) {
 730     return test_base_.StartRequestUsingPool(
 731         pool_.get(), group_name, priority, params);
 732   }
 733
 734   int StartRequest(const std::string& group_name, RequestPriority priority) {
 735     return StartRequestWithParams(group_name, priority, params_);
 736   }
 737
 738   int GetOrderOfRequest(size_t index) const {
 739     return test_base_.GetOrderOfRequest(index);
 740   }
 741
 742   bool ReleaseOneConnection(ClientSocketPoolTest::KeepAlive keep_alive) {
 743     return test_base_.ReleaseOneConnection(keep_alive);
 744   }
 745
 746   void ReleaseAllConnections(ClientSocketPoolTest::KeepAlive keep_alive) {
 747     test_base_.ReleaseAllConnections(keep_alive);
 748   }
 749
 750   TestSocketRequest* request(int i) { return test_base_.request(i); }
 751   size_t requests_size() const { return test_base_.requests_size(); }
 752   ScopedVector<TestSocketRequest>* requests() { return test_base_.requests(); }
 753   size_t completion_count() const { return test_base_.completion_count(); }
 754
 755   CapturingNetLog net_log_;
 756   bool connect_backup_jobs_enabled_;
 757   bool cleanup_timer_enabled_;
 758   MockClientSocketFactory client_socket_factory_;
 759   TestConnectJobFactory* connect_job_factory_;
 760   scoped_refptr<TestSocketParams> params_;
 761   ClientSocketPoolHistograms histograms_;
 762   scoped_ptr<TestClientSocketPool> pool_;
 763   ClientSocketPoolTest test_base_;
 764 };
 765
 766 // Even though a timeout is specified, it doesn't time out on a synchronous
 767 // completion.
 768 TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
 769   TestConnectJobDelegate delegate;
 770   ClientSocketHandle ignored;
 771   TestClientSocketPoolBase::Request request(
 772       &ignored, CompletionCallback(), DEFAULT_PRIORITY,
 773       internal::ClientSocketPoolBaseHelper::NORMAL,
 774       false, params_, BoundNetLog());
 775   scoped_ptr<TestConnectJob> job(
 776       new TestConnectJob(TestConnectJob::kMockJob,
 777                          "a",
 778                          request,
 779                          base::TimeDelta::FromMicroseconds(1),
 780                          &delegate,
 781                          &client_socket_factory_,
 782                          NULL));
 783   EXPECT_EQ(OK, job->Connect());
 784 }
 785
 786 TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
 787   TestConnectJobDelegate delegate;
 788   ClientSocketHandle ignored;
 789   CapturingNetLog log;
 790
 791   TestClientSocketPoolBase::Request request(
 792       &ignored, CompletionCallback(), DEFAULT_PRIORITY,
 793       internal::ClientSocketPoolBaseHelper::NORMAL,
 794       false, params_, BoundNetLog());
 795   // Deleted by TestConnectJobDelegate.
 796   TestConnectJob* job =
 797       new TestConnectJob(TestConnectJob::kMockPendingJob,
 798                          "a",
 799                          request,
 800                          base::TimeDelta::FromMicroseconds(1),
 801                          &delegate,
 802                          &client_socket_factory_,
 803                          &log);
 804   ASSERT_EQ(ERR_IO_PENDING, job->Connect());
 805   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
 806   EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult());
 807
 808   CapturingNetLog::CapturedEntryList entries;
 809   log.GetEntries(&entries);
 810
 811   EXPECT_EQ(6u, entries.size());
 812   EXPECT_TRUE(LogContainsBeginEvent(
 813       entries, 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
 814   EXPECT_TRUE(LogContainsBeginEvent(
 815       entries, 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
 816   EXPECT_TRUE(LogContainsEvent(
 817       entries, 2, NetLog::TYPE_CONNECT_JOB_SET_SOCKET,
 818       NetLog::PHASE_NONE));
 819   EXPECT_TRUE(LogContainsEvent(
 820       entries, 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
 821       NetLog::PHASE_NONE));
 822   EXPECT_TRUE(LogContainsEndEvent(
 823       entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
 824   EXPECT_TRUE(LogContainsEndEvent(
 825       entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
 826 }
 827
 828 TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
 829   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 830
 831   TestCompletionCallback callback;
 832   ClientSocketHandle handle;
 833   CapturingBoundNetLog log;
 834   TestLoadTimingInfoNotConnected(handle);
 835
 836   EXPECT_EQ(OK,
 837             handle.Init("a",
 838                         params_,
 839                         DEFAULT_PRIORITY,
 840                         callback.callback(),
 841                         pool_.get(),
 842                         log.bound()));
 843   EXPECT_TRUE(handle.is_initialized());
 844   EXPECT_TRUE(handle.socket());
 845   TestLoadTimingInfoConnectedNotReused(handle);
 846
 847   handle.Reset();
 848   TestLoadTimingInfoNotConnected(handle);
 849
 850   CapturingNetLog::CapturedEntryList entries;
 851   log.GetEntries(&entries);
 852
 853   EXPECT_EQ(4u, entries.size());
 854   EXPECT_TRUE(LogContainsBeginEvent(
 855       entries, 0, NetLog::TYPE_SOCKET_POOL));
 856   EXPECT_TRUE(LogContainsEvent(
 857       entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
 858       NetLog::PHASE_NONE));
 859   EXPECT_TRUE(LogContainsEvent(
 860       entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
 861       NetLog::PHASE_NONE));
 862   EXPECT_TRUE(LogContainsEndEvent(
 863       entries, 3, NetLog::TYPE_SOCKET_POOL));
 864 }
 865
 866 TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
 867   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 868
 869   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
 870   CapturingBoundNetLog log;
 871
 872   ClientSocketHandle handle;
 873   TestCompletionCallback callback;
 874   // Set the additional error state members to ensure that they get cleared.
 875   handle.set_is_ssl_error(true);
 876   HttpResponseInfo info;
 877   info.headers = new HttpResponseHeaders(std::string());
 878   handle.set_ssl_error_response_info(info);
 879   EXPECT_EQ(ERR_CONNECTION_FAILED,
 880             handle.Init("a",
 881                         params_,
 882                         DEFAULT_PRIORITY,
 883                         callback.callback(),
 884                         pool_.get(),
 885                         log.bound()));
 886   EXPECT_FALSE(handle.socket());
 887   EXPECT_FALSE(handle.is_ssl_error());
 888   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
 889   TestLoadTimingInfoNotConnected(handle);
 890
 891   CapturingNetLog::CapturedEntryList entries;
 892   log.GetEntries(&entries);
 893
 894   EXPECT_EQ(3u, entries.size());
 895   EXPECT_TRUE(LogContainsBeginEvent(
 896       entries, 0, NetLog::TYPE_SOCKET_POOL));
 897   EXPECT_TRUE(LogContainsEvent(
 898       entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
 899       NetLog::PHASE_NONE));
 900   EXPECT_TRUE(LogContainsEndEvent(
 901       entries, 2, NetLog::TYPE_SOCKET_POOL));
 902 }
 903
 904 TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
 905   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 906
 907   // TODO(eroman): Check that the NetLog contains this event.
 908
 909   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
 910   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
 911   EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
 912   EXPECT_EQ(OK, StartRequest("d", DEFAULT_PRIORITY));
 913
 914   EXPECT_EQ(static_cast<int>(requests_size()),
 915             client_socket_factory_.allocation_count());
 916   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 917
 918   EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
 919   EXPECT_EQ(ERR_IO_PENDING, StartRequest("f", DEFAULT_PRIORITY));
 920   EXPECT_EQ(ERR_IO_PENDING, StartRequest("g", DEFAULT_PRIORITY));
 921
 922   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 923
 924   EXPECT_EQ(static_cast<int>(requests_size()),
 925             client_socket_factory_.allocation_count());
 926   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 927
 928   EXPECT_EQ(1, GetOrderOfRequest(1));
 929   EXPECT_EQ(2, GetOrderOfRequest(2));
 930   EXPECT_EQ(3, GetOrderOfRequest(3));
 931   EXPECT_EQ(4, GetOrderOfRequest(4));
 932   EXPECT_EQ(5, GetOrderOfRequest(5));
 933   EXPECT_EQ(6, GetOrderOfRequest(6));
 934   EXPECT_EQ(7, GetOrderOfRequest(7));
 935
 936   // Make sure we test order of all requests made.
 937   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
 938 }
 939
 940 TEST_F(ClientSocketPoolBaseTest, TotalLimitReachedNewGroup) {
 941   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 942
 943   // TODO(eroman): Check that the NetLog contains this event.
 944
 945   // Reach all limits: max total sockets, and max sockets per group.
 946   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
 947   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
 948   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
 949   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
 950
 951   EXPECT_EQ(static_cast<int>(requests_size()),
 952             client_socket_factory_.allocation_count());
 953   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 954
 955   // Now create a new group and verify that we don't starve it.
 956   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
 957
 958   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 959
 960   EXPECT_EQ(static_cast<int>(requests_size()),
 961             client_socket_factory_.allocation_count());
 962   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 963
 964   EXPECT_EQ(1, GetOrderOfRequest(1));
 965   EXPECT_EQ(2, GetOrderOfRequest(2));
 966   EXPECT_EQ(3, GetOrderOfRequest(3));
 967   EXPECT_EQ(4, GetOrderOfRequest(4));
 968   EXPECT_EQ(5, GetOrderOfRequest(5));
 969
 970   // Make sure we test order of all requests made.
 971   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6));
 972 }
 973
 974 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsPriority) {
 975   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
 976
 977   EXPECT_EQ(OK, StartRequest("b", LOWEST));
 978   EXPECT_EQ(OK, StartRequest("a", MEDIUM));
 979   EXPECT_EQ(OK, StartRequest("b", HIGHEST));
 980   EXPECT_EQ(OK, StartRequest("a", LOWEST));
 981
 982   EXPECT_EQ(static_cast<int>(requests_size()),
 983             client_socket_factory_.allocation_count());
 984
 985   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", LOWEST));
 986   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
 987   EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST));
 988
 989   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
 990
 991   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
 992
 993   // First 4 requests don't have to wait, and finish in order.
 994   EXPECT_EQ(1, GetOrderOfRequest(1));
 995   EXPECT_EQ(2, GetOrderOfRequest(2));
 996   EXPECT_EQ(3, GetOrderOfRequest(3));
 997   EXPECT_EQ(4, GetOrderOfRequest(4));
 998
 999   // Request ("b", HIGHEST) has the highest priority, then ("a", MEDIUM),
1000   // and then ("c", LOWEST).
1001   EXPECT_EQ(7, GetOrderOfRequest(5));
1002   EXPECT_EQ(6, GetOrderOfRequest(6));
1003   EXPECT_EQ(5, GetOrderOfRequest(7));
1004
1005   // Make sure we test order of all requests made.
1006   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9));
1007 }
1008
1009 TEST_F(ClientSocketPoolBaseTest, TotalLimitRespectsGroupLimit) {
1010   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1011
1012   EXPECT_EQ(OK, StartRequest("a", LOWEST));
1013   EXPECT_EQ(OK, StartRequest("a", LOW));
1014   EXPECT_EQ(OK, StartRequest("b", HIGHEST));
1015   EXPECT_EQ(OK, StartRequest("b", MEDIUM));
1016
1017   EXPECT_EQ(static_cast<int>(requests_size()),
1018             client_socket_factory_.allocation_count());
1019
1020   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", MEDIUM));
1021   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1022   EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", HIGHEST));
1023
1024   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1025
1026   EXPECT_EQ(static_cast<int>(requests_size()),
1027             client_socket_factory_.allocation_count());
1028   EXPECT_EQ(requests_size() - kDefaultMaxSockets, completion_count());
1029
1030   // First 4 requests don't have to wait, and finish in order.
1031   EXPECT_EQ(1, GetOrderOfRequest(1));
1032   EXPECT_EQ(2, GetOrderOfRequest(2));
1033   EXPECT_EQ(3, GetOrderOfRequest(3));
1034   EXPECT_EQ(4, GetOrderOfRequest(4));
1035
1036   // Request ("b", 7) has the highest priority, but we can't make new socket for
1037   // group "b", because it has reached the per-group limit. Then we make
1038   // socket for ("c", 6), because it has higher priority than ("a", 4),
1039   // and we still can't make a socket for group "b".
1040   EXPECT_EQ(5, GetOrderOfRequest(5));
1041   EXPECT_EQ(6, GetOrderOfRequest(6));
1042   EXPECT_EQ(7, GetOrderOfRequest(7));
1043
1044   // Make sure we test order of all requests made.
1045   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
1046 }
1047
1048 // Make sure that we count connecting sockets against the total limit.
1049 TEST_F(ClientSocketPoolBaseTest, TotalLimitCountsConnectingSockets) {
1050   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1051
1052   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1053   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
1054   EXPECT_EQ(OK, StartRequest("c", DEFAULT_PRIORITY));
1055
1056   // Create one asynchronous request.
1057   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1058   EXPECT_EQ(ERR_IO_PENDING, StartRequest("d", DEFAULT_PRIORITY));
1059
1060   // We post all of our delayed tasks with a 2ms delay. I.e. they don't
1061   // actually become pending until 2ms after they have been created. In order
1062   // to flush all tasks, we need to wait so that we know there are no
1063   // soon-to-be-pending tasks waiting.
1064   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
1065   base::MessageLoop::current()->RunUntilIdle();
1066
1067   // The next synchronous request should wait for its turn.
1068   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1069   EXPECT_EQ(ERR_IO_PENDING, StartRequest("e", DEFAULT_PRIORITY));
1070
1071   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1072
1073   EXPECT_EQ(static_cast<int>(requests_size()),
1074             client_socket_factory_.allocation_count());
1075
1076   EXPECT_EQ(1, GetOrderOfRequest(1));
1077   EXPECT_EQ(2, GetOrderOfRequest(2));
1078   EXPECT_EQ(3, GetOrderOfRequest(3));
1079   EXPECT_EQ(4, GetOrderOfRequest(4));
1080   EXPECT_EQ(5, GetOrderOfRequest(5));
1081
1082   // Make sure we test order of all requests made.
1083   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(6));
1084 }
1085
1086 TEST_F(ClientSocketPoolBaseTest, CorrectlyCountStalledGroups) {
1087   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
1088   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1089
1090   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1091   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1092   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1093   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1094
1095   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1096
1097   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1098
1099   EXPECT_EQ(ERR_IO_PENDING, StartRequest("b", DEFAULT_PRIORITY));
1100   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", DEFAULT_PRIORITY));
1101
1102   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1103
1104   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1105   EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
1106   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1107   EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
1108   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1109   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1110   EXPECT_EQ(kDefaultMaxSockets + 2, client_socket_factory_.allocation_count());
1111 }
1112
1113 TEST_F(ClientSocketPoolBaseTest, StallAndThenCancelAndTriggerAvailableSocket) {
1114   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
1115   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1116
1117   ClientSocketHandle handle;
1118   TestCompletionCallback callback;
1119   EXPECT_EQ(ERR_IO_PENDING,
1120             handle.Init("a",
1121                         params_,
1122                         DEFAULT_PRIORITY,
1123                         callback.callback(),
1124                         pool_.get(),
1125                         BoundNetLog()));
1126
1127   ClientSocketHandle handles[4];
1128   for (size_t i = 0; i < arraysize(handles); ++i) {
1129     TestCompletionCallback callback;
1130     EXPECT_EQ(ERR_IO_PENDING,
1131               handles[i].Init("b",
1132                               params_,
1133                               DEFAULT_PRIORITY,
1134                               callback.callback(),
1135                               pool_.get(),
1136                               BoundNetLog()));
1137   }
1138
1139   // One will be stalled, cancel all the handles now.
1140   // This should hit the OnAvailableSocketSlot() code where we previously had
1141   // stalled groups, but no longer have any.
1142   for (size_t i = 0; i < arraysize(handles); ++i)
1143     handles[i].Reset();
1144 }
1145
1146 TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
1147   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1148   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1149
1150   {
1151     ClientSocketHandle handles[kDefaultMaxSockets];
1152     TestCompletionCallback callbacks[kDefaultMaxSockets];
1153     for (int i = 0; i < kDefaultMaxSockets; ++i) {
1154       EXPECT_EQ(OK, handles[i].Init(base::IntToString(i),
1155                                     params_,
1156                                     DEFAULT_PRIORITY,
1157                                     callbacks[i].callback(),
1158                                     pool_.get(),
1159                                     BoundNetLog()));
1160     }
1161
1162     // Force a stalled group.
1163     ClientSocketHandle stalled_handle;
1164     TestCompletionCallback callback;
1165     EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
1166                                                   params_,
1167                                                   DEFAULT_PRIORITY,
1168                                                   callback.callback(),
1169                                                   pool_.get(),
1170                                                   BoundNetLog()));
1171
1172     // Cancel the stalled request.
1173     stalled_handle.Reset();
1174
1175     EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1176     EXPECT_EQ(0, pool_->IdleSocketCount());
1177
1178     // Dropping out of scope will close all handles and return them to idle.
1179   }
1180
1181   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1182   EXPECT_EQ(kDefaultMaxSockets, pool_->IdleSocketCount());
1183 }
1184
1185 TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
1186   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1187   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1188
1189   {
1190     ClientSocketHandle handles[kDefaultMaxSockets];
1191     for (int i = 0; i < kDefaultMaxSockets; ++i) {
1192       TestCompletionCallback callback;
1193       EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i),
1194                                                 params_,
1195                                                 DEFAULT_PRIORITY,
1196                                                 callback.callback(),
1197                                                 pool_.get(),
1198                                                 BoundNetLog()));
1199     }
1200
1201     // Force a stalled group.
1202     connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1203     ClientSocketHandle stalled_handle;
1204     TestCompletionCallback callback;
1205     EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
1206                                                   params_,
1207                                                   DEFAULT_PRIORITY,
1208                                                   callback.callback(),
1209                                                   pool_.get(),
1210                                                   BoundNetLog()));
1211
1212     // Since it is stalled, it should have no connect jobs.
1213     EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
1214     EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
1215
1216     // Cancel the stalled request.
1217     handles[0].Reset();
1218
1219     // Now we should have a connect job.
1220     EXPECT_EQ(1, pool_->NumConnectJobsInGroup("foo"));
1221     EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
1222
1223     // The stalled socket should connect.
1224     EXPECT_EQ(OK, callback.WaitForResult());
1225
1226     EXPECT_EQ(kDefaultMaxSockets + 1,
1227               client_socket_factory_.allocation_count());
1228     EXPECT_EQ(0, pool_->IdleSocketCount());
1229     EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
1230     EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("foo"));
1231
1232     // Dropping out of scope will close all handles and return them to idle.
1233   }
1234
1235   EXPECT_EQ(1, pool_->IdleSocketCount());
1236 }
1237
1238 TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
1239   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1240   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1241
1242   ClientSocketHandle stalled_handle;
1243   TestCompletionCallback callback;
1244   {
1245     EXPECT_FALSE(pool_->IsStalled());
1246     ClientSocketHandle handles[kDefaultMaxSockets];
1247     for (int i = 0; i < kDefaultMaxSockets; ++i) {
1248       TestCompletionCallback callback;
1249       EXPECT_EQ(OK, handles[i].Init(base::StringPrintf(
1250           "Take 2: %d", i),
1251           params_,
1252           DEFAULT_PRIORITY,
1253           callback.callback(),
1254           pool_.get(),
1255           BoundNetLog()));
1256     }
1257
1258     EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1259     EXPECT_EQ(0, pool_->IdleSocketCount());
1260     EXPECT_FALSE(pool_->IsStalled());
1261
1262     // Now we will hit the socket limit.
1263     EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
1264                                                   params_,
1265                                                   DEFAULT_PRIORITY,
1266                                                   callback.callback(),
1267                                                   pool_.get(),
1268                                                   BoundNetLog()));
1269     EXPECT_TRUE(pool_->IsStalled());
1270
1271     // Dropping out of scope will close all handles and return them to idle.
1272   }
1273
1274   // But if we wait for it, the released idle sockets will be closed in
1275   // preference of the waiting request.
1276   EXPECT_EQ(OK, callback.WaitForResult());
1277
1278   EXPECT_EQ(kDefaultMaxSockets + 1, client_socket_factory_.allocation_count());
1279   EXPECT_EQ(3, pool_->IdleSocketCount());
1280 }
1281
1282 // Regression test for http://crbug.com/40952.
1283 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
1284   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1285   pool_->EnableConnectBackupJobs();
1286   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1287
1288   for (int i = 0; i < kDefaultMaxSockets; ++i) {
1289     ClientSocketHandle handle;
1290     TestCompletionCallback callback;
1291     EXPECT_EQ(OK, handle.Init(base::IntToString(i),
1292                               params_,
1293                               DEFAULT_PRIORITY,
1294                               callback.callback(),
1295                               pool_.get(),
1296                               BoundNetLog()));
1297   }
1298
1299   // Flush all the DoReleaseSocket tasks.
1300   base::MessageLoop::current()->RunUntilIdle();
1301
1302   // Stall a group.  Set a pending job so it'll trigger a backup job if we don't
1303   // reuse a socket.
1304   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1305   ClientSocketHandle handle;
1306   TestCompletionCallback callback;
1307
1308   // "0" is special here, since it should be the first entry in the sorted map,
1309   // which is the one which we would close an idle socket for.  We shouldn't
1310   // close an idle socket though, since we should reuse the idle socket.
1311   EXPECT_EQ(OK, handle.Init("0",
1312                             params_,
1313                             DEFAULT_PRIORITY,
1314                             callback.callback(),
1315                             pool_.get(),
1316                             BoundNetLog()));
1317
1318   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
1319   EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
1320 }
1321
1322 TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
1323   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1324
1325   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1326   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1327   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", IDLE));
1328   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1329   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1330   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1331   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1332   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1333
1334   ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
1335
1336   EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1337             client_socket_factory_.allocation_count());
1338   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1339             completion_count());
1340
1341   EXPECT_EQ(1, GetOrderOfRequest(1));
1342   EXPECT_EQ(2, GetOrderOfRequest(2));
1343   EXPECT_EQ(8, GetOrderOfRequest(3));
1344   EXPECT_EQ(6, GetOrderOfRequest(4));
1345   EXPECT_EQ(4, GetOrderOfRequest(5));
1346   EXPECT_EQ(3, GetOrderOfRequest(6));
1347   EXPECT_EQ(5, GetOrderOfRequest(7));
1348   EXPECT_EQ(7, GetOrderOfRequest(8));
1349
1350   // Make sure we test order of all requests made.
1351   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(9));
1352 }
1353
1354 TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) {
1355   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1356
1357   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1358   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1359   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1360   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1361   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1362   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1363   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1364
1365   ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
1366
1367   for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i)
1368     EXPECT_EQ(OK, request(i)->WaitForResult());
1369
1370   EXPECT_EQ(static_cast<int>(requests_size()),
1371             client_socket_factory_.allocation_count());
1372   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1373             completion_count());
1374 }
1375
1376 // This test will start up a RequestSocket() and then immediately Cancel() it.
1377 // The pending connect job will be cancelled and should not call back into
1378 // ClientSocketPoolBase.
1379 TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
1380   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1381
1382   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1383   ClientSocketHandle handle;
1384   TestCompletionCallback callback;
1385   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
1386                                         params_,
1387                                         DEFAULT_PRIORITY,
1388                                         callback.callback(),
1389                                         pool_.get(),
1390                                         BoundNetLog()));
1391   handle.Reset();
1392 }
1393
1394 TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
1395   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1396
1397   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1398   ClientSocketHandle handle;
1399   TestCompletionCallback callback;
1400
1401   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
1402                                         params_,
1403                                         DEFAULT_PRIORITY,
1404                                         callback.callback(),
1405                                         pool_.get(),
1406                                         BoundNetLog()));
1407
1408   handle.Reset();
1409
1410   TestCompletionCallback callback2;
1411   EXPECT_EQ(ERR_IO_PENDING,
1412             handle.Init("a",
1413                         params_,
1414                         DEFAULT_PRIORITY,
1415                         callback2.callback(),
1416                         pool_.get(),
1417                         BoundNetLog()));
1418
1419   EXPECT_EQ(OK, callback2.WaitForResult());
1420   EXPECT_FALSE(callback.have_result());
1421
1422   handle.Reset();
1423 }
1424
1425 TEST_F(ClientSocketPoolBaseTest, CancelRequest) {
1426   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1427
1428   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1429   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1430   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1431   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1432   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1433   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1434   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1435
1436   // Cancel a request.
1437   size_t index_to_cancel = kDefaultMaxSocketsPerGroup + 2;
1438   EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
1439   (*requests())[index_to_cancel]->handle()->Reset();
1440
1441   ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
1442
1443   EXPECT_EQ(kDefaultMaxSocketsPerGroup,
1444             client_socket_factory_.allocation_count());
1445   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup - 1,
1446             completion_count());
1447
1448   EXPECT_EQ(1, GetOrderOfRequest(1));
1449   EXPECT_EQ(2, GetOrderOfRequest(2));
1450   EXPECT_EQ(5, GetOrderOfRequest(3));
1451   EXPECT_EQ(3, GetOrderOfRequest(4));
1452   EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
1453             GetOrderOfRequest(5));  // Canceled request.
1454   EXPECT_EQ(4, GetOrderOfRequest(6));
1455   EXPECT_EQ(6, GetOrderOfRequest(7));
1456
1457   // Make sure we test order of all requests made.
1458   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(8));
1459 }
1460
1461 class RequestSocketCallback : public TestCompletionCallbackBase {
1462  public:
1463   RequestSocketCallback(ClientSocketHandle* handle,
1464                         TestClientSocketPool* pool,
1465                         TestConnectJobFactory* test_connect_job_factory,
1466                         TestConnectJob::JobType next_job_type)
1467       : handle_(handle),
1468         pool_(pool),
1469         within_callback_(false),
1470         test_connect_job_factory_(test_connect_job_factory),
1471         next_job_type_(next_job_type),
1472         callback_(base::Bind(&RequestSocketCallback::OnComplete,
1473                              base::Unretained(this))) {
1474   }
1475
1476   virtual ~RequestSocketCallback() {}
1477
1478   const CompletionCallback& callback() const { return callback_; }
1479
1480  private:
1481   void OnComplete(int result) {
1482     SetResult(result);
1483     ASSERT_EQ(OK, result);
1484
1485     if (!within_callback_) {
1486       test_connect_job_factory_->set_job_type(next_job_type_);
1487
1488       // Don't allow reuse of the socket.  Disconnect it and then release it and
1489       // run through the MessageLoop once to get it completely released.
1490       handle_->socket()->Disconnect();
1491       handle_->Reset();
1492       {
1493         // TODO: Resolve conflicting intentions of stopping recursion with the
1494         // |!within_callback_| test (above) and the call to |RunUntilIdle()|
1495         // below.  http://crbug.com/114130.
1496         base::MessageLoop::ScopedNestableTaskAllower allow(
1497             base::MessageLoop::current());
1498         base::MessageLoop::current()->RunUntilIdle();
1499       }
1500       within_callback_ = true;
1501       TestCompletionCallback next_job_callback;
1502       scoped_refptr<TestSocketParams> params(
1503           new TestSocketParams(false /* ignore_limits */));
1504       int rv = handle_->Init("a",
1505                              params,
1506                              DEFAULT_PRIORITY,
1507                              next_job_callback.callback(),
1508                              pool_,
1509                              BoundNetLog());
1510       switch (next_job_type_) {
1511         case TestConnectJob::kMockJob:
1512           EXPECT_EQ(OK, rv);
1513           break;
1514         case TestConnectJob::kMockPendingJob:
1515           EXPECT_EQ(ERR_IO_PENDING, rv);
1516
1517           // For pending jobs, wait for new socket to be created. This makes
1518           // sure there are no more pending operations nor any unclosed sockets
1519           // when the test finishes.
1520           // We need to give it a little bit of time to run, so that all the
1521           // operations that happen on timers (e.g. cleanup of idle
1522           // connections) can execute.
1523           {
1524             base::MessageLoop::ScopedNestableTaskAllower allow(
1525                 base::MessageLoop::current());
1526             base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
1527             EXPECT_EQ(OK, next_job_callback.WaitForResult());
1528           }
1529           break;
1530         default:
1531           FAIL() << "Unexpected job type: " << next_job_type_;
1532           break;
1533       }
1534     }
1535   }
1536
1537   ClientSocketHandle* const handle_;
1538   TestClientSocketPool* const pool_;
1539   bool within_callback_;
1540   TestConnectJobFactory* const test_connect_job_factory_;
1541   TestConnectJob::JobType next_job_type_;
1542   CompletionCallback callback_;
1543 };
1544
1545 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
1546   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1547
1548   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1549   ClientSocketHandle handle;
1550   RequestSocketCallback callback(
1551       &handle, pool_.get(), connect_job_factory_,
1552       TestConnectJob::kMockPendingJob);
1553   int rv = handle.Init("a",
1554                        params_,
1555                        DEFAULT_PRIORITY,
1556                        callback.callback(),
1557                        pool_.get(),
1558                        BoundNetLog());
1559   ASSERT_EQ(ERR_IO_PENDING, rv);
1560
1561   EXPECT_EQ(OK, callback.WaitForResult());
1562 }
1563
1564 TEST_F(ClientSocketPoolBaseTest, RequestPendingJobThenSynchronous) {
1565   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1566
1567   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1568   ClientSocketHandle handle;
1569   RequestSocketCallback callback(
1570       &handle, pool_.get(), connect_job_factory_, TestConnectJob::kMockJob);
1571   int rv = handle.Init("a",
1572                        params_,
1573                        DEFAULT_PRIORITY,
1574                        callback.callback(),
1575                        pool_.get(),
1576                        BoundNetLog());
1577   ASSERT_EQ(ERR_IO_PENDING, rv);
1578
1579   EXPECT_EQ(OK, callback.WaitForResult());
1580 }
1581
1582 // Make sure that pending requests get serviced after active requests get
1583 // cancelled.
1584 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
1585   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1586
1587   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1588
1589   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1590   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1591   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1592   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1593   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1594   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1595   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1596
1597   // Now, kDefaultMaxSocketsPerGroup requests should be active.
1598   // Let's cancel them.
1599   for (int i = 0; i < kDefaultMaxSocketsPerGroup; ++i) {
1600     ASSERT_FALSE(request(i)->handle()->is_initialized());
1601     request(i)->handle()->Reset();
1602   }
1603
1604   // Let's wait for the rest to complete now.
1605   for (size_t i = kDefaultMaxSocketsPerGroup; i < requests_size(); ++i) {
1606     EXPECT_EQ(OK, request(i)->WaitForResult());
1607     request(i)->handle()->Reset();
1608   }
1609
1610   EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
1611             completion_count());
1612 }
1613
1614 // Make sure that pending requests get serviced after active requests fail.
1615 TEST_F(ClientSocketPoolBaseTest, FailingActiveRequestWithPendingRequests) {
1616   const size_t kMaxSockets = 5;
1617   CreatePool(kMaxSockets, kDefaultMaxSocketsPerGroup);
1618
1619   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1620
1621   const size_t kNumberOfRequests = 2 * kDefaultMaxSocketsPerGroup + 1;
1622   ASSERT_LE(kNumberOfRequests, kMaxSockets);  // Otherwise the test will hang.
1623
1624   // Queue up all the requests
1625   for (size_t i = 0; i < kNumberOfRequests; ++i)
1626     EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1627
1628   for (size_t i = 0; i < kNumberOfRequests; ++i)
1629     EXPECT_EQ(ERR_CONNECTION_FAILED, request(i)->WaitForResult());
1630 }
1631
1632 TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestThenRequestSocket) {
1633   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1634
1635   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1636
1637   ClientSocketHandle handle;
1638   TestCompletionCallback callback;
1639   int rv = handle.Init("a",
1640                        params_,
1641                        DEFAULT_PRIORITY,
1642                        callback.callback(),
1643                        pool_.get(),
1644                        BoundNetLog());
1645   EXPECT_EQ(ERR_IO_PENDING, rv);
1646
1647   // Cancel the active request.
1648   handle.Reset();
1649
1650   rv = handle.Init("a",
1651                    params_,
1652                    DEFAULT_PRIORITY,
1653                    callback.callback(),
1654                    pool_.get(),
1655                    BoundNetLog());
1656   EXPECT_EQ(ERR_IO_PENDING, rv);
1657   EXPECT_EQ(OK, callback.WaitForResult());
1658
1659   EXPECT_FALSE(handle.is_reused());
1660   TestLoadTimingInfoConnectedNotReused(handle);
1661   EXPECT_EQ(2, client_socket_factory_.allocation_count());
1662 }
1663
1664 // Regression test for http://crbug.com/17985.
1665 TEST_F(ClientSocketPoolBaseTest, GroupWithPendingRequestsIsNotEmpty) {
1666   const int kMaxSockets = 3;
1667   const int kMaxSocketsPerGroup = 2;
1668   CreatePool(kMaxSockets, kMaxSocketsPerGroup);
1669
1670   const RequestPriority kHighPriority = HIGHEST;
1671
1672   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1673   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
1674
1675   // This is going to be a pending request in an otherwise empty group.
1676   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
1677
1678   // Reach the maximum socket limit.
1679   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
1680
1681   // Create a stalled group with high priorities.
1682   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority));
1683   EXPECT_EQ(ERR_IO_PENDING, StartRequest("c", kHighPriority));
1684
1685   // Release the first two sockets from "a".  Because this is a keepalive,
1686   // the first release will unblock the pending request for "a".  The
1687   // second release will unblock a request for "c", becaue it is the next
1688   // high priority socket.
1689   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1690   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::KEEP_ALIVE));
1691
1692   // Closing idle sockets should not get us into trouble, but in the bug
1693   // we were hitting a CHECK here.
1694   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
1695   pool_->CloseIdleSockets();
1696
1697   // Run the released socket wakeups.
1698   base::MessageLoop::current()->RunUntilIdle();
1699 }
1700
1701 TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
1702   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1703
1704   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1705   ClientSocketHandle handle;
1706   TestCompletionCallback callback;
1707   CapturingBoundNetLog log;
1708   int rv = handle.Init("a",
1709                        params_,
1710                        LOWEST,
1711                        callback.callback(),
1712                        pool_.get(),
1713                        log.bound());
1714   EXPECT_EQ(ERR_IO_PENDING, rv);
1715   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
1716   TestLoadTimingInfoNotConnected(handle);
1717
1718   EXPECT_EQ(OK, callback.WaitForResult());
1719   EXPECT_TRUE(handle.is_initialized());
1720   EXPECT_TRUE(handle.socket());
1721   TestLoadTimingInfoConnectedNotReused(handle);
1722
1723   handle.Reset();
1724   TestLoadTimingInfoNotConnected(handle);
1725
1726   CapturingNetLog::CapturedEntryList entries;
1727   log.GetEntries(&entries);
1728
1729   EXPECT_EQ(4u, entries.size());
1730   EXPECT_TRUE(LogContainsBeginEvent(
1731       entries, 0, NetLog::TYPE_SOCKET_POOL));
1732   EXPECT_TRUE(LogContainsEvent(
1733       entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
1734       NetLog::PHASE_NONE));
1735   EXPECT_TRUE(LogContainsEvent(
1736       entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
1737       NetLog::PHASE_NONE));
1738   EXPECT_TRUE(LogContainsEndEvent(
1739       entries, 3, NetLog::TYPE_SOCKET_POOL));
1740 }
1741
1742 TEST_F(ClientSocketPoolBaseTest,
1743        InitConnectionAsynchronousFailure) {
1744   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1745
1746   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1747   ClientSocketHandle handle;
1748   TestCompletionCallback callback;
1749   CapturingBoundNetLog log;
1750   // Set the additional error state members to ensure that they get cleared.
1751   handle.set_is_ssl_error(true);
1752   HttpResponseInfo info;
1753   info.headers = new HttpResponseHeaders(std::string());
1754   handle.set_ssl_error_response_info(info);
1755   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
1756                                         params_,
1757                                         DEFAULT_PRIORITY,
1758                                         callback.callback(),
1759                                         pool_.get(),
1760                                         log.bound()));
1761   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
1762   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
1763   EXPECT_FALSE(handle.is_ssl_error());
1764   EXPECT_TRUE(handle.ssl_error_response_info().headers.get() == NULL);
1765
1766   CapturingNetLog::CapturedEntryList entries;
1767   log.GetEntries(&entries);
1768
1769   EXPECT_EQ(3u, entries.size());
1770   EXPECT_TRUE(LogContainsBeginEvent(
1771       entries, 0, NetLog::TYPE_SOCKET_POOL));
1772   EXPECT_TRUE(LogContainsEvent(
1773       entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
1774       NetLog::PHASE_NONE));
1775   EXPECT_TRUE(LogContainsEndEvent(
1776       entries, 2, NetLog::TYPE_SOCKET_POOL));
1777 }
1778
1779 TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
1780   // TODO(eroman): Add back the log expectations! Removed them because the
1781   //               ordering is difficult, and some may fire during destructor.
1782   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1783
1784   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1785   ClientSocketHandle handle;
1786   TestCompletionCallback callback;
1787   ClientSocketHandle handle2;
1788   TestCompletionCallback callback2;
1789
1790   EXPECT_EQ(ERR_IO_PENDING,
1791             handle.Init("a",
1792                         params_,
1793                         DEFAULT_PRIORITY,
1794                         callback.callback(),
1795                         pool_.get(),
1796                         BoundNetLog()));
1797   CapturingBoundNetLog log2;
1798   EXPECT_EQ(ERR_IO_PENDING,
1799             handle2.Init("a",
1800                          params_,
1801                          DEFAULT_PRIORITY,
1802                          callback2.callback(),
1803                          pool_.get(),
1804                          BoundNetLog()));
1805
1806   handle.Reset();
1807
1808
1809   // At this point, request 2 is just waiting for the connect job to finish.
1810
1811   EXPECT_EQ(OK, callback2.WaitForResult());
1812   handle2.Reset();
1813
1814   // Now request 2 has actually finished.
1815   // TODO(eroman): Add back log expectations.
1816 }
1817
1818 TEST_F(ClientSocketPoolBaseTest, CancelRequestLimitsJobs) {
1819   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1820
1821   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1822
1823   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
1824   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
1825   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
1826   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
1827
1828   EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1829   (*requests())[2]->handle()->Reset();
1830   (*requests())[3]->handle()->Reset();
1831   EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1832
1833   (*requests())[1]->handle()->Reset();
1834   EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1835
1836   (*requests())[0]->handle()->Reset();
1837   EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->NumConnectJobsInGroup("a"));
1838 }
1839
1840 // When requests and ConnectJobs are not coupled, the request will get serviced
1841 // by whatever comes first.
1842 TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
1843   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1844
1845   // Start job 1 (async OK)
1846   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
1847
1848   std::vector<TestSocketRequest*> request_order;
1849   size_t completion_count;  // unused
1850   TestSocketRequest req1(&request_order, &completion_count);
1851   int rv = req1.handle()->Init("a",
1852                                params_,
1853                                DEFAULT_PRIORITY,
1854                                req1.callback(), pool_.get(),
1855                                BoundNetLog());
1856   EXPECT_EQ(ERR_IO_PENDING, rv);
1857   EXPECT_EQ(OK, req1.WaitForResult());
1858
1859   // Job 1 finished OK.  Start job 2 (also async OK).  Request 3 is pending
1860   // without a job.
1861   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1862
1863   TestSocketRequest req2(&request_order, &completion_count);
1864   rv = req2.handle()->Init("a",
1865                            params_,
1866                            DEFAULT_PRIORITY,
1867                            req2.callback(),
1868                            pool_.get(),
1869                            BoundNetLog());
1870   EXPECT_EQ(ERR_IO_PENDING, rv);
1871   TestSocketRequest req3(&request_order, &completion_count);
1872   rv = req3.handle()->Init("a",
1873                            params_,
1874                            DEFAULT_PRIORITY,
1875                            req3.callback(),
1876                            pool_.get(),
1877                            BoundNetLog());
1878   EXPECT_EQ(ERR_IO_PENDING, rv);
1879
1880   // Both Requests 2 and 3 are pending.  We release socket 1 which should
1881   // service request 2.  Request 3 should still be waiting.
1882   req1.handle()->Reset();
1883   // Run the released socket wakeups.
1884   base::MessageLoop::current()->RunUntilIdle();
1885   ASSERT_TRUE(req2.handle()->socket());
1886   EXPECT_EQ(OK, req2.WaitForResult());
1887   EXPECT_FALSE(req3.handle()->socket());
1888
1889   // Signal job 2, which should service request 3.
1890
1891   client_socket_factory_.SignalJobs();
1892   EXPECT_EQ(OK, req3.WaitForResult());
1893
1894   ASSERT_EQ(3U, request_order.size());
1895   EXPECT_EQ(&req1, request_order[0]);
1896   EXPECT_EQ(&req2, request_order[1]);
1897   EXPECT_EQ(&req3, request_order[2]);
1898   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
1899 }
1900
1901 // The requests are not coupled to the jobs.  So, the requests should finish in
1902 // their priority / insertion order.
1903 TEST_F(ClientSocketPoolBaseTest, PendingJobCompletionOrder) {
1904   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1905   // First two jobs are async.
1906   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
1907
1908   std::vector<TestSocketRequest*> request_order;
1909   size_t completion_count;  // unused
1910   TestSocketRequest req1(&request_order, &completion_count);
1911   int rv = req1.handle()->Init("a",
1912                                params_,
1913                                DEFAULT_PRIORITY,
1914                                req1.callback(),
1915                                pool_.get(),
1916                                BoundNetLog());
1917   EXPECT_EQ(ERR_IO_PENDING, rv);
1918
1919   TestSocketRequest req2(&request_order, &completion_count);
1920   rv = req2.handle()->Init("a",
1921                            params_,
1922                            DEFAULT_PRIORITY,
1923                            req2.callback(),
1924                            pool_.get(),
1925                            BoundNetLog());
1926   EXPECT_EQ(ERR_IO_PENDING, rv);
1927
1928   // The pending job is sync.
1929   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
1930
1931   TestSocketRequest req3(&request_order, &completion_count);
1932   rv = req3.handle()->Init("a",
1933                            params_,
1934                            DEFAULT_PRIORITY,
1935                            req3.callback(),
1936                            pool_.get(),
1937                            BoundNetLog());
1938   EXPECT_EQ(ERR_IO_PENDING, rv);
1939
1940   EXPECT_EQ(ERR_CONNECTION_FAILED, req1.WaitForResult());
1941   EXPECT_EQ(OK, req2.WaitForResult());
1942   EXPECT_EQ(ERR_CONNECTION_FAILED, req3.WaitForResult());
1943
1944   ASSERT_EQ(3U, request_order.size());
1945   EXPECT_EQ(&req1, request_order[0]);
1946   EXPECT_EQ(&req2, request_order[1]);
1947   EXPECT_EQ(&req3, request_order[2]);
1948 }
1949
1950 // Test GetLoadState in the case there's only one socket request.
1951 TEST_F(ClientSocketPoolBaseTest, LoadStateOneRequest) {
1952   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
1953   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1954
1955   ClientSocketHandle handle;
1956   TestCompletionCallback callback;
1957   int rv = handle.Init("a",
1958                        params_,
1959                        DEFAULT_PRIORITY,
1960                        callback.callback(),
1961                        pool_.get(),
1962                        BoundNetLog());
1963   EXPECT_EQ(ERR_IO_PENDING, rv);
1964   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
1965
1966   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
1967   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
1968
1969   // No point in completing the connection, since ClientSocketHandles only
1970   // expect the LoadState to be checked while connecting.
1971 }
1972
1973 // Test GetLoadState in the case there are two socket requests.
1974 TEST_F(ClientSocketPoolBaseTest, LoadStateTwoRequests) {
1975   CreatePool(2, 2);
1976   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
1977
1978   ClientSocketHandle handle;
1979   TestCompletionCallback callback;
1980   int rv = handle.Init("a",
1981                        params_,
1982                        DEFAULT_PRIORITY,
1983                        callback.callback(),
1984                        pool_.get(),
1985                        BoundNetLog());
1986   EXPECT_EQ(ERR_IO_PENDING, rv);
1987
1988   ClientSocketHandle handle2;
1989   TestCompletionCallback callback2;
1990   rv = handle2.Init("a",
1991                     params_,
1992                     DEFAULT_PRIORITY,
1993                     callback2.callback(),
1994                     pool_.get(),
1995                     BoundNetLog());
1996   EXPECT_EQ(ERR_IO_PENDING, rv);
1997
1998   // If the first Job is in an earlier state than the second, the state of
1999   // the second job should be used for both handles.
2000   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_RESOLVING_HOST);
2001   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2002   EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
2003
2004   // If the second Job is in an earlier state than the second, the state of
2005   // the first job should be used for both handles.
2006   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2007   // One request is farther
2008   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
2009   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
2010
2011   // Farthest along job connects and the first request gets the socket.  The
2012   // second handle switches to the state of the remaining ConnectJob.
2013   client_socket_factory_.SignalJob(0);
2014   EXPECT_EQ(OK, callback.WaitForResult());
2015   EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
2016 }
2017
2018 // Test GetLoadState in the case the per-group limit is reached.
2019 TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
2020   CreatePool(2, 1);
2021   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2022
2023   ClientSocketHandle handle;
2024   TestCompletionCallback callback;
2025   int rv = handle.Init("a",
2026                        params_,
2027                        MEDIUM,
2028                        callback.callback(),
2029                        pool_.get(),
2030                        BoundNetLog());
2031   EXPECT_EQ(ERR_IO_PENDING, rv);
2032   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2033
2034   // Request another socket from the same pool, buth with a higher priority.
2035   // The first request should now be stalled at the socket group limit.
2036   ClientSocketHandle handle2;
2037   TestCompletionCallback callback2;
2038   rv = handle2.Init("a",
2039                     params_,
2040                     HIGHEST,
2041                     callback2.callback(),
2042                     pool_.get(),
2043                     BoundNetLog());
2044   EXPECT_EQ(ERR_IO_PENDING, rv);
2045   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2046   EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
2047
2048   // The first handle should remain stalled as the other socket goes through
2049   // the connect process.
2050
2051   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2052   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2053   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle2.GetLoadState());
2054
2055   client_socket_factory_.SignalJob(0);
2056   EXPECT_EQ(OK, callback2.WaitForResult());
2057   EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
2058
2059   // Closing the second socket should cause the stalled handle to finally get a
2060   // ConnectJob.
2061   handle2.socket()->Disconnect();
2062   handle2.Reset();
2063   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2064 }
2065
2066 // Test GetLoadState in the case the per-pool limit is reached.
2067 TEST_F(ClientSocketPoolBaseTest, LoadStatePoolLimit) {
2068   CreatePool(2, 2);
2069   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2070
2071   ClientSocketHandle handle;
2072   TestCompletionCallback callback;
2073   int rv = handle.Init("a",
2074                        params_,
2075                        DEFAULT_PRIORITY,
2076                        callback.callback(),
2077                        pool_.get(),
2078                        BoundNetLog());
2079   EXPECT_EQ(ERR_IO_PENDING, rv);
2080
2081   // Request for socket from another pool.
2082   ClientSocketHandle handle2;
2083   TestCompletionCallback callback2;
2084   rv = handle2.Init("b",
2085                     params_,
2086                     DEFAULT_PRIORITY,
2087                     callback2.callback(),
2088                     pool_.get(),
2089                     BoundNetLog());
2090   EXPECT_EQ(ERR_IO_PENDING, rv);
2091
2092   // Request another socket from the first pool.  Request should stall at the
2093   // socket pool limit.
2094   ClientSocketHandle handle3;
2095   TestCompletionCallback callback3;
2096   rv = handle3.Init("a",
2097                     params_,
2098                     DEFAULT_PRIORITY,
2099                     callback2.callback(),
2100                     pool_.get(),
2101                     BoundNetLog());
2102   EXPECT_EQ(ERR_IO_PENDING, rv);
2103
2104   // The third handle should remain stalled as the other sockets in its group
2105   // goes through the connect process.
2106
2107   EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
2108   EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2109
2110   client_socket_factory_.SetJobLoadState(0, LOAD_STATE_SSL_HANDSHAKE);
2111   EXPECT_EQ(LOAD_STATE_SSL_HANDSHAKE, handle.GetLoadState());
2112   EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2113
2114   client_socket_factory_.SignalJob(0);
2115   EXPECT_EQ(OK, callback.WaitForResult());
2116   EXPECT_EQ(LOAD_STATE_WAITING_FOR_STALLED_SOCKET_POOL, handle3.GetLoadState());
2117
2118   // Closing a socket should allow the stalled handle to finally get a new
2119   // ConnectJob.
2120   handle.socket()->Disconnect();
2121   handle.Reset();
2122   EXPECT_EQ(LOAD_STATE_CONNECTING, handle3.GetLoadState());
2123 }
2124
2125 TEST_F(ClientSocketPoolBaseTest, Recoverable) {
2126   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2127   connect_job_factory_->set_job_type(TestConnectJob::kMockRecoverableJob);
2128
2129   ClientSocketHandle handle;
2130   TestCompletionCallback callback;
2131   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED,
2132             handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(),
2133                         pool_.get(), BoundNetLog()));
2134   EXPECT_TRUE(handle.is_initialized());
2135   EXPECT_TRUE(handle.socket());
2136 }
2137
2138 TEST_F(ClientSocketPoolBaseTest, AsyncRecoverable) {
2139   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2140
2141   connect_job_factory_->set_job_type(
2142       TestConnectJob::kMockPendingRecoverableJob);
2143   ClientSocketHandle handle;
2144   TestCompletionCallback callback;
2145   EXPECT_EQ(ERR_IO_PENDING,
2146             handle.Init("a",
2147                         params_,
2148                         DEFAULT_PRIORITY,
2149                         callback.callback(),
2150                         pool_.get(),
2151                         BoundNetLog()));
2152   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2153   EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED, callback.WaitForResult());
2154   EXPECT_TRUE(handle.is_initialized());
2155   EXPECT_TRUE(handle.socket());
2156 }
2157
2158 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateSynchronous) {
2159   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2160   connect_job_factory_->set_job_type(
2161       TestConnectJob::kMockAdditionalErrorStateJob);
2162
2163   ClientSocketHandle handle;
2164   TestCompletionCallback callback;
2165   EXPECT_EQ(ERR_CONNECTION_FAILED,
2166             handle.Init("a",
2167                         params_,
2168                         DEFAULT_PRIORITY,
2169                         callback.callback(),
2170                         pool_.get(),
2171                         BoundNetLog()));
2172   EXPECT_FALSE(handle.is_initialized());
2173   EXPECT_FALSE(handle.socket());
2174   EXPECT_TRUE(handle.is_ssl_error());
2175   EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
2176 }
2177
2178 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorStateAsynchronous) {
2179   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2180
2181   connect_job_factory_->set_job_type(
2182       TestConnectJob::kMockPendingAdditionalErrorStateJob);
2183   ClientSocketHandle handle;
2184   TestCompletionCallback callback;
2185   EXPECT_EQ(ERR_IO_PENDING,
2186             handle.Init("a",
2187                         params_,
2188                         DEFAULT_PRIORITY,
2189                         callback.callback(),
2190                         pool_.get(),
2191                         BoundNetLog()));
2192   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2193   EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
2194   EXPECT_FALSE(handle.is_initialized());
2195   EXPECT_FALSE(handle.socket());
2196   EXPECT_TRUE(handle.is_ssl_error());
2197   EXPECT_FALSE(handle.ssl_error_response_info().headers.get() == NULL);
2198 }
2199
2200 // Make sure we can reuse sockets when the cleanup timer is disabled.
2201 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) {
2202   // Disable cleanup timer.
2203   internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
2204
2205   CreatePoolWithIdleTimeouts(
2206       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2207       base::TimeDelta(),  // Time out unused sockets immediately.
2208       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
2209
2210   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2211
2212   ClientSocketHandle handle;
2213   TestCompletionCallback callback;
2214   int rv = handle.Init("a",
2215                        params_,
2216                        LOWEST,
2217                        callback.callback(),
2218                        pool_.get(),
2219                        BoundNetLog());
2220   ASSERT_EQ(ERR_IO_PENDING, rv);
2221   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2222   ASSERT_EQ(OK, callback.WaitForResult());
2223
2224   // Use and release the socket.
2225   EXPECT_EQ(1, handle.socket()->Write(NULL, 1, CompletionCallback()));
2226   TestLoadTimingInfoConnectedNotReused(handle);
2227   handle.Reset();
2228
2229   // Should now have one idle socket.
2230   ASSERT_EQ(1, pool_->IdleSocketCount());
2231
2232   // Request a new socket. This should reuse the old socket and complete
2233   // synchronously.
2234   CapturingBoundNetLog log;
2235   rv = handle.Init("a",
2236                    params_,
2237                    LOWEST,
2238                    CompletionCallback(),
2239                    pool_.get(),
2240                    log.bound());
2241   ASSERT_EQ(OK, rv);
2242   EXPECT_TRUE(handle.is_reused());
2243   TestLoadTimingInfoConnectedReused(handle);
2244
2245   ASSERT_TRUE(pool_->HasGroup("a"));
2246   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2247   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
2248
2249   CapturingNetLog::CapturedEntryList entries;
2250   log.GetEntries(&entries);
2251   EXPECT_TRUE(LogContainsEntryWithType(
2252       entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
2253 }
2254
2255 // Make sure we cleanup old unused sockets when the cleanup timer is disabled.
2256 TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerNoReuse) {
2257   // Disable cleanup timer.
2258   internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
2259
2260   CreatePoolWithIdleTimeouts(
2261       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2262       base::TimeDelta(),  // Time out unused sockets immediately
2263       base::TimeDelta());  // Time out used sockets immediately
2264
2265   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2266
2267   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
2268
2269   ClientSocketHandle handle;
2270   TestCompletionCallback callback;
2271   int rv = handle.Init("a",
2272                        params_,
2273                        LOWEST,
2274                        callback.callback(),
2275                        pool_.get(),
2276                        BoundNetLog());
2277   ASSERT_EQ(ERR_IO_PENDING, rv);
2278   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2279
2280   ClientSocketHandle handle2;
2281   TestCompletionCallback callback2;
2282   rv = handle2.Init("a",
2283                     params_,
2284                     LOWEST,
2285                     callback2.callback(),
2286                     pool_.get(),
2287                     BoundNetLog());
2288   ASSERT_EQ(ERR_IO_PENDING, rv);
2289   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
2290
2291   // Cancel one of the requests.  Wait for the other, which will get the first
2292   // job.  Release the socket.  Run the loop again to make sure the second
2293   // socket is sitting idle and the first one is released (since ReleaseSocket()
2294   // just posts a DoReleaseSocket() task).
2295
2296   handle.Reset();
2297   ASSERT_EQ(OK, callback2.WaitForResult());
2298   // Use the socket.
2299   EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
2300   handle2.Reset();
2301
2302   // We post all of our delayed tasks with a 2ms delay. I.e. they don't
2303   // actually become pending until 2ms after they have been created. In order
2304   // to flush all tasks, we need to wait so that we know there are no
2305   // soon-to-be-pending tasks waiting.
2306   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
2307   base::MessageLoop::current()->RunUntilIdle();
2308
2309   // Both sockets should now be idle.
2310   ASSERT_EQ(2, pool_->IdleSocketCount());
2311
2312   // Request a new socket. This should cleanup the unused and timed out ones.
2313   // A new socket will be created rather than reusing the idle one.
2314   CapturingBoundNetLog log;
2315   TestCompletionCallback callback3;
2316   rv = handle.Init("a",
2317                    params_,
2318                    LOWEST,
2319                    callback3.callback(),
2320                    pool_.get(),
2321                    log.bound());
2322   ASSERT_EQ(ERR_IO_PENDING, rv);
2323   ASSERT_EQ(OK, callback3.WaitForResult());
2324   EXPECT_FALSE(handle.is_reused());
2325
2326   // Make sure the idle socket is closed.
2327   ASSERT_TRUE(pool_->HasGroup("a"));
2328   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
2329   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
2330
2331   CapturingNetLog::CapturedEntryList entries;
2332   log.GetEntries(&entries);
2333   EXPECT_FALSE(LogContainsEntryWithType(
2334       entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
2335 }
2336
2337 TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
2338   CreatePoolWithIdleTimeouts(
2339       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2340       base::TimeDelta(),  // Time out unused sockets immediately.
2341       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
2342
2343   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2344
2345   // Startup two mock pending connect jobs, which will sit in the MessageLoop.
2346
2347   ClientSocketHandle handle;
2348   TestCompletionCallback callback;
2349   int rv = handle.Init("a",
2350                        params_,
2351                        LOWEST,
2352                        callback.callback(),
2353                        pool_.get(),
2354                        BoundNetLog());
2355   EXPECT_EQ(ERR_IO_PENDING, rv);
2356   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
2357
2358   ClientSocketHandle handle2;
2359   TestCompletionCallback callback2;
2360   rv = handle2.Init("a",
2361                     params_,
2362                     LOWEST,
2363                     callback2.callback(),
2364                     pool_.get(),
2365                     BoundNetLog());
2366   EXPECT_EQ(ERR_IO_PENDING, rv);
2367   EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
2368
2369   // Cancel one of the requests.  Wait for the other, which will get the first
2370   // job.  Release the socket.  Run the loop again to make sure the second
2371   // socket is sitting idle and the first one is released (since ReleaseSocket()
2372   // just posts a DoReleaseSocket() task).
2373
2374   handle.Reset();
2375   EXPECT_EQ(OK, callback2.WaitForResult());
2376   // Use the socket.
2377   EXPECT_EQ(1, handle2.socket()->Write(NULL, 1, CompletionCallback()));
2378   handle2.Reset();
2379
2380   // We post all of our delayed tasks with a 2ms delay. I.e. they don't
2381   // actually become pending until 2ms after they have been created. In order
2382   // to flush all tasks, we need to wait so that we know there are no
2383   // soon-to-be-pending tasks waiting.
2384   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(10));
2385   base::MessageLoop::current()->RunUntilIdle();
2386
2387   ASSERT_EQ(2, pool_->IdleSocketCount());
2388
2389   // Invoke the idle socket cleanup check.  Only one socket should be left, the
2390   // used socket.  Request it to make sure that it's used.
2391
2392   pool_->CleanupTimedOutIdleSockets();
2393   CapturingBoundNetLog log;
2394   rv = handle.Init("a",
2395                    params_,
2396                    LOWEST,
2397                    callback.callback(),
2398                    pool_.get(),
2399                    log.bound());
2400   EXPECT_EQ(OK, rv);
2401   EXPECT_TRUE(handle.is_reused());
2402
2403   CapturingNetLog::CapturedEntryList entries;
2404   log.GetEntries(&entries);
2405   EXPECT_TRUE(LogContainsEntryWithType(
2406       entries, 1, NetLog::TYPE_SOCKET_POOL_REUSED_AN_EXISTING_SOCKET));
2407 }
2408
2409 // Make sure that we process all pending requests even when we're stalling
2410 // because of multiple releasing disconnected sockets.
2411 TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
2412   CreatePoolWithIdleTimeouts(
2413       kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
2414       base::TimeDelta(),  // Time out unused sockets immediately.
2415       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
2416
2417   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2418
2419   // Startup 4 connect jobs.  Two of them will be pending.
2420
2421   ClientSocketHandle handle;
2422   TestCompletionCallback callback;
2423   int rv = handle.Init("a",
2424                        params_,
2425                        LOWEST,
2426                        callback.callback(),
2427                        pool_.get(),
2428                        BoundNetLog());
2429   EXPECT_EQ(OK, rv);
2430
2431   ClientSocketHandle handle2;
2432   TestCompletionCallback callback2;
2433   rv = handle2.Init("a",
2434                     params_,
2435                     LOWEST,
2436                     callback2.callback(),
2437                     pool_.get(),
2438                     BoundNetLog());
2439   EXPECT_EQ(OK, rv);
2440
2441   ClientSocketHandle handle3;
2442   TestCompletionCallback callback3;
2443   rv = handle3.Init("a",
2444                     params_,
2445                     LOWEST,
2446                     callback3.callback(),
2447                     pool_.get(),
2448                     BoundNetLog());
2449   EXPECT_EQ(ERR_IO_PENDING, rv);
2450
2451   ClientSocketHandle handle4;
2452   TestCompletionCallback callback4;
2453   rv = handle4.Init("a",
2454                     params_,
2455                     LOWEST,
2456                     callback4.callback(),
2457                     pool_.get(),
2458                     BoundNetLog());
2459   EXPECT_EQ(ERR_IO_PENDING, rv);
2460
2461   // Release two disconnected sockets.
2462
2463   handle.socket()->Disconnect();
2464   handle.Reset();
2465   handle2.socket()->Disconnect();
2466   handle2.Reset();
2467
2468   EXPECT_EQ(OK, callback3.WaitForResult());
2469   EXPECT_FALSE(handle3.is_reused());
2470   EXPECT_EQ(OK, callback4.WaitForResult());
2471   EXPECT_FALSE(handle4.is_reused());
2472 }
2473
2474 // Regression test for http://crbug.com/42267.
2475 // When DoReleaseSocket() is processed for one socket, it is blocked because the
2476 // other stalled groups all have releasing sockets, so no progress can be made.
2477 TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) {
2478   CreatePoolWithIdleTimeouts(
2479       4 /* socket limit */, 4 /* socket limit per group */,
2480       base::TimeDelta(),  // Time out unused sockets immediately.
2481       base::TimeDelta::FromDays(1));  // Don't time out used sockets.
2482
2483   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2484
2485   // Max out the socket limit with 2 per group.
2486
2487   ClientSocketHandle handle_a[4];
2488   TestCompletionCallback callback_a[4];
2489   ClientSocketHandle handle_b[4];
2490   TestCompletionCallback callback_b[4];
2491
2492   for (int i = 0; i < 2; ++i) {
2493     EXPECT_EQ(OK, handle_a[i].Init("a",
2494                                    params_,
2495                                    LOWEST,
2496                                    callback_a[i].callback(),
2497                                    pool_.get(),
2498                                    BoundNetLog()));
2499     EXPECT_EQ(OK, handle_b[i].Init("b",
2500                                    params_,
2501                                    LOWEST,
2502                                    callback_b[i].callback(),
2503                                    pool_.get(),
2504                                    BoundNetLog()));
2505   }
2506
2507   // Make 4 pending requests, 2 per group.
2508
2509   for (int i = 2; i < 4; ++i) {
2510     EXPECT_EQ(ERR_IO_PENDING,
2511               handle_a[i].Init("a",
2512                                params_,
2513                                LOWEST,
2514                                callback_a[i].callback(),
2515                                pool_.get(),
2516                                BoundNetLog()));
2517     EXPECT_EQ(ERR_IO_PENDING,
2518               handle_b[i].Init("b",
2519                                params_,
2520                                LOWEST,
2521                                callback_b[i].callback(),
2522                                pool_.get(),
2523                                BoundNetLog()));
2524   }
2525
2526   // Release b's socket first.  The order is important, because in
2527   // DoReleaseSocket(), we'll process b's released socket, and since both b and
2528   // a are stalled, but 'a' is lower lexicographically, we'll process group 'a'
2529   // first, which has a releasing socket, so it refuses to start up another
2530   // ConnectJob.  So, we used to infinite loop on this.
2531   handle_b[0].socket()->Disconnect();
2532   handle_b[0].Reset();
2533   handle_a[0].socket()->Disconnect();
2534   handle_a[0].Reset();
2535
2536   // Used to get stuck here.
2537   base::MessageLoop::current()->RunUntilIdle();
2538
2539   handle_b[1].socket()->Disconnect();
2540   handle_b[1].Reset();
2541   handle_a[1].socket()->Disconnect();
2542   handle_a[1].Reset();
2543
2544   for (int i = 2; i < 4; ++i) {
2545     EXPECT_EQ(OK, callback_b[i].WaitForResult());
2546     EXPECT_EQ(OK, callback_a[i].WaitForResult());
2547   }
2548 }
2549
2550 TEST_F(ClientSocketPoolBaseTest,
2551        ReleasingDisconnectedSocketsMaintainsPriorityOrder) {
2552   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2553
2554   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2555
2556   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2557   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2558   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2559   EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", DEFAULT_PRIORITY));
2560
2561   EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
2562   EXPECT_EQ(OK, (*requests())[1]->WaitForResult());
2563   EXPECT_EQ(2u, completion_count());
2564
2565   // Releases one connection.
2566   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
2567   EXPECT_EQ(OK, (*requests())[2]->WaitForResult());
2568
2569   EXPECT_TRUE(ReleaseOneConnection(ClientSocketPoolTest::NO_KEEP_ALIVE));
2570   EXPECT_EQ(OK, (*requests())[3]->WaitForResult());
2571   EXPECT_EQ(4u, completion_count());
2572
2573   EXPECT_EQ(1, GetOrderOfRequest(1));
2574   EXPECT_EQ(2, GetOrderOfRequest(2));
2575   EXPECT_EQ(3, GetOrderOfRequest(3));
2576   EXPECT_EQ(4, GetOrderOfRequest(4));
2577
2578   // Make sure we test order of all requests made.
2579   EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(5));
2580 }
2581
2582 class TestReleasingSocketRequest : public TestCompletionCallbackBase {
2583  public:
2584   TestReleasingSocketRequest(TestClientSocketPool* pool,
2585                              int expected_result,
2586                              bool reset_releasing_handle)
2587       : pool_(pool),
2588         expected_result_(expected_result),
2589         reset_releasing_handle_(reset_releasing_handle),
2590         callback_(base::Bind(&TestReleasingSocketRequest::OnComplete,
2591                              base::Unretained(this))) {
2592   }
2593
2594   virtual ~TestReleasingSocketRequest() {}
2595
2596   ClientSocketHandle* handle() { return &handle_; }
2597
2598   const CompletionCallback& callback() const { return callback_; }
2599
2600  private:
2601   void OnComplete(int result) {
2602     SetResult(result);
2603     if (reset_releasing_handle_)
2604       handle_.Reset();
2605
2606     scoped_refptr<TestSocketParams> con_params(
2607         new TestSocketParams(false /* ignore_limits */));
2608     EXPECT_EQ(expected_result_,
2609               handle2_.Init("a", con_params, DEFAULT_PRIORITY,
2610                             callback2_.callback(), pool_, BoundNetLog()));
2611   }
2612
2613   TestClientSocketPool* const pool_;
2614   int expected_result_;
2615   bool reset_releasing_handle_;
2616   ClientSocketHandle handle_;
2617   ClientSocketHandle handle2_;
2618   CompletionCallback callback_;
2619   TestCompletionCallback callback2_;
2620 };
2621
2622
2623 TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
2624   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2625
2626   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
2627   EXPECT_EQ(OK, StartRequest("a", DEFAULT_PRIORITY));
2628   EXPECT_EQ(OK, StartRequest("b", DEFAULT_PRIORITY));
2629
2630   EXPECT_EQ(static_cast<int>(requests_size()),
2631             client_socket_factory_.allocation_count());
2632
2633   connect_job_factory_->set_job_type(
2634       TestConnectJob::kMockPendingAdditionalErrorStateJob);
2635   TestReleasingSocketRequest req(pool_.get(), OK, false);
2636   EXPECT_EQ(ERR_IO_PENDING,
2637             req.handle()->Init("a", params_, DEFAULT_PRIORITY, req.callback(),
2638                                pool_.get(), BoundNetLog()));
2639   // The next job should complete synchronously
2640   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2641
2642   EXPECT_EQ(ERR_CONNECTION_FAILED, req.WaitForResult());
2643   EXPECT_FALSE(req.handle()->is_initialized());
2644   EXPECT_FALSE(req.handle()->socket());
2645   EXPECT_TRUE(req.handle()->is_ssl_error());
2646   EXPECT_FALSE(req.handle()->ssl_error_response_info().headers.get() == NULL);
2647 }
2648
2649 // http://crbug.com/44724 regression test.
2650 // We start releasing the pool when we flush on network change.  When that
2651 // happens, the only active references are in the ClientSocketHandles.  When a
2652 // ConnectJob completes and calls back into the last ClientSocketHandle, that
2653 // callback can release the last reference and delete the pool.  After the
2654 // callback finishes, we go back to the stack frame within the now-deleted pool.
2655 // Executing any code that refers to members of the now-deleted pool can cause
2656 // crashes.
2657 TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
2658   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2659   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
2660
2661   ClientSocketHandle handle;
2662   TestCompletionCallback callback;
2663   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2664                                         params_,
2665                                         DEFAULT_PRIORITY,
2666                                         callback.callback(),
2667                                         pool_.get(),
2668                                         BoundNetLog()));
2669
2670   pool_->FlushWithError(ERR_NETWORK_CHANGED);
2671
2672   // We'll call back into this now.
2673   callback.WaitForResult();
2674 }
2675
2676 TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
2677   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2678   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2679
2680   ClientSocketHandle handle;
2681   TestCompletionCallback callback;
2682   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2683                                         params_,
2684                                         DEFAULT_PRIORITY,
2685                                         callback.callback(),
2686                                         pool_.get(),
2687                                         BoundNetLog()));
2688   EXPECT_EQ(OK, callback.WaitForResult());
2689   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
2690
2691   pool_->FlushWithError(ERR_NETWORK_CHANGED);
2692
2693   handle.Reset();
2694   base::MessageLoop::current()->RunUntilIdle();
2695
2696   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2697                                         params_,
2698                                         DEFAULT_PRIORITY,
2699                                         callback.callback(),
2700                                         pool_.get(),
2701                                         BoundNetLog()));
2702   EXPECT_EQ(OK, callback.WaitForResult());
2703   EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
2704 }
2705
2706 class ConnectWithinCallback : public TestCompletionCallbackBase {
2707  public:
2708   ConnectWithinCallback(
2709       const std::string& group_name,
2710       const scoped_refptr<TestSocketParams>& params,
2711       TestClientSocketPool* pool)
2712       : group_name_(group_name),
2713         params_(params),
2714         pool_(pool),
2715         callback_(base::Bind(&ConnectWithinCallback::OnComplete,
2716                              base::Unretained(this))) {
2717   }
2718
2719   virtual ~ConnectWithinCallback() {}
2720
2721   int WaitForNestedResult() {
2722     return nested_callback_.WaitForResult();
2723   }
2724
2725   const CompletionCallback& callback() const { return callback_; }
2726
2727  private:
2728   void OnComplete(int result) {
2729     SetResult(result);
2730     EXPECT_EQ(ERR_IO_PENDING,
2731               handle_.Init(group_name_,
2732                            params_,
2733                            DEFAULT_PRIORITY,
2734                            nested_callback_.callback(),
2735                            pool_,
2736                            BoundNetLog()));
2737   }
2738
2739   const std::string group_name_;
2740   const scoped_refptr<TestSocketParams> params_;
2741   TestClientSocketPool* const pool_;
2742   ClientSocketHandle handle_;
2743   CompletionCallback callback_;
2744   TestCompletionCallback nested_callback_;
2745
2746   DISALLOW_COPY_AND_ASSIGN(ConnectWithinCallback);
2747 };
2748
2749 TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
2750   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2751
2752   // First job will be waiting until it gets aborted.
2753   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2754
2755   ClientSocketHandle handle;
2756   ConnectWithinCallback callback("a", params_, pool_.get());
2757   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
2758                                         params_,
2759                                         DEFAULT_PRIORITY,
2760                                         callback.callback(),
2761                                         pool_.get(),
2762                                         BoundNetLog()));
2763
2764   // Second job will be started during the first callback, and will
2765   // asynchronously complete with OK.
2766   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2767   pool_->FlushWithError(ERR_NETWORK_CHANGED);
2768   EXPECT_EQ(ERR_NETWORK_CHANGED, callback.WaitForResult());
2769   EXPECT_EQ(OK, callback.WaitForNestedResult());
2770 }
2771
2772 // Cancel a pending socket request while we're at max sockets,
2773 // and verify that the backup socket firing doesn't cause a crash.
2774 TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
2775   // Max 4 sockets globally, max 4 sockets per group.
2776   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2777   pool_->EnableConnectBackupJobs();
2778
2779   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
2780   // timer.
2781   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2782   ClientSocketHandle handle;
2783   TestCompletionCallback callback;
2784   EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
2785                                         params_,
2786                                         DEFAULT_PRIORITY,
2787                                         callback.callback(),
2788                                         pool_.get(),
2789                                         BoundNetLog()));
2790
2791   // Start (MaxSockets - 1) connected sockets to reach max sockets.
2792   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
2793   ClientSocketHandle handles[kDefaultMaxSockets];
2794   for (int i = 1; i < kDefaultMaxSockets; ++i) {
2795     TestCompletionCallback callback;
2796     EXPECT_EQ(OK, handles[i].Init("bar",
2797                                   params_,
2798                                   DEFAULT_PRIORITY,
2799                                   callback.callback(),
2800                                   pool_.get(),
2801                                   BoundNetLog()));
2802   }
2803
2804   base::MessageLoop::current()->RunUntilIdle();
2805
2806   // Cancel the pending request.
2807   handle.Reset();
2808
2809   // Wait for the backup timer to fire (add some slop to ensure it fires)
2810   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2811       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2812
2813   base::MessageLoop::current()->RunUntilIdle();
2814   EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
2815 }
2816
2817 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
2818   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2819   pool_->EnableConnectBackupJobs();
2820
2821   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
2822   // timer.
2823   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2824   ClientSocketHandle handle;
2825   TestCompletionCallback callback;
2826   EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
2827                                         params_,
2828                                         DEFAULT_PRIORITY,
2829                                         callback.callback(),
2830                                         pool_.get(),
2831                                         BoundNetLog()));
2832   ASSERT_TRUE(pool_->HasGroup("bar"));
2833   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
2834   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar"));
2835
2836   // Cancel the socket request.  This should cancel the backup timer.  Wait for
2837   // the backup time to see if it indeed got canceled.
2838   handle.Reset();
2839   // Wait for the backup timer to fire (add some slop to ensure it fires)
2840   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2841       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2842   base::MessageLoop::current()->RunUntilIdle();
2843   ASSERT_TRUE(pool_->HasGroup("bar"));
2844   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
2845 }
2846
2847 TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
2848   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
2849   pool_->EnableConnectBackupJobs();
2850
2851   // Create the first socket and set to ERR_IO_PENDING.  This starts the backup
2852   // timer.
2853   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2854   ClientSocketHandle handle;
2855   TestCompletionCallback callback;
2856   EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
2857                                         params_,
2858                                         DEFAULT_PRIORITY,
2859                                         callback.callback(),
2860                                         pool_.get(),
2861                                         BoundNetLog()));
2862   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2863   ClientSocketHandle handle2;
2864   TestCompletionCallback callback2;
2865   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar",
2866                                          params_,
2867                                          DEFAULT_PRIORITY,
2868                                          callback2.callback(),
2869                                          pool_.get(),
2870                                          BoundNetLog()));
2871   ASSERT_TRUE(pool_->HasGroup("bar"));
2872   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
2873
2874   // Cancel request 1 and then complete request 2.  With the requests finished,
2875   // the backup timer should be cancelled.
2876   handle.Reset();
2877   EXPECT_EQ(OK, callback2.WaitForResult());
2878   // Wait for the backup timer to fire (add some slop to ensure it fires)
2879   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
2880       ClientSocketPool::kMaxConnectRetryIntervalMs / 2 * 3));
2881   base::MessageLoop::current()->RunUntilIdle();
2882 }
2883
2884 // Test delayed socket binding for the case where we have two connects,
2885 // and while one is waiting on a connect, the other frees up.
2886 // The socket waiting on a connect should switch immediately to the freed
2887 // up socket.
2888 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingWaitingForConnect) {
2889   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2890   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2891
2892   ClientSocketHandle handle1;
2893   TestCompletionCallback callback;
2894   EXPECT_EQ(ERR_IO_PENDING,
2895             handle1.Init("a",
2896                          params_,
2897                          DEFAULT_PRIORITY,
2898                          callback.callback(),
2899                          pool_.get(),
2900                          BoundNetLog()));
2901   EXPECT_EQ(OK, callback.WaitForResult());
2902
2903   // No idle sockets, no pending jobs.
2904   EXPECT_EQ(0, pool_->IdleSocketCount());
2905   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2906
2907   // Create a second socket to the same host, but this one will wait.
2908   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2909   ClientSocketHandle handle2;
2910   EXPECT_EQ(ERR_IO_PENDING,
2911             handle2.Init("a",
2912                          params_,
2913                          DEFAULT_PRIORITY,
2914                          callback.callback(),
2915                          pool_.get(),
2916                          BoundNetLog()));
2917   // No idle sockets, and one connecting job.
2918   EXPECT_EQ(0, pool_->IdleSocketCount());
2919   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2920
2921   // Return the first handle to the pool.  This will initiate the delayed
2922   // binding.
2923   handle1.Reset();
2924
2925   base::MessageLoop::current()->RunUntilIdle();
2926
2927   // Still no idle sockets, still one pending connect job.
2928   EXPECT_EQ(0, pool_->IdleSocketCount());
2929   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2930
2931   // The second socket connected, even though it was a Waiting Job.
2932   EXPECT_EQ(OK, callback.WaitForResult());
2933
2934   // And we can see there is still one job waiting.
2935   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2936
2937   // Finally, signal the waiting Connect.
2938   client_socket_factory_.SignalJobs();
2939   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2940
2941   base::MessageLoop::current()->RunUntilIdle();
2942 }
2943
2944 // Test delayed socket binding when a group is at capacity and one
2945 // of the group's sockets frees up.
2946 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtGroupCapacity) {
2947   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
2948   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
2949
2950   ClientSocketHandle handle1;
2951   TestCompletionCallback callback;
2952   EXPECT_EQ(ERR_IO_PENDING,
2953             handle1.Init("a",
2954                          params_,
2955                          DEFAULT_PRIORITY,
2956                          callback.callback(),
2957                          pool_.get(),
2958                          BoundNetLog()));
2959   EXPECT_EQ(OK, callback.WaitForResult());
2960
2961   // No idle sockets, no pending jobs.
2962   EXPECT_EQ(0, pool_->IdleSocketCount());
2963   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2964
2965   // Create a second socket to the same host, but this one will wait.
2966   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
2967   ClientSocketHandle handle2;
2968   EXPECT_EQ(ERR_IO_PENDING,
2969             handle2.Init("a",
2970                          params_,
2971                          DEFAULT_PRIORITY,
2972                          callback.callback(),
2973                          pool_.get(),
2974                          BoundNetLog()));
2975   // No idle sockets, and one connecting job.
2976   EXPECT_EQ(0, pool_->IdleSocketCount());
2977   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2978
2979   // Return the first handle to the pool.  This will initiate the delayed
2980   // binding.
2981   handle1.Reset();
2982
2983   base::MessageLoop::current()->RunUntilIdle();
2984
2985   // Still no idle sockets, still one pending connect job.
2986   EXPECT_EQ(0, pool_->IdleSocketCount());
2987   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2988
2989   // The second socket connected, even though it was a Waiting Job.
2990   EXPECT_EQ(OK, callback.WaitForResult());
2991
2992   // And we can see there is still one job waiting.
2993   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
2994
2995   // Finally, signal the waiting Connect.
2996   client_socket_factory_.SignalJobs();
2997   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
2998
2999   base::MessageLoop::current()->RunUntilIdle();
3000 }
3001
3002 // Test out the case where we have one socket connected, one
3003 // connecting, when the first socket finishes and goes idle.
3004 // Although the second connection is pending, the second request
3005 // should complete, by taking the first socket's idle socket.
3006 TEST_F(ClientSocketPoolBaseTest, DelayedSocketBindingAtStall) {
3007   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3008   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3009
3010   ClientSocketHandle handle1;
3011   TestCompletionCallback callback;
3012   EXPECT_EQ(ERR_IO_PENDING,
3013             handle1.Init("a",
3014                          params_,
3015                          DEFAULT_PRIORITY,
3016                          callback.callback(),
3017                          pool_.get(),
3018                          BoundNetLog()));
3019   EXPECT_EQ(OK, callback.WaitForResult());
3020
3021   // No idle sockets, no pending jobs.
3022   EXPECT_EQ(0, pool_->IdleSocketCount());
3023   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3024
3025   // Create a second socket to the same host, but this one will wait.
3026   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3027   ClientSocketHandle handle2;
3028   EXPECT_EQ(ERR_IO_PENDING,
3029             handle2.Init("a",
3030                          params_,
3031                          DEFAULT_PRIORITY,
3032                          callback.callback(),
3033                          pool_.get(),
3034                          BoundNetLog()));
3035   // No idle sockets, and one connecting job.
3036   EXPECT_EQ(0, pool_->IdleSocketCount());
3037   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3038
3039   // Return the first handle to the pool.  This will initiate the delayed
3040   // binding.
3041   handle1.Reset();
3042
3043   base::MessageLoop::current()->RunUntilIdle();
3044
3045   // Still no idle sockets, still one pending connect job.
3046   EXPECT_EQ(0, pool_->IdleSocketCount());
3047   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3048
3049   // The second socket connected, even though it was a Waiting Job.
3050   EXPECT_EQ(OK, callback.WaitForResult());
3051
3052   // And we can see there is still one job waiting.
3053   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3054
3055   // Finally, signal the waiting Connect.
3056   client_socket_factory_.SignalJobs();
3057   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3058
3059   base::MessageLoop::current()->RunUntilIdle();
3060 }
3061
3062 // Cover the case where on an available socket slot, we have one pending
3063 // request that completes synchronously, thereby making the Group empty.
3064 TEST_F(ClientSocketPoolBaseTest, SynchronouslyProcessOnePendingRequest) {
3065   const int kUnlimitedSockets = 100;
3066   const int kOneSocketPerGroup = 1;
3067   CreatePool(kUnlimitedSockets, kOneSocketPerGroup);
3068
3069   // Make the first request asynchronous fail.
3070   // This will free up a socket slot later.
3071   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
3072
3073   ClientSocketHandle handle1;
3074   TestCompletionCallback callback1;
3075   EXPECT_EQ(ERR_IO_PENDING,
3076             handle1.Init("a",
3077                          params_,
3078                          DEFAULT_PRIORITY,
3079                          callback1.callback(),
3080                          pool_.get(),
3081                          BoundNetLog()));
3082   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3083
3084   // Make the second request synchronously fail.  This should make the Group
3085   // empty.
3086   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3087   ClientSocketHandle handle2;
3088   TestCompletionCallback callback2;
3089   // It'll be ERR_IO_PENDING now, but the TestConnectJob will synchronously fail
3090   // when created.
3091   EXPECT_EQ(ERR_IO_PENDING,
3092             handle2.Init("a",
3093                          params_,
3094                          DEFAULT_PRIORITY,
3095                          callback2.callback(),
3096                          pool_.get(),
3097                          BoundNetLog()));
3098
3099   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3100
3101   EXPECT_EQ(ERR_CONNECTION_FAILED, callback1.WaitForResult());
3102   EXPECT_EQ(ERR_CONNECTION_FAILED, callback2.WaitForResult());
3103   EXPECT_FALSE(pool_->HasGroup("a"));
3104 }
3105
3106 TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
3107   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3108
3109   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3110
3111   ClientSocketHandle handle1;
3112   TestCompletionCallback callback1;
3113   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3114                                          params_,
3115                                          DEFAULT_PRIORITY,
3116                                          callback1.callback(),
3117                                          pool_.get(),
3118                                          BoundNetLog()));
3119
3120   ClientSocketHandle handle2;
3121   TestCompletionCallback callback2;
3122   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3123                                          params_,
3124                                          DEFAULT_PRIORITY,
3125                                          callback2.callback(),
3126                                          pool_.get(),
3127                                          BoundNetLog()));
3128   ClientSocketHandle handle3;
3129   TestCompletionCallback callback3;
3130   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
3131                                          params_,
3132                                          DEFAULT_PRIORITY,
3133                                          callback3.callback(),
3134                                          pool_.get(),
3135                                          BoundNetLog()));
3136
3137   EXPECT_EQ(OK, callback1.WaitForResult());
3138   EXPECT_EQ(OK, callback2.WaitForResult());
3139   EXPECT_EQ(OK, callback3.WaitForResult());
3140
3141   // Use the socket.
3142   EXPECT_EQ(1, handle1.socket()->Write(NULL, 1, CompletionCallback()));
3143   EXPECT_EQ(1, handle3.socket()->Write(NULL, 1, CompletionCallback()));
3144
3145   handle1.Reset();
3146   handle2.Reset();
3147   handle3.Reset();
3148
3149   EXPECT_EQ(OK, handle1.Init("a",
3150                              params_,
3151                              DEFAULT_PRIORITY,
3152                              callback1.callback(),
3153                              pool_.get(),
3154                              BoundNetLog()));
3155   EXPECT_EQ(OK, handle2.Init("a",
3156                              params_,
3157                              DEFAULT_PRIORITY,
3158                              callback2.callback(),
3159                              pool_.get(),
3160                              BoundNetLog()));
3161   EXPECT_EQ(OK, handle3.Init("a",
3162                              params_,
3163                              DEFAULT_PRIORITY,
3164                              callback3.callback(),
3165                              pool_.get(),
3166                              BoundNetLog()));
3167
3168   EXPECT_TRUE(handle1.socket()->WasEverUsed());
3169   EXPECT_TRUE(handle2.socket()->WasEverUsed());
3170   EXPECT_FALSE(handle3.socket()->WasEverUsed());
3171 }
3172
3173 TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
3174   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3175   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3176
3177   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3178
3179   ASSERT_TRUE(pool_->HasGroup("a"));
3180   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3181   EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3182   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3183
3184   ClientSocketHandle handle1;
3185   TestCompletionCallback callback1;
3186   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3187                                          params_,
3188                                          DEFAULT_PRIORITY,
3189                                          callback1.callback(),
3190                                          pool_.get(),
3191                                          BoundNetLog()));
3192
3193   ClientSocketHandle handle2;
3194   TestCompletionCallback callback2;
3195   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3196                                          params_,
3197                                          DEFAULT_PRIORITY,
3198                                          callback2.callback(),
3199                                          pool_.get(),
3200                                          BoundNetLog()));
3201
3202   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3203   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3204   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3205
3206   EXPECT_EQ(OK, callback1.WaitForResult());
3207   EXPECT_EQ(OK, callback2.WaitForResult());
3208   handle1.Reset();
3209   handle2.Reset();
3210
3211   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3212   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3213   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3214 }
3215
3216 TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
3217   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3218   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3219
3220   ClientSocketHandle handle1;
3221   TestCompletionCallback callback1;
3222   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3223                                          params_,
3224                                          DEFAULT_PRIORITY,
3225                                          callback1.callback(),
3226                                          pool_.get(),
3227                                          BoundNetLog()));
3228
3229   ASSERT_TRUE(pool_->HasGroup("a"));
3230   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3231   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3232   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3233
3234   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3235
3236   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3237   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3238   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3239
3240   ClientSocketHandle handle2;
3241   TestCompletionCallback callback2;
3242   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3243                                          params_,
3244                                          DEFAULT_PRIORITY,
3245                                          callback2.callback(),
3246                                          pool_.get(),
3247                                          BoundNetLog()));
3248
3249   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3250   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3251   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3252
3253   EXPECT_EQ(OK, callback1.WaitForResult());
3254   EXPECT_EQ(OK, callback2.WaitForResult());
3255   handle1.Reset();
3256   handle2.Reset();
3257
3258   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3259   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3260   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3261 }
3262
3263 TEST_F(ClientSocketPoolBaseTest,
3264        RequestSocketsWhenAlreadyHaveMultipleConnectJob) {
3265   CreatePool(4, 4);
3266   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3267
3268   ClientSocketHandle handle1;
3269   TestCompletionCallback callback1;
3270   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3271                                          params_,
3272                                          DEFAULT_PRIORITY,
3273                                          callback1.callback(),
3274                                          pool_.get(),
3275                                          BoundNetLog()));
3276
3277   ClientSocketHandle handle2;
3278   TestCompletionCallback callback2;
3279   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
3280                                          params_,
3281                                          DEFAULT_PRIORITY,
3282                                          callback2.callback(),
3283                                          pool_.get(),
3284                                          BoundNetLog()));
3285
3286   ClientSocketHandle handle3;
3287   TestCompletionCallback callback3;
3288   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
3289                                          params_,
3290                                          DEFAULT_PRIORITY,
3291                                          callback3.callback(),
3292                                          pool_.get(),
3293                                          BoundNetLog()));
3294
3295   ASSERT_TRUE(pool_->HasGroup("a"));
3296   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3297   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3298   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3299
3300   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3301
3302   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3303   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3304   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3305
3306   EXPECT_EQ(OK, callback1.WaitForResult());
3307   EXPECT_EQ(OK, callback2.WaitForResult());
3308   EXPECT_EQ(OK, callback3.WaitForResult());
3309   handle1.Reset();
3310   handle2.Reset();
3311   handle3.Reset();
3312
3313   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3314   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3315   EXPECT_EQ(3, pool_->IdleSocketCountInGroup("a"));
3316 }
3317
3318 TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
3319   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3320   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3321
3322   ASSERT_FALSE(pool_->HasGroup("a"));
3323
3324   pool_->RequestSockets("a", &params_, kDefaultMaxSockets,
3325                         BoundNetLog());
3326
3327   ASSERT_TRUE(pool_->HasGroup("a"));
3328   EXPECT_EQ(kDefaultMaxSockets, pool_->NumConnectJobsInGroup("a"));
3329   EXPECT_EQ(kDefaultMaxSockets, pool_->NumUnassignedConnectJobsInGroup("a"));
3330
3331   ASSERT_FALSE(pool_->HasGroup("b"));
3332
3333   pool_->RequestSockets("b", &params_, kDefaultMaxSockets,
3334                         BoundNetLog());
3335
3336   ASSERT_FALSE(pool_->HasGroup("b"));
3337 }
3338
3339 TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
3340   CreatePool(kDefaultMaxSockets, kDefaultMaxSockets);
3341   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3342
3343   ASSERT_FALSE(pool_->HasGroup("a"));
3344
3345   pool_->RequestSockets("a", &params_, kDefaultMaxSockets - 1,
3346                         BoundNetLog());
3347
3348   ASSERT_TRUE(pool_->HasGroup("a"));
3349   EXPECT_EQ(kDefaultMaxSockets - 1, pool_->NumConnectJobsInGroup("a"));
3350   EXPECT_EQ(kDefaultMaxSockets - 1,
3351             pool_->NumUnassignedConnectJobsInGroup("a"));
3352   EXPECT_FALSE(pool_->IsStalled());
3353
3354   ASSERT_FALSE(pool_->HasGroup("b"));
3355
3356   pool_->RequestSockets("b", &params_, kDefaultMaxSockets,
3357                         BoundNetLog());
3358
3359   ASSERT_TRUE(pool_->HasGroup("b"));
3360   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b"));
3361   EXPECT_FALSE(pool_->IsStalled());
3362 }
3363
3364 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
3365   CreatePool(4, 4);
3366   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3367
3368   ClientSocketHandle handle1;
3369   TestCompletionCallback callback1;
3370   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3371                                          params_,
3372                                          DEFAULT_PRIORITY,
3373                                          callback1.callback(),
3374                                          pool_.get(),
3375                                          BoundNetLog()));
3376   ASSERT_EQ(OK, callback1.WaitForResult());
3377   handle1.Reset();
3378
3379   ASSERT_TRUE(pool_->HasGroup("a"));
3380   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3381   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3382   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3383
3384   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3385
3386   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3387   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3388   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3389 }
3390
3391 TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
3392   CreatePool(4, 4);
3393   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3394
3395   ClientSocketHandle handle1;
3396   TestCompletionCallback callback1;
3397   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3398                                          params_,
3399                                          DEFAULT_PRIORITY,
3400                                          callback1.callback(),
3401                                          pool_.get(),
3402                                          BoundNetLog()));
3403   ASSERT_EQ(OK, callback1.WaitForResult());
3404
3405   ASSERT_TRUE(pool_->HasGroup("a"));
3406   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3407   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3408   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3409   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3410
3411   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3412
3413   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3414   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3415   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3416   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3417 }
3418
3419 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
3420   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3421   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3422
3423   pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3424                         BoundNetLog());
3425
3426   ASSERT_TRUE(pool_->HasGroup("a"));
3427   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3428   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3429   EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("a"));
3430
3431   pool_->RequestSockets("b", &params_, kDefaultMaxSocketsPerGroup,
3432                         BoundNetLog());
3433
3434   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3435   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3436   EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("b"));
3437 }
3438
3439 TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronousError) {
3440   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3441   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3442
3443   pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3444                         BoundNetLog());
3445
3446   ASSERT_FALSE(pool_->HasGroup("a"));
3447
3448   connect_job_factory_->set_job_type(
3449       TestConnectJob::kMockAdditionalErrorStateJob);
3450   pool_->RequestSockets("a", &params_, kDefaultMaxSocketsPerGroup,
3451                         BoundNetLog());
3452
3453   ASSERT_FALSE(pool_->HasGroup("a"));
3454 }
3455
3456 TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
3457   CreatePool(4, 4);
3458   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3459
3460   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3461
3462   ASSERT_TRUE(pool_->HasGroup("a"));
3463   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3464   EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3465   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3466
3467   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3468   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3469   EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3470   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3471
3472   ClientSocketHandle handle1;
3473   TestCompletionCallback callback1;
3474   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3475                                          params_,
3476                                          DEFAULT_PRIORITY,
3477                                          callback1.callback(),
3478                                          pool_.get(),
3479                                          BoundNetLog()));
3480   ASSERT_EQ(OK, callback1.WaitForResult());
3481
3482   ClientSocketHandle handle2;
3483   TestCompletionCallback callback2;
3484   int rv = handle2.Init("a",
3485                         params_,
3486                         DEFAULT_PRIORITY,
3487                         callback2.callback(),
3488                         pool_.get(),
3489                         BoundNetLog());
3490   if (rv != OK) {
3491     EXPECT_EQ(ERR_IO_PENDING, rv);
3492     EXPECT_EQ(OK, callback2.WaitForResult());
3493   }
3494
3495   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3496   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3497   EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("a"));
3498   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3499
3500   handle1.Reset();
3501   handle2.Reset();
3502
3503   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3504   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3505   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3506
3507   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3508   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3509   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3510   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("a"));
3511 }
3512
3513 TEST_F(ClientSocketPoolBaseTest, RequestSocketsDifferentNumSockets) {
3514   CreatePool(4, 4);
3515   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3516
3517   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3518
3519   ASSERT_TRUE(pool_->HasGroup("a"));
3520   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3521   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3522   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3523
3524   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3525   EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
3526   EXPECT_EQ(2, pool_->NumUnassignedConnectJobsInGroup("a"));
3527   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3528
3529   pool_->RequestSockets("a", &params_, 3, BoundNetLog());
3530   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3531   EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
3532   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3533
3534   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3535   EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
3536   EXPECT_EQ(3, pool_->NumUnassignedConnectJobsInGroup("a"));
3537   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3538 }
3539
3540 TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
3541   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3542   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3543
3544   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3545
3546   ASSERT_TRUE(pool_->HasGroup("a"));
3547   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3548   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3549   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3550
3551   ClientSocketHandle handle1;
3552   TestCompletionCallback callback1;
3553   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3554                                          params_,
3555                                          DEFAULT_PRIORITY,
3556                                          callback1.callback(),
3557                                          pool_.get(),
3558                                          BoundNetLog()));
3559
3560   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3561   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3562   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3563
3564   ASSERT_EQ(OK, callback1.WaitForResult());
3565
3566   // Make sure if a preconnected socket is not fully connected when a request
3567   // starts, it has a connect start time.
3568   TestLoadTimingInfoConnectedNotReused(handle1);
3569   handle1.Reset();
3570
3571   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3572 }
3573
3574 // Checks that fully connected preconnect jobs have no connect times, and are
3575 // marked as reused.
3576 TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
3577   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3578   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3579   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3580
3581   ASSERT_TRUE(pool_->HasGroup("a"));
3582   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3583   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3584   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3585
3586   ClientSocketHandle handle;
3587   TestCompletionCallback callback;
3588   EXPECT_EQ(OK, handle.Init("a",
3589                             params_,
3590                             DEFAULT_PRIORITY,
3591                             callback.callback(),
3592                             pool_.get(),
3593                             BoundNetLog()));
3594
3595   // Make sure the idle socket was used.
3596   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3597
3598   TestLoadTimingInfoConnectedReused(handle);
3599   handle.Reset();
3600   TestLoadTimingInfoNotConnected(handle);
3601 }
3602
3603 // http://crbug.com/64940 regression test.
3604 TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
3605   const int kMaxTotalSockets = 3;
3606   const int kMaxSocketsPerGroup = 2;
3607   CreatePool(kMaxTotalSockets, kMaxSocketsPerGroup);
3608   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3609
3610   // Note that group name ordering matters here.  "a" comes before "b", so
3611   // CloseOneIdleSocket() will try to close "a"'s idle socket.
3612
3613   // Set up one idle socket in "a".
3614   ClientSocketHandle handle1;
3615   TestCompletionCallback callback1;
3616   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
3617                                          params_,
3618                                          DEFAULT_PRIORITY,
3619                                          callback1.callback(),
3620                                          pool_.get(),
3621                                          BoundNetLog()));
3622
3623   ASSERT_EQ(OK, callback1.WaitForResult());
3624   handle1.Reset();
3625   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3626
3627   // Set up two active sockets in "b".
3628   ClientSocketHandle handle2;
3629   TestCompletionCallback callback2;
3630   EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b",
3631                                          params_,
3632                                          DEFAULT_PRIORITY,
3633                                          callback1.callback(),
3634                                          pool_.get(),
3635                                          BoundNetLog()));
3636   EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b",
3637                                          params_,
3638                                          DEFAULT_PRIORITY,
3639                                          callback2.callback(),
3640                                          pool_.get(),
3641                                          BoundNetLog()));
3642
3643   ASSERT_EQ(OK, callback1.WaitForResult());
3644   ASSERT_EQ(OK, callback2.WaitForResult());
3645   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
3646   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3647   EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
3648
3649   // Now we have 1 idle socket in "a" and 2 active sockets in "b".  This means
3650   // we've maxed out on sockets, since we set |kMaxTotalSockets| to 3.
3651   // Requesting 2 preconnected sockets for "a" should fail to allocate any more
3652   // sockets for "a", and "b" should still have 2 active sockets.
3653
3654   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3655   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3656   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3657   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3658   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3659   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3660   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3661   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("b"));
3662   EXPECT_EQ(2, pool_->NumActiveSocketsInGroup("b"));
3663
3664   // Now release the 2 active sockets for "b".  This will give us 1 idle socket
3665   // in "a" and 2 idle sockets in "b".  Requesting 2 preconnected sockets for
3666   // "a" should result in closing 1 for "b".
3667   handle1.Reset();
3668   handle2.Reset();
3669   EXPECT_EQ(2, pool_->IdleSocketCountInGroup("b"));
3670   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
3671
3672   pool_->RequestSockets("a", &params_, 2, BoundNetLog());
3673   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3674   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3675   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3676   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3677   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
3678   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
3679   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("b"));
3680   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("b"));
3681 }
3682
3683 TEST_F(ClientSocketPoolBaseTest, PreconnectWithoutBackupJob) {
3684   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3685   pool_->EnableConnectBackupJobs();
3686
3687   // Make the ConnectJob hang until it times out, shorten the timeout.
3688   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3689   connect_job_factory_->set_timeout_duration(
3690       base::TimeDelta::FromMilliseconds(500));
3691   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3692   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3693   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3694   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3695
3696   // Verify the backup timer doesn't create a backup job, by making
3697   // the backup job a pending job instead of a waiting job, so it
3698   // *would* complete if it were created.
3699   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3700   base::MessageLoop::current()->PostDelayedTask(
3701       FROM_HERE,
3702       base::MessageLoop::QuitClosure(),
3703       base::TimeDelta::FromSeconds(1));
3704   base::MessageLoop::current()->Run();
3705   EXPECT_FALSE(pool_->HasGroup("a"));
3706 }
3707
3708 TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
3709   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3710   pool_->EnableConnectBackupJobs();
3711
3712   // Make the ConnectJob hang forever.
3713   connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
3714   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3715   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3716   EXPECT_EQ(1, pool_->NumUnassignedConnectJobsInGroup("a"));
3717   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3718   base::MessageLoop::current()->RunUntilIdle();
3719
3720   // Make the backup job be a pending job, so it completes normally.
3721   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
3722   ClientSocketHandle handle;
3723   TestCompletionCallback callback;
3724   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
3725                                         params_,
3726                                         DEFAULT_PRIORITY,
3727                                         callback.callback(),
3728                                         pool_.get(),
3729                                         BoundNetLog()));
3730   // Timer has started, but the backup connect job shouldn't be created yet.
3731   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3732   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3733   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3734   EXPECT_EQ(0, pool_->NumActiveSocketsInGroup("a"));
3735   ASSERT_EQ(OK, callback.WaitForResult());
3736
3737   // The hung connect job should still be there, but everything else should be
3738   // complete.
3739   EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
3740   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3741   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3742   EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
3743 }
3744
3745 // Tests that a preconnect that starts out with unread data can still be used.
3746 // http://crbug.com/334467
3747 TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
3748   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3749   connect_job_factory_->set_job_type(TestConnectJob::kMockUnreadDataJob);
3750
3751   pool_->RequestSockets("a", &params_, 1, BoundNetLog());
3752
3753   ASSERT_TRUE(pool_->HasGroup("a"));
3754   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3755   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3756   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3757
3758   // Fail future jobs to be sure that handle receives the preconnected socket
3759   // rather than closing it and making a new one.
3760   connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
3761   ClientSocketHandle handle;
3762   TestCompletionCallback callback;
3763   EXPECT_EQ(OK, handle.Init("a",
3764                              params_,
3765                              DEFAULT_PRIORITY,
3766                              callback.callback(),
3767                              pool_.get(),
3768                              BoundNetLog()));
3769
3770   ASSERT_TRUE(pool_->HasGroup("a"));
3771   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
3772   EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
3773   EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
3774
3775   // Drain the pending read.
3776   EXPECT_EQ(1, handle.socket()->Read(NULL, 1, CompletionCallback()));
3777
3778   TestLoadTimingInfoConnectedReused(handle);
3779   handle.Reset();
3780
3781   // The socket should be usable now that it's idle again.
3782   EXPECT_EQ(1, pool_->IdleSocketCountInGroup("a"));
3783 }
3784
3785 class MockLayeredPool : public HigherLayeredPool {
3786  public:
3787   MockLayeredPool(TestClientSocketPool* pool,
3788                   const std::string& group_name)
3789       : pool_(pool),
3790         group_name_(group_name),
3791         can_release_connection_(true) {
3792     pool_->AddHigherLayeredPool(this);
3793   }
3794
3795   ~MockLayeredPool() {
3796     pool_->RemoveHigherLayeredPool(this);
3797   }
3798
3799   int RequestSocket(TestClientSocketPool* pool) {
3800     scoped_refptr<TestSocketParams> params(
3801         new TestSocketParams(false /* ignore_limits */));
3802     return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
3803                         callback_.callback(), pool, BoundNetLog());
3804   }
3805
3806   int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
3807     scoped_refptr<TestSocketParams> params(
3808         new TestSocketParams(true /* ignore_limits */));
3809     return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
3810                         callback_.callback(), pool, BoundNetLog());
3811   }
3812
3813   bool ReleaseOneConnection() {
3814     if (!handle_.is_initialized() || !can_release_connection_) {
3815       return false;
3816     }
3817     handle_.socket()->Disconnect();
3818     handle_.Reset();
3819     return true;
3820   }
3821
3822   void set_can_release_connection(bool can_release_connection) {
3823     can_release_connection_ = can_release_connection;
3824   }
3825
3826   MOCK_METHOD0(CloseOneIdleConnection, bool());
3827
3828  private:
3829   TestClientSocketPool* const pool_;
3830   ClientSocketHandle handle_;
3831   TestCompletionCallback callback_;
3832   const std::string group_name_;
3833   bool can_release_connection_;
3834 };
3835
3836 TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) {
3837   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3838   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3839
3840   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
3841   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3842   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3843       .WillOnce(Return(false));
3844   EXPECT_FALSE(pool_->CloseOneIdleConnectionInHigherLayeredPool());
3845 }
3846
3847 TEST_F(ClientSocketPoolBaseTest, ForciblyCloseIdleSocketsHeldByLayeredPool) {
3848   CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
3849   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3850
3851   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
3852   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3853   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3854       .WillOnce(Invoke(&mock_layered_pool,
3855                        &MockLayeredPool::ReleaseOneConnection));
3856   EXPECT_TRUE(pool_->CloseOneIdleConnectionInHigherLayeredPool());
3857 }
3858
3859 // Tests the basic case of closing an idle socket in a higher layered pool when
3860 // a new request is issued and the lower layer pool is stalled.
3861 TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
3862   CreatePool(1, 1);
3863   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3864
3865   MockLayeredPool mock_layered_pool(pool_.get(), "foo");
3866   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3867   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3868       .WillOnce(Invoke(&mock_layered_pool,
3869                        &MockLayeredPool::ReleaseOneConnection));
3870   ClientSocketHandle handle;
3871   TestCompletionCallback callback;
3872   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
3873                                         params_,
3874                                         DEFAULT_PRIORITY,
3875                                         callback.callback(),
3876                                         pool_.get(),
3877                                         BoundNetLog()));
3878   EXPECT_EQ(OK, callback.WaitForResult());
3879 }
3880
3881 // Same as above, but the idle socket is in the same group as the stalled
3882 // socket, and closes the only other request in its group when closing requests
3883 // in higher layered pools.  This generally shouldn't happen, but it may be
3884 // possible if a higher level pool issues a request and the request is
3885 // subsequently cancelled.  Even if it's not possible, best not to crash.
3886 TEST_F(ClientSocketPoolBaseTest,
3887        CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) {
3888   CreatePool(2, 2);
3889   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
3890
3891   // Need a socket in another group for the pool to be stalled (If a group
3892   // has the maximum number of connections already, it's not stalled).
3893   ClientSocketHandle handle1;
3894   TestCompletionCallback callback1;
3895   EXPECT_EQ(OK, handle1.Init("group1",
3896                              params_,
3897                              DEFAULT_PRIORITY,
3898                              callback1.callback(),
3899                              pool_.get(),
3900                              BoundNetLog()));
3901
3902   MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3903   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3904   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3905       .WillOnce(Invoke(&mock_layered_pool,
3906                        &MockLayeredPool::ReleaseOneConnection));
3907   ClientSocketHandle handle;
3908   TestCompletionCallback callback2;
3909   EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2",
3910                                         params_,
3911                                         DEFAULT_PRIORITY,
3912                                         callback2.callback(),
3913                                         pool_.get(),
3914                                         BoundNetLog()));
3915   EXPECT_EQ(OK, callback2.WaitForResult());
3916 }
3917
3918 // Tests the case when an idle socket can be closed when a new request is
3919 // issued, and the new request belongs to a group that was previously stalled.
3920 TEST_F(ClientSocketPoolBaseTest,
3921        CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) {
3922   CreatePool(2, 2);
3923   std::list<TestConnectJob::JobType> job_types;
3924   job_types.push_back(TestConnectJob::kMockJob);
3925   job_types.push_back(TestConnectJob::kMockJob);
3926   job_types.push_back(TestConnectJob::kMockJob);
3927   job_types.push_back(TestConnectJob::kMockJob);
3928   connect_job_factory_->set_job_types(&job_types);
3929
3930   ClientSocketHandle handle1;
3931   TestCompletionCallback callback1;
3932   EXPECT_EQ(OK, handle1.Init("group1",
3933                              params_,
3934                              DEFAULT_PRIORITY,
3935                              callback1.callback(),
3936                              pool_.get(),
3937                              BoundNetLog()));
3938
3939   MockLayeredPool mock_layered_pool(pool_.get(), "group2");
3940   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
3941   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
3942       .WillRepeatedly(Invoke(&mock_layered_pool,
3943                              &MockLayeredPool::ReleaseOneConnection));
3944   mock_layered_pool.set_can_release_connection(false);
3945
3946   // The third request is made when the socket pool is in a stalled state.
3947   ClientSocketHandle handle3;
3948   TestCompletionCallback callback3;
3949   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
3950                                          params_,
3951                                          DEFAULT_PRIORITY,
3952                                          callback3.callback(),
3953                                          pool_.get(),
3954                                          BoundNetLog()));
3955
3956   base::RunLoop().RunUntilIdle();
3957   EXPECT_FALSE(callback3.have_result());
3958
3959   // The fourth request is made when the pool is no longer stalled.  The third
3960   // request should be serviced first, since it was issued first and has the
3961   // same priority.
3962   mock_layered_pool.set_can_release_connection(true);
3963   ClientSocketHandle handle4;
3964   TestCompletionCallback callback4;
3965   EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
3966                                          params_,
3967                                          DEFAULT_PRIORITY,
3968                                          callback4.callback(),
3969                                          pool_.get(),
3970                                          BoundNetLog()));
3971   EXPECT_EQ(OK, callback3.WaitForResult());
3972   EXPECT_FALSE(callback4.have_result());
3973
3974   // Closing a handle should free up another socket slot.
3975   handle1.Reset();
3976   EXPECT_EQ(OK, callback4.WaitForResult());
3977 }
3978
3979 // Tests the case when an idle socket can be closed when a new request is
3980 // issued, and the new request belongs to a group that was previously stalled.
3981 //
3982 // The two differences from the above test are that the stalled requests are not
3983 // in the same group as the layered pool's request, and the the fourth request
3984 // has a higher priority than the third one, so gets a socket first.
3985 TEST_F(ClientSocketPoolBaseTest,
3986        CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) {
3987   CreatePool(2, 2);
3988   std::list<TestConnectJob::JobType> job_types;
3989   job_types.push_back(TestConnectJob::kMockJob);
3990   job_types.push_back(TestConnectJob::kMockJob);
3991   job_types.push_back(TestConnectJob::kMockJob);
3992   job_types.push_back(TestConnectJob::kMockJob);
3993   connect_job_factory_->set_job_types(&job_types);
3994
3995   ClientSocketHandle handle1;
3996   TestCompletionCallback callback1;
3997   EXPECT_EQ(OK, handle1.Init("group1",
3998                              params_,
3999                              DEFAULT_PRIORITY,
4000                              callback1.callback(),
4001                              pool_.get(),
4002                              BoundNetLog()));
4003
4004   MockLayeredPool mock_layered_pool(pool_.get(), "group2");
4005   EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
4006   EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
4007       .WillRepeatedly(Invoke(&mock_layered_pool,
4008                              &MockLayeredPool::ReleaseOneConnection));
4009   mock_layered_pool.set_can_release_connection(false);
4010
4011   // The third request is made when the socket pool is in a stalled state.
4012   ClientSocketHandle handle3;
4013   TestCompletionCallback callback3;
4014   EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
4015                                          params_,
4016                                          MEDIUM,
4017                                          callback3.callback(),
4018                                          pool_.get(),
4019                                          BoundNetLog()));
4020
4021   base::RunLoop().RunUntilIdle();
4022   EXPECT_FALSE(callback3.have_result());
4023
4024   // The fourth request is made when the pool is no longer stalled.  This
4025   // request has a higher priority than the third request, so is serviced first.
4026   mock_layered_pool.set_can_release_connection(true);
4027   ClientSocketHandle handle4;
4028   TestCompletionCallback callback4;
4029   EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
4030                                          params_,
4031                                          HIGHEST,
4032                                          callback4.callback(),
4033                                          pool_.get(),
4034                                          BoundNetLog()));
4035   EXPECT_EQ(OK, callback4.WaitForResult());
4036   EXPECT_FALSE(callback3.have_result());
4037
4038   // Closing a handle should free up another socket slot.
4039   handle1.Reset();
4040   EXPECT_EQ(OK, callback3.WaitForResult());
4041 }
4042
4043 TEST_F(ClientSocketPoolBaseTest,
4044        CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) {
4045   CreatePool(1, 1);
4046   connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
4047
4048   MockLayeredPool mock_layered_pool1(pool_.get(), "foo");
4049   EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get()));
4050   EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection())
4051       .WillRepeatedly(Invoke(&mock_layered_pool1,
4052                              &MockLayeredPool::ReleaseOneConnection));
4053   MockLayeredPool mock_layered_pool2(pool_.get(), "bar");
4054   EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()));
4055   EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection())
4056       .WillRepeatedly(Invoke(&mock_layered_pool2,
4057                              &MockLayeredPool::ReleaseOneConnection));
4058   ClientSocketHandle handle;
4059   TestCompletionCallback callback;
4060   EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
4061                                         params_,
4062                                         DEFAULT_PRIORITY,
4063                                         callback.callback(),
4064                                         pool_.get(),
4065                                         BoundNetLog()));
4066   EXPECT_EQ(OK, callback.WaitForResult());
4067 }
4068
4069 // Test that when a socket pool and group are at their limits, a request
4070 // with |ignore_limits| triggers creation of a new socket, and gets the socket
4071 // instead of a request with the same priority that was issued earlier, but
4072 // that does not have |ignore_limits| set.
4073 TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) {
4074   scoped_refptr<TestSocketParams> params_ignore_limits(
4075       new TestSocketParams(true /* ignore_limits */));
4076   CreatePool(1, 1);
4077
4078   // Issue a request to reach the socket pool limit.
4079   EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
4080   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4081
4082   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
4083
4084   EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4085                                                    params_));
4086   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4087
4088   EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4089                                                    params_ignore_limits));
4090   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
4091
4092   EXPECT_EQ(OK, request(2)->WaitForResult());
4093   EXPECT_FALSE(request(1)->have_result());
4094 }
4095
4096 // Test that when a socket pool and group are at their limits, a ConnectJob
4097 // issued for a request with |ignore_limits| set is not cancelled when a request
4098 // without |ignore_limits| issued to the same group is cancelled.
4099 TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) {
4100   scoped_refptr<TestSocketParams> params_ignore_limits(
4101       new TestSocketParams(true /* ignore_limits */));
4102   CreatePool(1, 1);
4103
4104   // Issue a request to reach the socket pool limit.
4105   EXPECT_EQ(OK, StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
4106   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4107
4108   connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
4109
4110   EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4111                                                    params_));
4112   EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
4113
4114   EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
4115                                                    params_ignore_limits));
4116   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
4117
4118   // Cancel the pending request without ignore_limits set. The ConnectJob
4119   // should not be cancelled.
4120   request(1)->handle()->Reset();
4121   ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
4122
4123   EXPECT_EQ(OK, request(2)->WaitForResult());
4124   EXPECT_FALSE(request(1)->have_result());
4125 }
4126
4127 }  // namespace
4128
4129 }  // namespace net