When a new request comes in to a socket pool, and that
request's group is stalled due to the pool hitting the
connection limit, try to close idle sockets in higher
level pools.
CLs to do this have been landed and reverted in the
past, due to crashes. This CL attempts to avoid such
crashes by reducing re-entracy. Idle sockets are closed
asynchronously, and the CL relies on that automatically
triggering use of the freed up socket slot.
BUG=92244
Review URL: https://codereview.chromium.org/14308013
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@195540 0039d316-1c4b-4281-b951-d872f2087c98
diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc
index bc64306..81b6802 100644
--- a/net/socket/client_socket_pool_base_unittest.cc
+++ b/net/socket/client_socket_pool_base_unittest.cc
@@ -3562,6 +3562,290 @@
EXPECT_EQ(1, pool_->NumActiveSocketsInGroup("a"));
}
+class MockLayeredPool : public LayeredPool {
+ public:
+ MockLayeredPool(TestClientSocketPool* pool,
+ const std::string& group_name)
+ : pool_(pool),
+ params_(new TestSocketParams),
+ group_name_(group_name),
+ can_release_connection_(true) {
+ pool_->AddLayeredPool(this);
+ }
+
+ ~MockLayeredPool() {
+ pool_->RemoveLayeredPool(this);
+ }
+
+ int RequestSocket(TestClientSocketPool* pool) {
+ return handle_.Init(group_name_, params_, kDefaultPriority,
+ callback_.callback(), pool, BoundNetLog());
+ }
+
+ int RequestSocketWithoutLimits(TestClientSocketPool* pool) {
+ params_->set_ignore_limits(true);
+ return handle_.Init(group_name_, params_, kDefaultPriority,
+ callback_.callback(), pool, BoundNetLog());
+ }
+
+ bool ReleaseOneConnection() {
+ if (!handle_.is_initialized() || !can_release_connection_) {
+ return false;
+ }
+ handle_.socket()->Disconnect();
+ handle_.Reset();
+ return true;
+ }
+
+ void set_can_release_connection(bool can_release_connection) {
+ can_release_connection_ = can_release_connection;
+ }
+
+ MOCK_METHOD0(CloseOneIdleConnection, bool());
+
+ private:
+ TestClientSocketPool* const pool_;
+ scoped_refptr<TestSocketParams> params_;
+ ClientSocketHandle handle_;
+ TestCompletionCallback callback_;
+ const std::string group_name_;
+ bool can_release_connection_;
+};
+
+TEST_F(ClientSocketPoolBaseTest, FailToCloseIdleSocketsNotHeldByLayeredPool) {
+ CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
+ connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
+
+ MockLayeredPool mock_layered_pool(pool_.get(), "foo");
+ EXPECT_EQ(OK, mock_layered_pool.RequestSocket(pool_.get()));
+ EXPECT_CALL(mock_layered_pool, CloseOneIdleConnection())
+ .WillOnce(Return(false));
+ EXPECT_FALSE(pool_->CloseOneIdleConnectionInLayeredPool());
+}
+
+TEST_F(ClientSocketPoolBaseTest, ForciblyCloseIdleSocketsHeldByLayeredPool) {
+ CreatePool(kDefaultMaxSockets, kDefaultMaxSocketsPerGroup);
+ connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
+
+ 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_TRUE(pool_->CloseOneIdleConnectionInLayeredPool());
+}
+
+// Tests the basic case of closing an idle socket in a higher layered pool when
+// a new request is issued and the lower layer pool is stalled.
+TEST_F(ClientSocketPoolBaseTest, CloseIdleSocketsHeldByLayeredPoolWhenNeeded) {
+ CreatePool(1, 1);
+ connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
+
+ 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));
+ ClientSocketHandle handle;
+ TestCompletionCallback callback;
+ EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
+ params_,
+ kDefaultPriority,
+ callback.callback(),
+ pool_.get(),
+ BoundNetLog()));
+ EXPECT_EQ(OK, callback.WaitForResult());
+}
+
+// Same as above, but the idle socket is in the same group as the stalled
+// socket, and closes the only other request in its group when closing requests
+// in higher layered pools. This generally shouldn't happen, but it may be
+// possible if a higher level pool issues a request and the request is
+// subsequently cancelled. Even if it's not possible, best not to crash.
+TEST_F(ClientSocketPoolBaseTest,
+ CloseIdleSocketsHeldByLayeredPoolWhenNeededSameGroup) {
+ CreatePool(2, 2);
+ connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
+
+ // Need a socket in another group for the pool to be stalled (If a group
+ // has the maximum number of connections already, it's not stalled).
+ ClientSocketHandle handle1;
+ TestCompletionCallback callback1;
+ EXPECT_EQ(OK, handle1.Init("group1",
+ params_,
+ kDefaultPriority,
+ 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));
+ ClientSocketHandle handle;
+ TestCompletionCallback callback2;
+ EXPECT_EQ(ERR_IO_PENDING, handle.Init("group2",
+ params_,
+ kDefaultPriority,
+ callback2.callback(),
+ pool_.get(),
+ BoundNetLog()));
+ EXPECT_EQ(OK, callback2.WaitForResult());
+}
+
+// Tests the case when an idle socket can be closed when a new request is
+// issued, and the new request belongs to a group that was previously stalled.
+TEST_F(ClientSocketPoolBaseTest,
+ CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded) {
+ CreatePool(2, 2);
+ std::list<TestConnectJob::JobType> job_types;
+ job_types.push_back(TestConnectJob::kMockJob);
+ job_types.push_back(TestConnectJob::kMockJob);
+ job_types.push_back(TestConnectJob::kMockJob);
+ job_types.push_back(TestConnectJob::kMockJob);
+ connect_job_factory_->set_job_types(&job_types);
+
+ ClientSocketHandle handle1;
+ TestCompletionCallback callback1;
+ EXPECT_EQ(OK, handle1.Init("group1",
+ params_,
+ kDefaultPriority,
+ 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));
+ 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_,
+ kDefaultPriority,
+ callback3.callback(),
+ pool_.get(),
+ BoundNetLog()));
+
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(callback3.have_result());
+
+ // The fourth request is made when the pool is no longer stalled. The third
+ // request should be serviced first, since it was issued first and has the
+ // same priority.
+ mock_layered_pool.set_can_release_connection(true);
+ ClientSocketHandle handle4;
+ TestCompletionCallback callback4;
+ EXPECT_EQ(ERR_IO_PENDING, handle4.Init("group3",
+ params_,
+ kDefaultPriority,
+ callback4.callback(),
+ pool_.get(),
+ BoundNetLog()));
+ EXPECT_EQ(OK, callback3.WaitForResult());
+ EXPECT_FALSE(callback4.have_result());
+
+ // Closing a handle should free up another socket slot.
+ handle1.Reset();
+ EXPECT_EQ(OK, callback4.WaitForResult());
+}
+
+// Tests the case when an idle socket can be closed when a new request is
+// issued, and the new request belongs to a group that was previously stalled.
+//
+// The two differences from the above test are that the stalled requests are not
+// in the same group as the layered pool's request, and the the fourth request
+// has a higher priority than the third one, so gets a socket first.
+TEST_F(ClientSocketPoolBaseTest,
+ CloseIdleSocketsHeldByLayeredPoolInSameGroupWhenNeeded2) {
+ CreatePool(2, 2);
+ std::list<TestConnectJob::JobType> job_types;
+ job_types.push_back(TestConnectJob::kMockJob);
+ job_types.push_back(TestConnectJob::kMockJob);
+ job_types.push_back(TestConnectJob::kMockJob);
+ job_types.push_back(TestConnectJob::kMockJob);
+ connect_job_factory_->set_job_types(&job_types);
+
+ ClientSocketHandle handle1;
+ TestCompletionCallback callback1;
+ EXPECT_EQ(OK, handle1.Init("group1",
+ params_,
+ kDefaultPriority,
+ 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));
+ 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()));
+
+ base::RunLoop().RunUntilIdle();
+ EXPECT_FALSE(callback3.have_result());
+
+ // The fourth request is made when the pool is no longer stalled. This
+ // request has a higher priority than the third request, so is serviced first.
+ 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(OK, callback4.WaitForResult());
+ EXPECT_FALSE(callback3.have_result());
+
+ // Closing a handle should free up another socket slot.
+ handle1.Reset();
+ EXPECT_EQ(OK, callback3.WaitForResult());
+}
+
+TEST_F(ClientSocketPoolBaseTest,
+ CloseMultipleIdleSocketsHeldByLayeredPoolWhenNeeded) {
+ CreatePool(1, 1);
+ connect_job_factory_->set_job_type(TestConnectJob::kMockJob);
+
+ 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));
+ 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));
+ ClientSocketHandle handle;
+ TestCompletionCallback callback;
+ EXPECT_EQ(ERR_IO_PENDING, handle.Init("a",
+ params_,
+ kDefaultPriority,
+ callback.callback(),
+ pool_.get(),
+ BoundNetLog()));
+ EXPECT_EQ(OK, callback.WaitForResult());
+}
+
+
} // namespace
} // namespace net
