| Index: net/socket/client_socket_pool_base_unittest.cc
|
| diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
|
| index 5a672b44a4e99a30fd2583b9a545c84287b9d5b4..8e96fe2a3fad77d8d7af8448d3190ad470bf1da9 100644
|
| --- a/net/socket/client_socket_pool_base_unittest.cc
|
| +++ b/net/socket/client_socket_pool_base_unittest.cc
|
| @@ -118,8 +118,7 @@ class MockClientSocket : public StreamSocket {
|
| : connected_(false),
|
| has_unread_data_(false),
|
| net_log_(BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
|
| - was_used_to_convey_data_(false) {
|
| - }
|
| + was_used_to_convey_data_(false) {}
|
|
|
| // Sets whether the socket has unread data. If true, the next call to Read()
|
| // will return 1 byte and IsConnectedAndIdle() will return false.
|
| @@ -128,9 +127,9 @@ class MockClientSocket : public StreamSocket {
|
| }
|
|
|
| // Socket implementation.
|
| - virtual int Read(
|
| - IOBuffer* /* buf */, int len,
|
| - const CompletionCallback& /* callback */) OVERRIDE {
|
| + virtual int Read(IOBuffer* /* buf */,
|
| + int len,
|
| + const CompletionCallback& /* callback */) OVERRIDE {
|
| if (has_unread_data_ && len > 0) {
|
| has_unread_data_ = false;
|
| was_used_to_convey_data_ = true;
|
| @@ -139,9 +138,9 @@ class MockClientSocket : public StreamSocket {
|
| return ERR_UNEXPECTED;
|
| }
|
|
|
| - virtual int Write(
|
| - IOBuffer* /* buf */, int len,
|
| - const CompletionCallback& /* callback */) OVERRIDE {
|
| + virtual int Write(IOBuffer* /* buf */,
|
| + int len,
|
| + const CompletionCallback& /* callback */) OVERRIDE {
|
| was_used_to_convey_data_ = true;
|
| return len;
|
| }
|
| @@ -168,25 +167,17 @@ class MockClientSocket : public StreamSocket {
|
| return ERR_UNEXPECTED;
|
| }
|
|
|
| - virtual const BoundNetLog& NetLog() const OVERRIDE {
|
| - return net_log_;
|
| - }
|
| + virtual const BoundNetLog& NetLog() const OVERRIDE { return net_log_; }
|
|
|
| virtual void SetSubresourceSpeculation() OVERRIDE {}
|
| virtual void SetOmniboxSpeculation() OVERRIDE {}
|
| - virtual bool WasEverUsed() const OVERRIDE {
|
| - return was_used_to_convey_data_;
|
| - }
|
| + virtual bool WasEverUsed() const OVERRIDE { return was_used_to_convey_data_; }
|
| virtual bool UsingTCPFastOpen() const OVERRIDE { return false; }
|
| - virtual bool WasNpnNegotiated() const OVERRIDE {
|
| - return false;
|
| - }
|
| + virtual bool WasNpnNegotiated() const OVERRIDE { return false; }
|
| virtual NextProto GetNegotiatedProtocol() const OVERRIDE {
|
| return kProtoUnknown;
|
| }
|
| - virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE {
|
| - return false;
|
| - }
|
| + virtual bool GetSSLInfo(SSLInfo* ssl_info) OVERRIDE { return false; }
|
|
|
| private:
|
| bool connected_;
|
| @@ -229,9 +220,7 @@ class MockClientSocketFactory : public ClientSocketFactory {
|
| return scoped_ptr<SSLClientSocket>();
|
| }
|
|
|
| - virtual void ClearSSLSessionCache() OVERRIDE {
|
| - NOTIMPLEMENTED();
|
| - }
|
| + virtual void ClearSSLSessionCache() OVERRIDE { NOTIMPLEMENTED(); }
|
|
|
| void WaitForSignal(TestConnectJob* job) { waiting_jobs_.push_back(job); }
|
|
|
| @@ -274,14 +263,16 @@ class TestConnectJob : public ConnectJob {
|
| ConnectJob::Delegate* delegate,
|
| MockClientSocketFactory* client_socket_factory,
|
| NetLog* net_log)
|
| - : ConnectJob(group_name, timeout_duration, request.priority(), delegate,
|
| + : ConnectJob(group_name,
|
| + timeout_duration,
|
| + request.priority(),
|
| + delegate,
|
| BoundNetLog::Make(net_log, NetLog::SOURCE_CONNECT_JOB)),
|
| job_type_(job_type),
|
| client_socket_factory_(client_socket_factory),
|
| load_state_(LOAD_STATE_IDLE),
|
| store_additional_error_state_(false),
|
| - weak_factory_(this) {
|
| - }
|
| + weak_factory_(this) {}
|
|
|
| void Signal() {
|
| DoConnect(waiting_success_, true /* async */, false /* recoverable */);
|
| @@ -314,11 +305,11 @@ class TestConnectJob : public ConnectJob {
|
| scoped_ptr<StreamSocket>(new MockClientSocket(net_log().net_log())));
|
| switch (job_type_) {
|
| case kMockJob:
|
| - return DoConnect(true /* successful */, false /* sync */,
|
| - false /* recoverable */);
|
| + return DoConnect(
|
| + true /* successful */, false /* sync */, false /* recoverable */);
|
| case kMockFailingJob:
|
| - return DoConnect(false /* error */, false /* sync */,
|
| - false /* recoverable */);
|
| + return DoConnect(
|
| + false /* error */, false /* sync */, false /* recoverable */);
|
| case kMockPendingJob:
|
| set_load_state(LOAD_STATE_CONNECTING);
|
|
|
| @@ -349,7 +340,7 @@ class TestConnectJob : public ConnectJob {
|
| base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
|
| weak_factory_.GetWeakPtr(),
|
| false /* error */,
|
| - true /* async */,
|
| + true /* async */,
|
| false /* recoverable */),
|
| base::TimeDelta::FromMilliseconds(2));
|
| return ERR_IO_PENDING;
|
| @@ -359,8 +350,8 @@ class TestConnectJob : public ConnectJob {
|
| waiting_success_ = true;
|
| return ERR_IO_PENDING;
|
| case kMockRecoverableJob:
|
| - return DoConnect(false /* error */, false /* sync */,
|
| - true /* recoverable */);
|
| + return DoConnect(
|
| + false /* error */, false /* sync */, true /* recoverable */);
|
| case kMockPendingRecoverableJob:
|
| set_load_state(LOAD_STATE_CONNECTING);
|
| base::MessageLoop::current()->PostDelayedTask(
|
| @@ -368,14 +359,14 @@ class TestConnectJob : public ConnectJob {
|
| base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
|
| weak_factory_.GetWeakPtr(),
|
| false /* error */,
|
| - true /* async */,
|
| - true /* recoverable */),
|
| + true /* async */,
|
| + true /* recoverable */),
|
| base::TimeDelta::FromMilliseconds(2));
|
| return ERR_IO_PENDING;
|
| case kMockAdditionalErrorStateJob:
|
| store_additional_error_state_ = true;
|
| - return DoConnect(false /* error */, false /* sync */,
|
| - false /* recoverable */);
|
| + return DoConnect(
|
| + false /* error */, false /* sync */, false /* recoverable */);
|
| case kMockPendingAdditionalErrorStateJob:
|
| set_load_state(LOAD_STATE_CONNECTING);
|
| store_additional_error_state_ = true;
|
| @@ -384,13 +375,13 @@ class TestConnectJob : public ConnectJob {
|
| base::Bind(base::IgnoreResult(&TestConnectJob::DoConnect),
|
| weak_factory_.GetWeakPtr(),
|
| false /* error */,
|
| - true /* async */,
|
| + true /* async */,
|
| false /* recoverable */),
|
| base::TimeDelta::FromMilliseconds(2));
|
| return ERR_IO_PENDING;
|
| case kMockUnreadDataJob: {
|
| - int ret = DoConnect(true /* successful */, false /* sync */,
|
| - false /* recoverable */);
|
| + int ret = DoConnect(
|
| + true /* successful */, false /* sync */, false /* recoverable */);
|
| static_cast<MockClientSocket*>(socket())->set_has_unread_data(true);
|
| return ret;
|
| }
|
| @@ -436,8 +427,7 @@ class TestConnectJobFactory
|
| : job_type_(TestConnectJob::kMockJob),
|
| job_types_(NULL),
|
| client_socket_factory_(client_socket_factory),
|
| - net_log_(net_log) {
|
| - }
|
| + net_log_(net_log) {}
|
|
|
| virtual ~TestConnectJobFactory() {}
|
|
|
| @@ -498,23 +488,26 @@ class TestClientSocketPool : public ClientSocketPool {
|
| base::TimeDelta unused_idle_socket_timeout,
|
| base::TimeDelta used_idle_socket_timeout,
|
| TestClientSocketPoolBase::ConnectJobFactory* connect_job_factory)
|
| - : base_(NULL, max_sockets, max_sockets_per_group, histograms,
|
| - unused_idle_socket_timeout, used_idle_socket_timeout,
|
| + : base_(NULL,
|
| + max_sockets,
|
| + max_sockets_per_group,
|
| + histograms,
|
| + unused_idle_socket_timeout,
|
| + used_idle_socket_timeout,
|
| connect_job_factory) {}
|
|
|
| virtual ~TestClientSocketPool() {}
|
|
|
| - virtual int RequestSocket(
|
| - const std::string& group_name,
|
| - const void* params,
|
| - net::RequestPriority priority,
|
| - ClientSocketHandle* handle,
|
| - const CompletionCallback& callback,
|
| - const BoundNetLog& net_log) OVERRIDE {
|
| + virtual int RequestSocket(const std::string& group_name,
|
| + const void* params,
|
| + net::RequestPriority priority,
|
| + ClientSocketHandle* handle,
|
| + const CompletionCallback& callback,
|
| + const BoundNetLog& net_log) OVERRIDE {
|
| const scoped_refptr<TestSocketParams>* casted_socket_params =
|
| static_cast<const scoped_refptr<TestSocketParams>*>(params);
|
| - return base_.RequestSocket(group_name, *casted_socket_params, priority,
|
| - handle, callback, net_log);
|
| + return base_.RequestSocket(
|
| + group_name, *casted_socket_params, priority, handle, callback, net_log);
|
| }
|
|
|
| virtual void RequestSockets(const std::string& group_name,
|
| @@ -527,16 +520,14 @@ class TestClientSocketPool : public ClientSocketPool {
|
| base_.RequestSockets(group_name, *casted_params, num_sockets, net_log);
|
| }
|
|
|
| - virtual void CancelRequest(
|
| - const std::string& group_name,
|
| - ClientSocketHandle* handle) OVERRIDE {
|
| + virtual void CancelRequest(const std::string& group_name,
|
| + ClientSocketHandle* handle) OVERRIDE {
|
| base_.CancelRequest(group_name, handle);
|
| }
|
|
|
| - virtual void ReleaseSocket(
|
| - const std::string& group_name,
|
| - scoped_ptr<StreamSocket> socket,
|
| - int id) OVERRIDE {
|
| + virtual void ReleaseSocket(const std::string& group_name,
|
| + scoped_ptr<StreamSocket> socket,
|
| + int id) OVERRIDE {
|
| base_.ReleaseSocket(group_name, socket.Pass(), id);
|
| }
|
|
|
| @@ -544,13 +535,9 @@ class TestClientSocketPool : public ClientSocketPool {
|
| base_.FlushWithError(error);
|
| }
|
|
|
| - virtual bool IsStalled() const OVERRIDE {
|
| - return base_.IsStalled();
|
| - }
|
| + virtual bool IsStalled() const OVERRIDE { return base_.IsStalled(); }
|
|
|
| - virtual void CloseIdleSockets() OVERRIDE {
|
| - base_.CloseIdleSockets();
|
| - }
|
| + virtual void CloseIdleSockets() OVERRIDE { base_.CloseIdleSockets(); }
|
|
|
| virtual int IdleSocketCount() const OVERRIDE {
|
| return base_.idle_socket_count();
|
| @@ -629,7 +616,8 @@ namespace {
|
|
|
| void MockClientSocketFactory::SignalJobs() {
|
| for (std::vector<TestConnectJob*>::iterator it = waiting_jobs_.begin();
|
| - it != waiting_jobs_.end(); ++it) {
|
| + it != waiting_jobs_.end();
|
| + ++it) {
|
| (*it)->Signal();
|
| }
|
| waiting_jobs_.clear();
|
| @@ -701,20 +689,19 @@ class ClientSocketPoolBaseTest : public testing::Test {
|
| }
|
|
|
| void CreatePool(int max_sockets, int max_sockets_per_group) {
|
| - CreatePoolWithIdleTimeouts(
|
| - max_sockets,
|
| - max_sockets_per_group,
|
| - ClientSocketPool::unused_idle_socket_timeout(),
|
| - ClientSocketPool::used_idle_socket_timeout());
|
| + CreatePoolWithIdleTimeouts(max_sockets,
|
| + max_sockets_per_group,
|
| + ClientSocketPool::unused_idle_socket_timeout(),
|
| + ClientSocketPool::used_idle_socket_timeout());
|
| }
|
|
|
| - void CreatePoolWithIdleTimeouts(
|
| - int max_sockets, int max_sockets_per_group,
|
| - base::TimeDelta unused_idle_socket_timeout,
|
| - base::TimeDelta used_idle_socket_timeout) {
|
| + void CreatePoolWithIdleTimeouts(int max_sockets,
|
| + int max_sockets_per_group,
|
| + base::TimeDelta unused_idle_socket_timeout,
|
| + base::TimeDelta used_idle_socket_timeout) {
|
| DCHECK(!pool_.get());
|
| - connect_job_factory_ = new TestConnectJobFactory(&client_socket_factory_,
|
| - &net_log_);
|
| + connect_job_factory_ =
|
| + new TestConnectJobFactory(&client_socket_factory_, &net_log_);
|
| pool_.reset(new TestClientSocketPool(max_sockets,
|
| max_sockets_per_group,
|
| &histograms_,
|
| @@ -723,10 +710,9 @@ class ClientSocketPoolBaseTest : public testing::Test {
|
| connect_job_factory_));
|
| }
|
|
|
| - int StartRequestWithParams(
|
| - const std::string& group_name,
|
| - RequestPriority priority,
|
| - const scoped_refptr<TestSocketParams>& params) {
|
| + int StartRequestWithParams(const std::string& group_name,
|
| + RequestPriority priority,
|
| + const scoped_refptr<TestSocketParams>& params) {
|
| return test_base_.StartRequestUsingPool(
|
| pool_.get(), group_name, priority, params);
|
| }
|
| @@ -769,9 +755,13 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_NoTimeoutOnSynchronousCompletion) {
|
| TestConnectJobDelegate delegate;
|
| ClientSocketHandle ignored;
|
| TestClientSocketPoolBase::Request request(
|
| - &ignored, CompletionCallback(), DEFAULT_PRIORITY,
|
| + &ignored,
|
| + CompletionCallback(),
|
| + DEFAULT_PRIORITY,
|
| internal::ClientSocketPoolBaseHelper::NORMAL,
|
| - false, params_, BoundNetLog());
|
| + false,
|
| + params_,
|
| + BoundNetLog());
|
| scoped_ptr<TestConnectJob> job(
|
| new TestConnectJob(TestConnectJob::kMockJob,
|
| "a",
|
| @@ -789,18 +779,21 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
|
| CapturingNetLog log;
|
|
|
| TestClientSocketPoolBase::Request request(
|
| - &ignored, CompletionCallback(), DEFAULT_PRIORITY,
|
| + &ignored,
|
| + CompletionCallback(),
|
| + DEFAULT_PRIORITY,
|
| internal::ClientSocketPoolBaseHelper::NORMAL,
|
| - false, params_, BoundNetLog());
|
| + false,
|
| + params_,
|
| + BoundNetLog());
|
| // Deleted by TestConnectJobDelegate.
|
| - TestConnectJob* job =
|
| - new TestConnectJob(TestConnectJob::kMockPendingJob,
|
| - "a",
|
| - request,
|
| - base::TimeDelta::FromMicroseconds(1),
|
| - &delegate,
|
| - &client_socket_factory_,
|
| - &log);
|
| + TestConnectJob* job = new TestConnectJob(TestConnectJob::kMockPendingJob,
|
| + "a",
|
| + request,
|
| + base::TimeDelta::FromMicroseconds(1),
|
| + &delegate,
|
| + &client_socket_factory_,
|
| + &log);
|
| ASSERT_EQ(ERR_IO_PENDING, job->Connect());
|
| base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(1));
|
| EXPECT_EQ(ERR_TIMED_OUT, delegate.WaitForResult());
|
| @@ -809,20 +802,20 @@ TEST_F(ClientSocketPoolBaseTest, ConnectJob_TimedOut) {
|
| log.GetEntries(&entries);
|
|
|
| EXPECT_EQ(6u, entries.size());
|
| - EXPECT_TRUE(LogContainsBeginEvent(
|
| - entries, 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
|
| + EXPECT_TRUE(
|
| + LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
|
| EXPECT_TRUE(LogContainsBeginEvent(
|
| entries, 1, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
|
| EXPECT_TRUE(LogContainsEvent(
|
| - entries, 2, NetLog::TYPE_CONNECT_JOB_SET_SOCKET,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEvent(
|
| - entries, 3, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
|
| - NetLog::PHASE_NONE));
|
| + entries, 2, NetLog::TYPE_CONNECT_JOB_SET_SOCKET, NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEvent(entries,
|
| + 3,
|
| + NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_TIMED_OUT,
|
| + NetLog::PHASE_NONE));
|
| EXPECT_TRUE(LogContainsEndEvent(
|
| entries, 4, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB_CONNECT));
|
| - EXPECT_TRUE(LogContainsEndEvent(
|
| - entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
|
| + EXPECT_TRUE(
|
| + LogContainsEndEvent(entries, 5, NetLog::TYPE_SOCKET_POOL_CONNECT_JOB));
|
| }
|
|
|
| TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
|
| @@ -851,16 +844,16 @@ TEST_F(ClientSocketPoolBaseTest, BasicSynchronous) {
|
| log.GetEntries(&entries);
|
|
|
| EXPECT_EQ(4u, entries.size());
|
| - EXPECT_TRUE(LogContainsBeginEvent(
|
| - entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| - EXPECT_TRUE(LogContainsEvent(
|
| - entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEvent(
|
| - entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEndEvent(
|
| - entries, 3, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsEvent(entries,
|
| + 1,
|
| + NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEvent(entries,
|
| + 2,
|
| + NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEndEvent(entries, 3, NetLog::TYPE_SOCKET_POOL));
|
| }
|
|
|
| TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
|
| @@ -892,13 +885,12 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) {
|
| log.GetEntries(&entries);
|
|
|
| EXPECT_EQ(3u, entries.size());
|
| - EXPECT_TRUE(LogContainsBeginEvent(
|
| - entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| - EXPECT_TRUE(LogContainsEvent(
|
| - entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEndEvent(
|
| - entries, 2, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsEvent(entries,
|
| + 1,
|
| + NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEndEvent(entries, 2, NetLog::TYPE_SOCKET_POOL));
|
| }
|
|
|
| TEST_F(ClientSocketPoolBaseTest, TotalLimit) {
|
| @@ -1151,23 +1143,25 @@ TEST_F(ClientSocketPoolBaseTest, CancelStalledSocketAtSocketLimit) {
|
| ClientSocketHandle handles[kDefaultMaxSockets];
|
| TestCompletionCallback callbacks[kDefaultMaxSockets];
|
| for (int i = 0; i < kDefaultMaxSockets; ++i) {
|
| - EXPECT_EQ(OK, handles[i].Init(base::IntToString(i),
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callbacks[i].callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handles[i].Init(base::IntToString(i),
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callbacks[i].callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| }
|
|
|
| // Force a stalled group.
|
| ClientSocketHandle stalled_handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stalled_handle.Init("foo",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| // Cancel the stalled request.
|
| stalled_handle.Reset();
|
| @@ -1190,24 +1184,26 @@ TEST_F(ClientSocketPoolBaseTest, CancelPendingSocketAtSocketLimit) {
|
| ClientSocketHandle handles[kDefaultMaxSockets];
|
| for (int i = 0; i < kDefaultMaxSockets; ++i) {
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handles[i].Init(base::IntToString(i),
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handles[i].Init(base::IntToString(i),
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| }
|
|
|
| // Force a stalled group.
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
| ClientSocketHandle stalled_handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stalled_handle.Init("foo",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| // Since it is stalled, it should have no connect jobs.
|
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("foo"));
|
| @@ -1246,13 +1242,13 @@ TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
|
| ClientSocketHandle handles[kDefaultMaxSockets];
|
| for (int i = 0; i < kDefaultMaxSockets; ++i) {
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(OK, handles[i].Init(base::StringPrintf(
|
| - "Take 2: %d", i),
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handles[i].Init(base::StringPrintf("Take 2: %d", i),
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| }
|
|
|
| EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
|
| @@ -1260,12 +1256,13 @@ TEST_F(ClientSocketPoolBaseTest, WaitForStalledSocketAtSocketLimit) {
|
| EXPECT_FALSE(pool_->IsStalled());
|
|
|
| // Now we will hit the socket limit.
|
| - EXPECT_EQ(ERR_IO_PENDING, stalled_handle.Init("foo",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + stalled_handle.Init("foo",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_TRUE(pool_->IsStalled());
|
|
|
| // Dropping out of scope will close all handles and return them to idle.
|
| @@ -1288,12 +1285,13 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
|
| for (int i = 0; i < kDefaultMaxSockets; ++i) {
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(OK, handle.Init(base::IntToString(i),
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle.Init(base::IntToString(i),
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| }
|
|
|
| // Flush all the DoReleaseSocket tasks.
|
| @@ -1308,12 +1306,13 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketAtSocketLimitDeleteGroup) {
|
| // "0" is special here, since it should be the first entry in the sorted map,
|
| // which is the one which we would close an idle socket for. We shouldn't
|
| // close an idle socket though, since we should reuse the idle socket.
|
| - EXPECT_EQ(OK, handle.Init("0",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle.Init("0",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| EXPECT_EQ(kDefaultMaxSockets, client_socket_factory_.allocation_count());
|
| EXPECT_EQ(kDefaultMaxSockets - 1, pool_->IdleSocketCount());
|
| @@ -1335,8 +1334,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingRequests) {
|
|
|
| EXPECT_EQ(kDefaultMaxSocketsPerGroup,
|
| client_socket_factory_.allocation_count());
|
| - EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
|
| - completion_count());
|
| + EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup, completion_count());
|
|
|
| EXPECT_EQ(1, GetOrderOfRequest(1));
|
| EXPECT_EQ(2, GetOrderOfRequest(2));
|
| @@ -1369,8 +1367,7 @@ TEST_F(ClientSocketPoolBaseTest, PendingRequests_NoKeepAlive) {
|
|
|
| EXPECT_EQ(static_cast<int>(requests_size()),
|
| client_socket_factory_.allocation_count());
|
| - EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
|
| - completion_count());
|
| + EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup, completion_count());
|
| }
|
|
|
| // This test will start up a RequestSocket() and then immediately Cancel() it.
|
| @@ -1382,12 +1379,13 @@ TEST_F(ClientSocketPoolBaseTest, CancelRequestClearGroup) {
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| handle.Reset();
|
| }
|
|
|
| @@ -1398,12 +1396,13 @@ TEST_F(ClientSocketPoolBaseTest, ConnectCancelConnect) {
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
|
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| handle.Reset();
|
|
|
| @@ -1470,8 +1469,7 @@ class RequestSocketCallback : public TestCompletionCallbackBase {
|
| test_connect_job_factory_(test_connect_job_factory),
|
| next_job_type_(next_job_type),
|
| callback_(base::Bind(&RequestSocketCallback::OnComplete,
|
| - base::Unretained(this))) {
|
| - }
|
| + base::Unretained(this))) {}
|
|
|
| virtual ~RequestSocketCallback() {}
|
|
|
| @@ -1547,9 +1545,10 @@ TEST_F(ClientSocketPoolBaseTest, RequestPendingJobTwice) {
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
| ClientSocketHandle handle;
|
| - RequestSocketCallback callback(
|
| - &handle, pool_.get(), connect_job_factory_,
|
| - TestConnectJob::kMockPendingJob);
|
| + RequestSocketCallback callback(&handle,
|
| + pool_.get(),
|
| + connect_job_factory_,
|
| + TestConnectJob::kMockPendingJob);
|
| int rv = handle.Init("a",
|
| params_,
|
| DEFAULT_PRIORITY,
|
| @@ -1607,8 +1606,7 @@ TEST_F(ClientSocketPoolBaseTest, CancelActiveRequestWithPendingRequests) {
|
| request(i)->handle()->Reset();
|
| }
|
|
|
| - EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup,
|
| - completion_count());
|
| + EXPECT_EQ(requests_size() - kDefaultMaxSocketsPerGroup, completion_count());
|
| }
|
|
|
| // Make sure that pending requests get serviced after active requests fail.
|
| @@ -1705,12 +1703,8 @@ TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| CapturingBoundNetLog log;
|
| - int rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - log.bound());
|
| + int rv = handle.Init(
|
| + "a", params_, LOWEST, callback.callback(), pool_.get(), log.bound());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
|
| TestLoadTimingInfoNotConnected(handle);
|
| @@ -1727,20 +1721,19 @@ TEST_F(ClientSocketPoolBaseTest, BasicAsynchronous) {
|
| log.GetEntries(&entries);
|
|
|
| EXPECT_EQ(4u, entries.size());
|
| - EXPECT_TRUE(LogContainsBeginEvent(
|
| - entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| - EXPECT_TRUE(LogContainsEvent(
|
| - entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEvent(
|
| - entries, 2, NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEndEvent(
|
| - entries, 3, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsEvent(entries,
|
| + 1,
|
| + NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEvent(entries,
|
| + 2,
|
| + NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEndEvent(entries, 3, NetLog::TYPE_SOCKET_POOL));
|
| }
|
|
|
| -TEST_F(ClientSocketPoolBaseTest,
|
| - InitConnectionAsynchronousFailure) {
|
| +TEST_F(ClientSocketPoolBaseTest, InitConnectionAsynchronousFailure) {
|
| CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingFailingJob);
|
| @@ -1752,12 +1745,13 @@ TEST_F(ClientSocketPoolBaseTest,
|
| HttpResponseInfo info;
|
| info.headers = new HttpResponseHeaders(std::string());
|
| handle.set_ssl_error_response_info(info);
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - log.bound()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + log.bound()));
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
|
| EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
|
| EXPECT_FALSE(handle.is_ssl_error());
|
| @@ -1767,13 +1761,12 @@ TEST_F(ClientSocketPoolBaseTest,
|
| log.GetEntries(&entries);
|
|
|
| EXPECT_EQ(3u, entries.size());
|
| - EXPECT_TRUE(LogContainsBeginEvent(
|
| - entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| - EXPECT_TRUE(LogContainsEvent(
|
| - entries, 1, NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| - NetLog::PHASE_NONE));
|
| - EXPECT_TRUE(LogContainsEndEvent(
|
| - entries, 2, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsBeginEvent(entries, 0, NetLog::TYPE_SOCKET_POOL));
|
| + EXPECT_TRUE(LogContainsEvent(entries,
|
| + 1,
|
| + NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB,
|
| + NetLog::PHASE_NONE));
|
| + EXPECT_TRUE(LogContainsEndEvent(entries, 2, NetLog::TYPE_SOCKET_POOL));
|
| }
|
|
|
| TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
|
| @@ -1805,7 +1798,6 @@ TEST_F(ClientSocketPoolBaseTest, TwoRequestsCancelOne) {
|
|
|
| handle.Reset();
|
|
|
| -
|
| // At this point, request 2 is just waiting for the connect job to finish.
|
|
|
| EXPECT_EQ(OK, callback2.WaitForResult());
|
| @@ -1851,7 +1843,8 @@ TEST_F(ClientSocketPoolBaseTest, ReleaseSockets) {
|
| int rv = req1.handle()->Init("a",
|
| params_,
|
| DEFAULT_PRIORITY,
|
| - req1.callback(), pool_.get(),
|
| + req1.callback(),
|
| + pool_.get(),
|
| BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(OK, req1.WaitForResult());
|
| @@ -2022,12 +2015,8 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - int rv = handle.Init("a",
|
| - params_,
|
| - MEDIUM,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + int rv = handle.Init(
|
| + "a", params_, MEDIUM, callback.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, handle.GetLoadState());
|
|
|
| @@ -2035,12 +2024,8 @@ TEST_F(ClientSocketPoolBaseTest, LoadStateGroupLimit) {
|
| // The first request should now be stalled at the socket group limit.
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - rv = handle2.Init("a",
|
| - params_,
|
| - HIGHEST,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + rv = handle2.Init(
|
| + "a", params_, HIGHEST, callback2.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_WAITING_FOR_AVAILABLE_SOCKET, handle.GetLoadState());
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, handle2.GetLoadState());
|
| @@ -2129,8 +2114,12 @@ TEST_F(ClientSocketPoolBaseTest, Recoverable) {
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| EXPECT_EQ(ERR_PROXY_AUTH_REQUESTED,
|
| - handle.Init("a", params_, DEFAULT_PRIORITY, callback.callback(),
|
| - pool_.get(), BoundNetLog()));
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_TRUE(handle.is_initialized());
|
| EXPECT_TRUE(handle.socket());
|
| }
|
| @@ -2203,20 +2192,17 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) {
|
| internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
|
|
|
| CreatePoolWithIdleTimeouts(
|
| - kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
|
| - base::TimeDelta(), // Time out unused sockets immediately.
|
| + kDefaultMaxSockets,
|
| + kDefaultMaxSocketsPerGroup,
|
| + base::TimeDelta(), // Time out unused sockets immediately.
|
| base::TimeDelta::FromDays(1)); // Don't time out used sockets.
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - int rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + int rv = handle.Init(
|
| + "a", params_, LOWEST, callback.callback(), pool_.get(), BoundNetLog());
|
| ASSERT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
|
| ASSERT_EQ(OK, callback.WaitForResult());
|
| @@ -2232,12 +2218,8 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerReuse) {
|
| // Request a new socket. This should reuse the old socket and complete
|
| // synchronously.
|
| CapturingBoundNetLog log;
|
| - rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - CompletionCallback(),
|
| - pool_.get(),
|
| - log.bound());
|
| + rv = handle.Init(
|
| + "a", params_, LOWEST, CompletionCallback(), pool_.get(), log.bound());
|
| ASSERT_EQ(OK, rv);
|
| EXPECT_TRUE(handle.is_reused());
|
| TestLoadTimingInfoConnectedReused(handle);
|
| @@ -2258,8 +2240,9 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerNoReuse) {
|
| internal::ClientSocketPoolBaseHelper::set_cleanup_timer_enabled(false);
|
|
|
| CreatePoolWithIdleTimeouts(
|
| - kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
|
| - base::TimeDelta(), // Time out unused sockets immediately
|
| + kDefaultMaxSockets,
|
| + kDefaultMaxSocketsPerGroup,
|
| + base::TimeDelta(), // Time out unused sockets immediately
|
| base::TimeDelta()); // Time out used sockets immediately
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
| @@ -2268,23 +2251,15 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerNoReuse) {
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - int rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + int rv = handle.Init(
|
| + "a", params_, LOWEST, callback.callback(), pool_.get(), BoundNetLog());
|
| ASSERT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
|
|
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - rv = handle2.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + rv = handle2.Init(
|
| + "a", params_, LOWEST, callback2.callback(), pool_.get(), BoundNetLog());
|
| ASSERT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
|
|
|
| @@ -2313,12 +2288,8 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerNoReuse) {
|
| // A new socket will be created rather than reusing the idle one.
|
| CapturingBoundNetLog log;
|
| TestCompletionCallback callback3;
|
| - rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback3.callback(),
|
| - pool_.get(),
|
| - log.bound());
|
| + rv = handle.Init(
|
| + "a", params_, LOWEST, callback3.callback(), pool_.get(), log.bound());
|
| ASSERT_EQ(ERR_IO_PENDING, rv);
|
| ASSERT_EQ(OK, callback3.WaitForResult());
|
| EXPECT_FALSE(handle.is_reused());
|
| @@ -2336,8 +2307,9 @@ TEST_F(ClientSocketPoolBaseTest, DisableCleanupTimerNoReuse) {
|
|
|
| TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
|
| CreatePoolWithIdleTimeouts(
|
| - kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
|
| - base::TimeDelta(), // Time out unused sockets immediately.
|
| + kDefaultMaxSockets,
|
| + kDefaultMaxSocketsPerGroup,
|
| + base::TimeDelta(), // Time out unused sockets immediately.
|
| base::TimeDelta::FromDays(1)); // Don't time out used sockets.
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
| @@ -2346,23 +2318,15 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - int rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + int rv = handle.Init(
|
| + "a", params_, LOWEST, callback.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle));
|
|
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - rv = handle2.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + rv = handle2.Init(
|
| + "a", params_, LOWEST, callback2.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_EQ(LOAD_STATE_CONNECTING, pool_->GetLoadState("a", &handle2));
|
|
|
| @@ -2391,12 +2355,8 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
|
|
|
| pool_->CleanupTimedOutIdleSockets();
|
| CapturingBoundNetLog log;
|
| - rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - log.bound());
|
| + rv = handle.Init(
|
| + "a", params_, LOWEST, callback.callback(), pool_.get(), log.bound());
|
| EXPECT_EQ(OK, rv);
|
| EXPECT_TRUE(handle.is_reused());
|
|
|
| @@ -2410,8 +2370,9 @@ TEST_F(ClientSocketPoolBaseTest, CleanupTimedOutIdleSockets) {
|
| // because of multiple releasing disconnected sockets.
|
| TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
|
| CreatePoolWithIdleTimeouts(
|
| - kDefaultMaxSockets, kDefaultMaxSocketsPerGroup,
|
| - base::TimeDelta(), // Time out unused sockets immediately.
|
| + kDefaultMaxSockets,
|
| + kDefaultMaxSocketsPerGroup,
|
| + base::TimeDelta(), // Time out unused sockets immediately.
|
| base::TimeDelta::FromDays(1)); // Don't time out used sockets.
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
|
| @@ -2420,42 +2381,26 @@ TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - int rv = handle.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + int rv = handle.Init(
|
| + "a", params_, LOWEST, callback.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(OK, rv);
|
|
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - rv = handle2.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + rv = handle2.Init(
|
| + "a", params_, LOWEST, callback2.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(OK, rv);
|
|
|
| ClientSocketHandle handle3;
|
| TestCompletionCallback callback3;
|
| - rv = handle3.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback3.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + rv = handle3.Init(
|
| + "a", params_, LOWEST, callback3.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
|
|
| ClientSocketHandle handle4;
|
| TestCompletionCallback callback4;
|
| - rv = handle4.Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback4.callback(),
|
| - pool_.get(),
|
| - BoundNetLog());
|
| + rv = handle4.Init(
|
| + "a", params_, LOWEST, callback4.callback(), pool_.get(), BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
|
|
| // Release two disconnected sockets.
|
| @@ -2476,8 +2421,9 @@ TEST_F(ClientSocketPoolBaseTest, MultipleReleasingDisconnectedSockets) {
|
| // other stalled groups all have releasing sockets, so no progress can be made.
|
| TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) {
|
| CreatePoolWithIdleTimeouts(
|
| - 4 /* socket limit */, 4 /* socket limit per group */,
|
| - base::TimeDelta(), // Time out unused sockets immediately.
|
| + 4 /* socket limit */,
|
| + 4 /* socket limit per group */,
|
| + base::TimeDelta(), // Time out unused sockets immediately.
|
| base::TimeDelta::FromDays(1)); // Don't time out used sockets.
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
|
| @@ -2490,18 +2436,20 @@ TEST_F(ClientSocketPoolBaseTest, SocketLimitReleasingSockets) {
|
| TestCompletionCallback callback_b[4];
|
|
|
| for (int i = 0; i < 2; ++i) {
|
| - EXPECT_EQ(OK, handle_a[i].Init("a",
|
| - params_,
|
| - LOWEST,
|
| - callback_a[i].callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| - EXPECT_EQ(OK, handle_b[i].Init("b",
|
| - params_,
|
| - LOWEST,
|
| - callback_b[i].callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle_a[i].Init("a",
|
| + params_,
|
| + LOWEST,
|
| + callback_a[i].callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle_b[i].Init("b",
|
| + params_,
|
| + LOWEST,
|
| + callback_b[i].callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| }
|
|
|
| // Make 4 pending requests, 2 per group.
|
| @@ -2588,8 +2536,7 @@ class TestReleasingSocketRequest : public TestCompletionCallbackBase {
|
| expected_result_(expected_result),
|
| reset_releasing_handle_(reset_releasing_handle),
|
| callback_(base::Bind(&TestReleasingSocketRequest::OnComplete,
|
| - base::Unretained(this))) {
|
| - }
|
| + base::Unretained(this))) {}
|
|
|
| virtual ~TestReleasingSocketRequest() {}
|
|
|
| @@ -2606,8 +2553,12 @@ class TestReleasingSocketRequest : public TestCompletionCallbackBase {
|
| scoped_refptr<TestSocketParams> con_params(
|
| new TestSocketParams(false /* ignore_limits */));
|
| EXPECT_EQ(expected_result_,
|
| - handle2_.Init("a", con_params, DEFAULT_PRIORITY,
|
| - callback2_.callback(), pool_, BoundNetLog()));
|
| + handle2_.Init("a",
|
| + con_params,
|
| + DEFAULT_PRIORITY,
|
| + callback2_.callback(),
|
| + pool_,
|
| + BoundNetLog()));
|
| }
|
|
|
| TestClientSocketPool* const pool_;
|
| @@ -2619,7 +2570,6 @@ class TestReleasingSocketRequest : public TestCompletionCallbackBase {
|
| TestCompletionCallback callback2_;
|
| };
|
|
|
| -
|
| TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
|
| CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
|
|
|
| @@ -2634,8 +2584,12 @@ TEST_F(ClientSocketPoolBaseTest, AdditionalErrorSocketsDontUseSlot) {
|
| TestConnectJob::kMockPendingAdditionalErrorStateJob);
|
| TestReleasingSocketRequest req(pool_.get(), OK, false);
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - req.handle()->Init("a", params_, DEFAULT_PRIORITY, req.callback(),
|
| - pool_.get(), BoundNetLog()));
|
| + req.handle()->Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + req.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| // The next job should complete synchronously
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
|
|
|
| @@ -2660,12 +2614,13 @@ TEST_F(ClientSocketPoolBaseTest, CallbackThatReleasesPool) {
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| pool_->FlushWithError(ERR_NETWORK_CHANGED);
|
|
|
| @@ -2679,12 +2634,13 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_EQ(OK, callback.WaitForResult());
|
| EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
|
|
|
| @@ -2693,34 +2649,31 @@ TEST_F(ClientSocketPoolBaseTest, DoNotReuseSocketAfterFlush) {
|
| handle.Reset();
|
| base::MessageLoop::current()->RunUntilIdle();
|
|
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_EQ(OK, callback.WaitForResult());
|
| EXPECT_EQ(ClientSocketHandle::UNUSED, handle.reuse_type());
|
| }
|
|
|
| class ConnectWithinCallback : public TestCompletionCallbackBase {
|
| public:
|
| - ConnectWithinCallback(
|
| - const std::string& group_name,
|
| - const scoped_refptr<TestSocketParams>& params,
|
| - TestClientSocketPool* pool)
|
| + ConnectWithinCallback(const std::string& group_name,
|
| + const scoped_refptr<TestSocketParams>& params,
|
| + TestClientSocketPool* pool)
|
| : group_name_(group_name),
|
| params_(params),
|
| pool_(pool),
|
| callback_(base::Bind(&ConnectWithinCallback::OnComplete,
|
| - base::Unretained(this))) {
|
| - }
|
| + base::Unretained(this))) {}
|
|
|
| virtual ~ConnectWithinCallback() {}
|
|
|
| - int WaitForNestedResult() {
|
| - return nested_callback_.WaitForResult();
|
| - }
|
| + int WaitForNestedResult() { return nested_callback_.WaitForResult(); }
|
|
|
| const CompletionCallback& callback() const { return callback_; }
|
|
|
| @@ -2754,12 +2707,13 @@ TEST_F(ClientSocketPoolBaseTest, AbortAllRequestsOnFlush) {
|
|
|
| ClientSocketHandle handle;
|
| ConnectWithinCallback callback("a", params_, pool_.get());
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| // Second job will be started during the first callback, and will
|
| // asynchronously complete with OK.
|
| @@ -2781,24 +2735,26 @@ TEST_F(ClientSocketPoolBaseTest, BackupSocketCancelAtMaxSockets) {
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("bar",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| // Start (MaxSockets - 1) connected sockets to reach max sockets.
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
|
| ClientSocketHandle handles[kDefaultMaxSockets];
|
| for (int i = 1; i < kDefaultMaxSockets; ++i) {
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(OK, handles[i].Init("bar",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handles[i].Init("bar",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| }
|
|
|
| base::MessageLoop::current()->RunUntilIdle();
|
| @@ -2823,12 +2779,13 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterCancelingAllRequests) {
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("bar",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| ASSERT_TRUE(pool_->HasGroup("bar"));
|
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("bar"));
|
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("bar"));
|
| @@ -2853,21 +2810,23 @@ TEST_F(ClientSocketPoolBaseTest, CancelBackupSocketAfterFinishingAllRequests) {
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockWaitingJob);
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("bar",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("bar",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("bar",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle2.Init("bar",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| ASSERT_TRUE(pool_->HasGroup("bar"));
|
| EXPECT_EQ(2, pool_->NumConnectJobsInGroup("bar"));
|
|
|
| @@ -3110,29 +3069,32 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle2.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| ClientSocketHandle handle3;
|
| TestCompletionCallback callback3;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback3.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle3.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback3.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| EXPECT_EQ(OK, callback1.WaitForResult());
|
| EXPECT_EQ(OK, callback2.WaitForResult());
|
| @@ -3146,24 +3108,27 @@ TEST_F(ClientSocketPoolBaseTest, PreferUsedSocketToUnusedSocket) {
|
| handle2.Reset();
|
| handle3.Reset();
|
|
|
| - EXPECT_EQ(OK, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| - EXPECT_EQ(OK, handle2.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| - EXPECT_EQ(OK, handle3.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback3.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle2.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle3.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback3.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| EXPECT_TRUE(handle1.socket()->WasEverUsed());
|
| EXPECT_TRUE(handle2.socket()->WasEverUsed());
|
| @@ -3183,21 +3148,23 @@ TEST_F(ClientSocketPoolBaseTest, RequestSockets) {
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle2.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
|
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
|
| @@ -3219,12 +3186,13 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ASSERT_TRUE(pool_->HasGroup("a"));
|
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
|
| @@ -3239,12 +3207,13 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsWhenAlreadyHaveAConnectJob) {
|
|
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle2.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| EXPECT_EQ(2, pool_->NumConnectJobsInGroup("a"));
|
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
|
| @@ -3267,30 +3236,33 @@ TEST_F(ClientSocketPoolBaseTest,
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle2.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ClientSocketHandle handle3;
|
| TestCompletionCallback callback3;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle3.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback3.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle3.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback3.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ASSERT_TRUE(pool_->HasGroup("a"));
|
| EXPECT_EQ(3, pool_->NumConnectJobsInGroup("a"));
|
| @@ -3321,8 +3293,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
|
|
|
| ASSERT_FALSE(pool_->HasGroup("a"));
|
|
|
| - pool_->RequestSockets("a", ¶ms_, kDefaultMaxSockets,
|
| - BoundNetLog());
|
| + pool_->RequestSockets("a", ¶ms_, kDefaultMaxSockets, BoundNetLog());
|
|
|
| ASSERT_TRUE(pool_->HasGroup("a"));
|
| EXPECT_EQ(kDefaultMaxSockets, pool_->NumConnectJobsInGroup("a"));
|
| @@ -3330,8 +3301,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsAtMaxSocketLimit) {
|
|
|
| ASSERT_FALSE(pool_->HasGroup("b"));
|
|
|
| - pool_->RequestSockets("b", ¶ms_, kDefaultMaxSockets,
|
| - BoundNetLog());
|
| + pool_->RequestSockets("b", ¶ms_, kDefaultMaxSockets, BoundNetLog());
|
|
|
| ASSERT_FALSE(pool_->HasGroup("b"));
|
| }
|
| @@ -3342,8 +3312,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
|
|
|
| ASSERT_FALSE(pool_->HasGroup("a"));
|
|
|
| - pool_->RequestSockets("a", ¶ms_, kDefaultMaxSockets - 1,
|
| - BoundNetLog());
|
| + pool_->RequestSockets("a", ¶ms_, kDefaultMaxSockets - 1, BoundNetLog());
|
|
|
| ASSERT_TRUE(pool_->HasGroup("a"));
|
| EXPECT_EQ(kDefaultMaxSockets - 1, pool_->NumConnectJobsInGroup("a"));
|
| @@ -3353,8 +3322,7 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsHitMaxSocketLimit) {
|
|
|
| ASSERT_FALSE(pool_->HasGroup("b"));
|
|
|
| - pool_->RequestSockets("b", ¶ms_, kDefaultMaxSockets,
|
| - BoundNetLog());
|
| + pool_->RequestSockets("b", ¶ms_, kDefaultMaxSockets, BoundNetLog());
|
|
|
| ASSERT_TRUE(pool_->HasGroup("b"));
|
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("b"));
|
| @@ -3367,12 +3335,13 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountIdleSockets) {
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| ASSERT_EQ(OK, callback1.WaitForResult());
|
| handle1.Reset();
|
|
|
| @@ -3394,12 +3363,13 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsCountActiveSockets) {
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| ASSERT_EQ(OK, callback1.WaitForResult());
|
|
|
| ASSERT_TRUE(pool_->HasGroup("a"));
|
| @@ -3420,16 +3390,16 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronous) {
|
| CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
|
|
|
| - pool_->RequestSockets("a", ¶ms_, kDefaultMaxSocketsPerGroup,
|
| - BoundNetLog());
|
| + pool_->RequestSockets(
|
| + "a", ¶ms_, kDefaultMaxSocketsPerGroup, BoundNetLog());
|
|
|
| ASSERT_TRUE(pool_->HasGroup("a"));
|
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
|
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
|
| EXPECT_EQ(kDefaultMaxSocketsPerGroup, pool_->IdleSocketCountInGroup("a"));
|
|
|
| - pool_->RequestSockets("b", ¶ms_, kDefaultMaxSocketsPerGroup,
|
| - BoundNetLog());
|
| + pool_->RequestSockets(
|
| + "b", ¶ms_, kDefaultMaxSocketsPerGroup, BoundNetLog());
|
|
|
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("b"));
|
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("b"));
|
| @@ -3440,15 +3410,15 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsSynchronousError) {
|
| CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
|
|
|
| - pool_->RequestSockets("a", ¶ms_, kDefaultMaxSocketsPerGroup,
|
| - BoundNetLog());
|
| + pool_->RequestSockets(
|
| + "a", ¶ms_, kDefaultMaxSocketsPerGroup, BoundNetLog());
|
|
|
| ASSERT_FALSE(pool_->HasGroup("a"));
|
|
|
| connect_job_factory_->set_job_type(
|
| TestConnectJob::kMockAdditionalErrorStateJob);
|
| - pool_->RequestSockets("a", ¶ms_, kDefaultMaxSocketsPerGroup,
|
| - BoundNetLog());
|
| + pool_->RequestSockets(
|
| + "a", ¶ms_, kDefaultMaxSocketsPerGroup, BoundNetLog());
|
|
|
| ASSERT_FALSE(pool_->HasGroup("a"));
|
| }
|
| @@ -3471,12 +3441,13 @@ TEST_F(ClientSocketPoolBaseTest, RequestSocketsMultipleTimesDoesNothing) {
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| ASSERT_EQ(OK, callback1.WaitForResult());
|
|
|
| ClientSocketHandle handle2;
|
| @@ -3550,12 +3521,13 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectJobsTakenByNormalRequests) {
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
|
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
|
| @@ -3585,12 +3557,13 @@ TEST_F(ClientSocketPoolBaseTest, ConnectedPreconnectJobsHaveNoConnectTimes) {
|
|
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(OK, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| // Make sure the idle socket was used.
|
| EXPECT_EQ(0, pool_->IdleSocketCountInGroup("a"));
|
| @@ -3613,12 +3586,13 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
|
| // Set up one idle socket in "a".
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ASSERT_EQ(OK, callback1.WaitForResult());
|
| handle1.Reset();
|
| @@ -3627,18 +3601,20 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectClosesIdleSocketRemovesGroup) {
|
| // Set up two active sockets in "b".
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle1.Init("b",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| - EXPECT_EQ(ERR_IO_PENDING, handle2.Init("b",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle1.Init("b",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle2.Init("b",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ASSERT_EQ(OK, callback1.WaitForResult());
|
| ASSERT_EQ(OK, callback2.WaitForResult());
|
| @@ -3721,12 +3697,13 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithBackupJob) {
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| // Timer has started, but the backup connect job shouldn't be created yet.
|
| EXPECT_EQ(1, pool_->NumConnectJobsInGroup("a"));
|
| EXPECT_EQ(0, pool_->NumUnassignedConnectJobsInGroup("a"));
|
| @@ -3760,12 +3737,13 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockFailingJob);
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(OK, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| ASSERT_TRUE(pool_->HasGroup("a"));
|
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
|
| @@ -3784,30 +3762,33 @@ TEST_F(ClientSocketPoolBaseTest, PreconnectWithUnreadData) {
|
|
|
| class MockLayeredPool : public HigherLayeredPool {
|
| public:
|
| - MockLayeredPool(TestClientSocketPool* pool,
|
| - const std::string& group_name)
|
| - : pool_(pool),
|
| - group_name_(group_name),
|
| - can_release_connection_(true) {
|
| + MockLayeredPool(TestClientSocketPool* pool, const std::string& group_name)
|
| + : pool_(pool), group_name_(group_name), can_release_connection_(true) {
|
| pool_->AddHigherLayeredPool(this);
|
| }
|
|
|
| - ~MockLayeredPool() {
|
| - pool_->RemoveHigherLayeredPool(this);
|
| - }
|
| + ~MockLayeredPool() { pool_->RemoveHigherLayeredPool(this); }
|
|
|
| int RequestSocket(TestClientSocketPool* pool) {
|
| scoped_refptr<TestSocketParams> params(
|
| new TestSocketParams(false /* ignore_limits */));
|
| - return handle_.Init(group_name_, params, DEFAULT_PRIORITY,
|
| - callback_.callback(), pool, BoundNetLog());
|
| + return handle_.Init(group_name_,
|
| + params,
|
| + DEFAULT_PRIORITY,
|
| + callback_.callback(),
|
| + pool,
|
| + BoundNetLog());
|
| }
|
|
|
| int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
|
| scoped_refptr<TestSocketParams> params(
|
| new TestSocketParams(true /* ignore_limits */));
|
| - return handle_.Init(group_name_, params, MAXIMUM_PRIORITY,
|
| - callback_.callback(), pool, BoundNetLog());
|
| + return handle_.Init(group_name_,
|
| + params,
|
| + MAXIMUM_PRIORITY,
|
| + callback_.callback(),
|
| + pool,
|
| + BoundNetLog());
|
| }
|
|
|
| bool ReleaseOneConnection() {
|
| @@ -3850,9 +3831,8 @@ TEST_F(ClientSocketPoolBaseTest, ForciblyCloseIdleSocketsHeldByLayeredPool) {
|
|
|
| MockLayeredPool mock_layered_pool(pool_.get(), "foo");
|
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
|
| - EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
|
| - .WillOnce(Invoke(&mock_layered_pool,
|
| - &MockLayeredPool::ReleaseOneConnection));
|
| + EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()).WillOnce(
|
| + Invoke(&mock_layered_pool, &MockLayeredPool::ReleaseOneConnection));
|
| EXPECT_TRUE(pool_->CloseOneIdleConnectionInHigherLayeredPool());
|
| }
|
|
|
| @@ -3864,17 +3844,17 @@ TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
|
|
|
| MockLayeredPool mock_layered_pool(pool_.get(), "foo");
|
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
|
| - EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
|
| - .WillOnce(Invoke(&mock_layered_pool,
|
| - &MockLayeredPool::ReleaseOneConnection));
|
| + EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()).WillOnce(
|
| + Invoke(&mock_layered_pool, &MockLayeredPool::ReleaseOneConnection));
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_EQ(OK, callback.WaitForResult());
|
| }
|
|
|
| @@ -3892,26 +3872,27 @@ TEST_F(ClientSocketPoolBaseTest,
|
| // has the maximum number of connections already, it's not stalled).
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(OK, handle1.Init("group1",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle1.Init("group1",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| MockLayeredPool mock_layered_pool(pool_.get(), "group2");
|
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
|
| - EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
|
| - .WillOnce(Invoke(&mock_layered_pool,
|
| - &MockLayeredPool::ReleaseOneConnection));
|
| + EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()).WillOnce(
|
| + Invoke(&mock_layered_pool, &MockLayeredPool::ReleaseOneConnection));
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback2;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback2.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("group2",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback2.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_EQ(OK, callback2.WaitForResult());
|
| }
|
|
|
| @@ -3929,29 +3910,30 @@ TEST_F(ClientSocketPoolBaseTest,
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(OK, handle1.Init("group1",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle1.Init("group1",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| MockLayeredPool mock_layered_pool(pool_.get(), "group2");
|
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
|
| - EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
|
| - .WillRepeatedly(Invoke(&mock_layered_pool,
|
| - &MockLayeredPool::ReleaseOneConnection));
|
| + EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()).WillRepeatedly(
|
| + Invoke(&mock_layered_pool, &MockLayeredPool::ReleaseOneConnection));
|
| mock_layered_pool.set_can_release_connection(false);
|
|
|
| // The third request is made when the socket pool is in a stalled state.
|
| ClientSocketHandle handle3;
|
| TestCompletionCallback callback3;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback3.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle3.Init("group3",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback3.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| base::RunLoop().RunUntilIdle();
|
| EXPECT_FALSE(callback3.have_result());
|
| @@ -3962,12 +3944,13 @@ TEST_F(ClientSocketPoolBaseTest,
|
| mock_layered_pool.set_can_release_connection(true);
|
| ClientSocketHandle handle4;
|
| TestCompletionCallback callback4;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback4.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle4.Init("group3",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback4.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_EQ(OK, callback3.WaitForResult());
|
| EXPECT_FALSE(callback4.have_result());
|
|
|
| @@ -3994,29 +3977,30 @@ TEST_F(ClientSocketPoolBaseTest,
|
|
|
| ClientSocketHandle handle1;
|
| TestCompletionCallback callback1;
|
| - EXPECT_EQ(OK, handle1.Init("group1",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback1.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(OK,
|
| + handle1.Init("group1",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback1.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| MockLayeredPool mock_layered_pool(pool_.get(), "group2");
|
| EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
|
| - EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
|
| - .WillRepeatedly(Invoke(&mock_layered_pool,
|
| - &MockLayeredPool::ReleaseOneConnection));
|
| + EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection()).WillRepeatedly(
|
| + Invoke(&mock_layered_pool, &MockLayeredPool::ReleaseOneConnection));
|
| mock_layered_pool.set_can_release_connection(false);
|
|
|
| // The third request is made when the socket pool is in a stalled state.
|
| ClientSocketHandle handle3;
|
| TestCompletionCallback callback3;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle3.Init("group3",
|
| - params_,
|
| - MEDIUM,
|
| - callback3.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle3.Init("group3",
|
| + params_,
|
| + MEDIUM,
|
| + callback3.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
|
|
| base::RunLoop().RunUntilIdle();
|
| EXPECT_FALSE(callback3.have_result());
|
| @@ -4026,12 +4010,13 @@ TEST_F(ClientSocketPoolBaseTest,
|
| mock_layered_pool.set_can_release_connection(true);
|
| ClientSocketHandle handle4;
|
| TestCompletionCallback callback4;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
|
| - params_,
|
| - HIGHEST,
|
| - callback4.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle4.Init("group3",
|
| + params_,
|
| + HIGHEST,
|
| + callback4.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_EQ(OK, callback4.WaitForResult());
|
| EXPECT_FALSE(callback3.have_result());
|
|
|
| @@ -4047,22 +4032,21 @@ TEST_F(ClientSocketPoolBaseTest,
|
|
|
| MockLayeredPool mock_layered_pool1(pool_.get(), "foo");
|
| EXPECT_EQ(OK, mock_layered_pool1.RequestSocket(pool_.get()));
|
| - EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection())
|
| - .WillRepeatedly(Invoke(&mock_layered_pool1,
|
| - &MockLayeredPool::ReleaseOneConnection));
|
| + EXPECT_CALL(mock_layered_pool1, CloseOneIdleConnection()).WillRepeatedly(
|
| + Invoke(&mock_layered_pool1, &MockLayeredPool::ReleaseOneConnection));
|
| MockLayeredPool mock_layered_pool2(pool_.get(), "bar");
|
| EXPECT_EQ(OK, mock_layered_pool2.RequestSocketWithoutLimits(pool_.get()));
|
| - EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection())
|
| - .WillRepeatedly(Invoke(&mock_layered_pool2,
|
| - &MockLayeredPool::ReleaseOneConnection));
|
| + EXPECT_CALL(mock_layered_pool2, CloseOneIdleConnection()).WillRepeatedly(
|
| + Invoke(&mock_layered_pool2, &MockLayeredPool::ReleaseOneConnection));
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| - EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
|
| - params_,
|
| - DEFAULT_PRIORITY,
|
| - callback.callback(),
|
| - pool_.get(),
|
| - BoundNetLog()));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + handle.Init("a",
|
| + params_,
|
| + DEFAULT_PRIORITY,
|
| + callback.callback(),
|
| + pool_.get(),
|
| + BoundNetLog()));
|
| EXPECT_EQ(OK, callback.WaitForResult());
|
| }
|
|
|
| @@ -4081,12 +4065,13 @@ TEST_F(ClientSocketPoolBaseTest, IgnoreLimits) {
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
|
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
|
| - params_));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
|
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
|
|
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
|
| - params_ignore_limits));
|
| + EXPECT_EQ(
|
| + ERR_IO_PENDING,
|
| + StartRequestWithParams("a", MAXIMUM_PRIORITY, params_ignore_limits));
|
| ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
|
|
|
| EXPECT_EQ(OK, request(2)->WaitForResult());
|
| @@ -4107,12 +4092,13 @@ TEST_F(ClientSocketPoolBaseTest, IgnoreLimitsCancelOtherJob) {
|
|
|
| connect_job_factory_->set_job_type(TestConnectJob::kMockPendingJob);
|
|
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
|
| - params_));
|
| + EXPECT_EQ(ERR_IO_PENDING,
|
| + StartRequestWithParams("a", MAXIMUM_PRIORITY, params_));
|
| EXPECT_EQ(0, pool_->NumConnectJobsInGroup("a"));
|
|
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequestWithParams("a", MAXIMUM_PRIORITY,
|
| - params_ignore_limits));
|
| + EXPECT_EQ(
|
| + ERR_IO_PENDING,
|
| + StartRequestWithParams("a", MAXIMUM_PRIORITY, params_ignore_limits));
|
| ASSERT_EQ(1, pool_->NumConnectJobsInGroup("a"));
|
|
|
| // Cancel the pending request without ignore_limits set. The ConnectJob
|
|
|
Chromium Code Reviews
