| Index: net/socket/websocket_transport_client_socket_pool_unittest.cc
|
| diff --git a/net/socket/transport_client_socket_pool_unittest.cc b/net/socket/websocket_transport_client_socket_pool_unittest.cc
|
| similarity index 50%
|
| copy from net/socket/transport_client_socket_pool_unittest.cc
|
| copy to net/socket/websocket_transport_client_socket_pool_unittest.cc
|
| index ff85847979b692231b4b6558722ab78f47136cdc..6419d5fc939cd9ef9afb0b0d8f3d0d4b8f6fa020 100644
|
| --- a/net/socket/transport_client_socket_pool_unittest.cc
|
| +++ b/net/socket/websocket_transport_client_socket_pool_unittest.cc
|
| @@ -2,7 +2,7 @@
|
| // Use of this source code is governed by a BSD-style license that can be
|
| // found in the LICENSE file.
|
|
|
| -#include "net/socket/transport_client_socket_pool.h"
|
| +#include "net/socket/websocket_transport_client_socket_pool.h"
|
|
|
| #include "base/bind.h"
|
| #include "base/bind_helpers.h"
|
| @@ -89,25 +89,19 @@ class MockClientSocket : public StreamSocket {
|
| MockClientSocket(const AddressList& addrlist, net::NetLog* net_log)
|
| : connected_(false),
|
| addrlist_(addrlist),
|
| - net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
|
| - }
|
| + net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {}
|
|
|
| // StreamSocket implementation.
|
| virtual int Connect(const CompletionCallback& callback) OVERRIDE {
|
| connected_ = true;
|
| return OK;
|
| }
|
| - virtual void Disconnect() OVERRIDE {
|
| - connected_ = false;
|
| - }
|
| - virtual bool IsConnected() const OVERRIDE {
|
| - return connected_;
|
| - }
|
| - virtual bool IsConnectedAndIdle() const OVERRIDE {
|
| - return connected_;
|
| - }
|
| + virtual void Disconnect() OVERRIDE { connected_ = false; }
|
| + virtual bool IsConnected() const OVERRIDE { return connected_; }
|
| + virtual bool IsConnectedAndIdle() const OVERRIDE { return connected_; }
|
| virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
|
| - return ERR_UNEXPECTED;
|
| + *address = addrlist_.front();
|
| + return OK;
|
| }
|
| virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
|
| if (!connected_)
|
| @@ -118,30 +112,26 @@ class MockClientSocket : public StreamSocket {
|
| SetIPv6Address(address);
|
| return OK;
|
| }
|
| - 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 false; }
|
| 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; }
|
|
|
| // Socket implementation.
|
| - virtual int Read(IOBuffer* buf, int buf_len,
|
| + virtual int Read(IOBuffer* buf,
|
| + int buf_len,
|
| const CompletionCallback& callback) OVERRIDE {
|
| return ERR_FAILED;
|
| }
|
| - virtual int Write(IOBuffer* buf, int buf_len,
|
| + virtual int Write(IOBuffer* buf,
|
| + int buf_len,
|
| const CompletionCallback& callback) OVERRIDE {
|
| return ERR_FAILED;
|
| }
|
| @@ -160,8 +150,7 @@ class MockFailingClientSocket : public StreamSocket {
|
| public:
|
| MockFailingClientSocket(const AddressList& addrlist, net::NetLog* net_log)
|
| : addrlist_(addrlist),
|
| - net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {
|
| - }
|
| + net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)) {}
|
|
|
| // StreamSocket implementation.
|
| virtual int Connect(const CompletionCallback& callback) OVERRIDE {
|
| @@ -170,43 +159,35 @@ class MockFailingClientSocket : public StreamSocket {
|
|
|
| virtual void Disconnect() OVERRIDE {}
|
|
|
| - virtual bool IsConnected() const OVERRIDE {
|
| - return false;
|
| - }
|
| - virtual bool IsConnectedAndIdle() const OVERRIDE {
|
| - return false;
|
| - }
|
| + virtual bool IsConnected() const OVERRIDE { return false; }
|
| + virtual bool IsConnectedAndIdle() const OVERRIDE { return false; }
|
| virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
|
| return ERR_UNEXPECTED;
|
| }
|
| virtual int GetLocalAddress(IPEndPoint* address) const OVERRIDE {
|
| 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 false; }
|
| 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; }
|
|
|
| // Socket implementation.
|
| - virtual int Read(IOBuffer* buf, int buf_len,
|
| + virtual int Read(IOBuffer* buf,
|
| + int buf_len,
|
| const CompletionCallback& callback) OVERRIDE {
|
| return ERR_FAILED;
|
| }
|
|
|
| - virtual int Write(IOBuffer* buf, int buf_len,
|
| + virtual int Write(IOBuffer* buf,
|
| + int buf_len,
|
| const CompletionCallback& callback) OVERRIDE {
|
| return ERR_FAILED;
|
| }
|
| @@ -226,39 +207,34 @@ class MockPendingClientSocket : public StreamSocket {
|
| // or fail.
|
| // |should_stall| indicates that this socket should never connect.
|
| // |delay_ms| is the delay, in milliseconds, before simulating a connect.
|
| - MockPendingClientSocket(
|
| - const AddressList& addrlist,
|
| - bool should_connect,
|
| - bool should_stall,
|
| - base::TimeDelta delay,
|
| - net::NetLog* net_log)
|
| + MockPendingClientSocket(const AddressList& addrlist,
|
| + bool should_connect,
|
| + bool should_stall,
|
| + base::TimeDelta delay,
|
| + net::NetLog* net_log)
|
| : should_connect_(should_connect),
|
| should_stall_(should_stall),
|
| delay_(delay),
|
| is_connected_(false),
|
| addrlist_(addrlist),
|
| net_log_(BoundNetLog::Make(net_log, NetLog::SOURCE_SOCKET)),
|
| - weak_factory_(this) {
|
| - }
|
| + weak_factory_(this) {}
|
|
|
| // StreamSocket implementation.
|
| virtual int Connect(const CompletionCallback& callback) OVERRIDE {
|
| base::MessageLoop::current()->PostDelayedTask(
|
| FROM_HERE,
|
| base::Bind(&MockPendingClientSocket::DoCallback,
|
| - weak_factory_.GetWeakPtr(), callback),
|
| + weak_factory_.GetWeakPtr(),
|
| + callback),
|
| delay_);
|
| return ERR_IO_PENDING;
|
| }
|
|
|
| virtual void Disconnect() OVERRIDE {}
|
|
|
| - virtual bool IsConnected() const OVERRIDE {
|
| - return is_connected_;
|
| - }
|
| - virtual bool IsConnectedAndIdle() const OVERRIDE {
|
| - return is_connected_;
|
| - }
|
| + virtual bool IsConnected() const OVERRIDE { return is_connected_; }
|
| + virtual bool IsConnectedAndIdle() const OVERRIDE { return is_connected_; }
|
| virtual int GetPeerAddress(IPEndPoint* address) const OVERRIDE {
|
| return ERR_UNEXPECTED;
|
| }
|
| @@ -271,31 +247,27 @@ class MockPendingClientSocket : public StreamSocket {
|
| SetIPv6Address(address);
|
| return OK;
|
| }
|
| - 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 false; }
|
| 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; }
|
|
|
| // Socket implementation.
|
| - virtual int Read(IOBuffer* buf, int buf_len,
|
| + virtual int Read(IOBuffer* buf,
|
| + int buf_len,
|
| const CompletionCallback& callback) OVERRIDE {
|
| return ERR_FAILED;
|
| }
|
|
|
| - virtual int Write(IOBuffer* buf, int buf_len,
|
| + virtual int Write(IOBuffer* buf,
|
| + int buf_len,
|
| const CompletionCallback& callback) OVERRIDE {
|
| return ERR_FAILED;
|
| }
|
| @@ -342,9 +314,12 @@ class MockClientSocketFactory : public ClientSocketFactory {
|
| };
|
|
|
| explicit MockClientSocketFactory(NetLog* net_log)
|
| - : net_log_(net_log), allocation_count_(0),
|
| - client_socket_type_(MOCK_CLIENT_SOCKET), client_socket_types_(NULL),
|
| - client_socket_index_(0), client_socket_index_max_(0),
|
| + : net_log_(net_log),
|
| + allocation_count_(0),
|
| + client_socket_type_(MOCK_CLIENT_SOCKET),
|
| + client_socket_types_(NULL),
|
| + client_socket_index_(0),
|
| + client_socket_index_max_(0),
|
| delay_(base::TimeDelta::FromMilliseconds(
|
| ClientSocketPool::kMaxConnectRetryIntervalMs)) {}
|
|
|
| @@ -377,21 +352,17 @@ class MockClientSocketFactory : public ClientSocketFactory {
|
| return scoped_ptr<StreamSocket>(
|
| new MockFailingClientSocket(addresses, net_log_));
|
| case MOCK_PENDING_CLIENT_SOCKET:
|
| - return scoped_ptr<StreamSocket>(
|
| - new MockPendingClientSocket(
|
| - addresses, true, false, base::TimeDelta(), net_log_));
|
| + return scoped_ptr<StreamSocket>(new MockPendingClientSocket(
|
| + addresses, true, false, base::TimeDelta(), net_log_));
|
| case MOCK_PENDING_FAILING_CLIENT_SOCKET:
|
| - return scoped_ptr<StreamSocket>(
|
| - new MockPendingClientSocket(
|
| - addresses, false, false, base::TimeDelta(), net_log_));
|
| + return scoped_ptr<StreamSocket>(new MockPendingClientSocket(
|
| + addresses, false, false, base::TimeDelta(), net_log_));
|
| case MOCK_DELAYED_CLIENT_SOCKET:
|
| - return scoped_ptr<StreamSocket>(
|
| - new MockPendingClientSocket(
|
| - addresses, true, false, delay_, net_log_));
|
| + return scoped_ptr<StreamSocket>(new MockPendingClientSocket(
|
| + addresses, true, false, delay_, net_log_));
|
| case MOCK_STALLED_CLIENT_SOCKET:
|
| - return scoped_ptr<StreamSocket>(
|
| - new MockPendingClientSocket(
|
| - addresses, true, true, base::TimeDelta(), net_log_));
|
| + return scoped_ptr<StreamSocket>(new MockPendingClientSocket(
|
| + addresses, true, true, base::TimeDelta(), net_log_));
|
| default:
|
| NOTREACHED();
|
| return scoped_ptr<StreamSocket>(
|
| @@ -408,9 +379,7 @@ class MockClientSocketFactory : public ClientSocketFactory {
|
| return scoped_ptr<SSLClientSocket>();
|
| }
|
|
|
| - virtual void ClearSSLSessionCache() OVERRIDE {
|
| - NOTIMPLEMENTED();
|
| - }
|
| + virtual void ClearSSLSessionCache() OVERRIDE { NOTIMPLEMENTED(); }
|
|
|
| int allocation_count() const { return allocation_count_; }
|
|
|
| @@ -441,15 +410,15 @@ class MockClientSocketFactory : public ClientSocketFactory {
|
| DISALLOW_COPY_AND_ASSIGN(MockClientSocketFactory);
|
| };
|
|
|
| -class TransportClientSocketPoolTest : public testing::Test {
|
| +class WebSocketTransportClientSocketPoolTest : public testing::Test {
|
| protected:
|
| - TransportClientSocketPoolTest()
|
| + WebSocketTransportClientSocketPoolTest()
|
| : connect_backup_jobs_enabled_(
|
| ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(true)),
|
| - params_(
|
| - new TransportSocketParams(HostPortPair("www.google.com", 80),
|
| - false, false,
|
| - OnHostResolutionCallback())),
|
| + params_(new TransportSocketParams(HostPortPair("www.google.com", 80),
|
| + false,
|
| + false,
|
| + OnHostResolutionCallback())),
|
| histograms_(new ClientSocketPoolHistograms("TCPUnitTest")),
|
| host_resolver_(new MockHostResolver),
|
| client_socket_factory_(&net_log_),
|
| @@ -458,18 +427,19 @@ class TransportClientSocketPoolTest : public testing::Test {
|
| histograms_.get(),
|
| host_resolver_.get(),
|
| &client_socket_factory_,
|
| - NULL) {
|
| - }
|
| + NULL) {}
|
|
|
| - virtual ~TransportClientSocketPoolTest() {
|
| + virtual ~WebSocketTransportClientSocketPoolTest() {
|
| internal::ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(
|
| connect_backup_jobs_enabled_);
|
| }
|
|
|
| int StartRequest(const std::string& group_name, RequestPriority priority) {
|
| - scoped_refptr<TransportSocketParams> params(new TransportSocketParams(
|
| - HostPortPair("www.google.com", 80), false, false,
|
| - OnHostResolutionCallback()));
|
| + scoped_refptr<TransportSocketParams> params(
|
| + new TransportSocketParams(HostPortPair("www.google.com", 80),
|
| + false,
|
| + false,
|
| + OnHostResolutionCallback()));
|
| return test_base_.StartRequestUsingPool(
|
| &pool_, group_name, priority, params);
|
| }
|
| @@ -495,88 +465,17 @@ class TransportClientSocketPoolTest : public testing::Test {
|
| scoped_ptr<ClientSocketPoolHistograms> histograms_;
|
| scoped_ptr<MockHostResolver> host_resolver_;
|
| MockClientSocketFactory client_socket_factory_;
|
| - TransportClientSocketPool pool_;
|
| + WebSocketTransportClientSocketPool pool_;
|
| ClientSocketPoolTest test_base_;
|
|
|
| - DISALLOW_COPY_AND_ASSIGN(TransportClientSocketPoolTest);
|
| + DISALLOW_COPY_AND_ASSIGN(WebSocketTransportClientSocketPoolTest);
|
| };
|
|
|
| -TEST(TransportConnectJobTest, MakeAddrListStartWithIPv4) {
|
| - IPAddressNumber ip_number;
|
| - ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.1", &ip_number));
|
| - IPEndPoint addrlist_v4_1(ip_number, 80);
|
| - ASSERT_TRUE(ParseIPLiteralToNumber("192.168.1.2", &ip_number));
|
| - IPEndPoint addrlist_v4_2(ip_number, 80);
|
| - ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::64", &ip_number));
|
| - IPEndPoint addrlist_v6_1(ip_number, 80);
|
| - ASSERT_TRUE(ParseIPLiteralToNumber("2001:4860:b006::66", &ip_number));
|
| - IPEndPoint addrlist_v6_2(ip_number, 80);
|
| -
|
| - AddressList addrlist;
|
| -
|
| - // Test 1: IPv4 only. Expect no change.
|
| - addrlist.clear();
|
| - addrlist.push_back(addrlist_v4_1);
|
| - addrlist.push_back(addrlist_v4_2);
|
| - TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
|
| - ASSERT_EQ(2u, addrlist.size());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily());
|
| -
|
| - // Test 2: IPv6 only. Expect no change.
|
| - addrlist.clear();
|
| - addrlist.push_back(addrlist_v6_1);
|
| - addrlist.push_back(addrlist_v6_2);
|
| - TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
|
| - ASSERT_EQ(2u, addrlist.size());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[0].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily());
|
| -
|
| - // Test 3: IPv4 then IPv6. Expect no change.
|
| - addrlist.clear();
|
| - addrlist.push_back(addrlist_v4_1);
|
| - addrlist.push_back(addrlist_v4_2);
|
| - addrlist.push_back(addrlist_v6_1);
|
| - addrlist.push_back(addrlist_v6_2);
|
| - TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
|
| - ASSERT_EQ(4u, addrlist.size());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily());
|
| -
|
| - // Test 4: IPv6, IPv4, IPv6, IPv4. Expect first IPv6 moved to the end.
|
| - addrlist.clear();
|
| - addrlist.push_back(addrlist_v6_1);
|
| - addrlist.push_back(addrlist_v4_1);
|
| - addrlist.push_back(addrlist_v6_2);
|
| - addrlist.push_back(addrlist_v4_2);
|
| - TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
|
| - ASSERT_EQ(4u, addrlist.size());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[1].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[2].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily());
|
| -
|
| - // Test 5: IPv6, IPv6, IPv4, IPv4. Expect first two IPv6's moved to the end.
|
| - addrlist.clear();
|
| - addrlist.push_back(addrlist_v6_1);
|
| - addrlist.push_back(addrlist_v6_2);
|
| - addrlist.push_back(addrlist_v4_1);
|
| - addrlist.push_back(addrlist_v4_2);
|
| - TransportConnectJob::MakeAddressListStartWithIPv4(&addrlist);
|
| - ASSERT_EQ(4u, addrlist.size());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[0].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV4, addrlist[1].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[2].GetFamily());
|
| - EXPECT_EQ(ADDRESS_FAMILY_IPV6, addrlist[3].GetFamily());
|
| -}
|
| -
|
| -TEST_F(TransportClientSocketPoolTest, Basic) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, Basic) {
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| - int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| + int rv = handle.Init(
|
| + "a", params_, LOW, callback.callback(), &pool_, BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle.is_initialized());
|
| EXPECT_FALSE(handle.socket());
|
| @@ -587,52 +486,67 @@ TEST_F(TransportClientSocketPoolTest, Basic) {
|
| TestLoadTimingInfoConnectedNotReused(handle);
|
| }
|
|
|
| -// Make sure that TransportConnectJob passes on its priority to its
|
| +// Make sure that WebSocketTransportConnectJob passes on its priority to its
|
| // HostResolver request on Init.
|
| -TEST_F(TransportClientSocketPoolTest, SetResolvePriorityOnInit) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, SetResolvePriorityOnInit) {
|
| for (int i = MINIMUM_PRIORITY; i <= MAXIMUM_PRIORITY; ++i) {
|
| RequestPriority priority = static_cast<RequestPriority>(i);
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle.Init("a", params_, priority, callback.callback(), &pool_,
|
| + handle.Init("a",
|
| + params_,
|
| + priority,
|
| + callback.callback(),
|
| + &pool_,
|
| BoundNetLog()));
|
| EXPECT_EQ(priority, host_resolver_->last_request_priority());
|
| }
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, InitHostResolutionFailure) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, InitHostResolutionFailure) {
|
| host_resolver_->rules()->AddSimulatedFailure("unresolvable.host.name");
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| HostPortPair host_port_pair("unresolvable.host.name", 80);
|
| scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
|
| - host_port_pair, false, false,
|
| - OnHostResolutionCallback()));
|
| + host_port_pair, false, false, OnHostResolutionCallback()));
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle.Init("a", dest, kDefaultPriority, callback.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle.Init("a",
|
| + dest,
|
| + kDefaultPriority,
|
| + callback.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
| EXPECT_EQ(ERR_NAME_NOT_RESOLVED, callback.WaitForResult());
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, InitConnectionFailure) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, InitConnectionFailure) {
|
| client_socket_factory_.set_client_socket_type(
|
| MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET);
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle.Init("a", params_, kDefaultPriority, callback.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle.Init("a",
|
| + params_,
|
| + kDefaultPriority,
|
| + callback.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
| EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
|
|
|
| // Make the host resolutions complete synchronously this time.
|
| host_resolver_->set_synchronous_mode(true);
|
| EXPECT_EQ(ERR_CONNECTION_FAILED,
|
| - handle.Init("a", params_, kDefaultPriority, callback.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle.Init("a",
|
| + params_,
|
| + kDefaultPriority,
|
| + callback.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, PendingRequests) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, PendingRequestsFinishFifo) {
|
| // First request finishes asynchronously.
|
| EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
|
| @@ -640,33 +554,21 @@ TEST_F(TransportClientSocketPoolTest, PendingRequests) {
|
| // Make all subsequent host resolutions complete synchronously.
|
| host_resolver_->set_synchronous_mode(true);
|
|
|
| - // Rest of them finish synchronously, until we reach the per-group limit.
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| -
|
| - // The rest are pending since we've used all active sockets.
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
|
| + // Rest of them wait for the first socket to be released.
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
|
|
| ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
|
|
|
| - EXPECT_EQ(kMaxSocketsPerGroup, client_socket_factory_.allocation_count());
|
| + EXPECT_EQ(6, client_socket_factory_.allocation_count());
|
|
|
| - // One initial asynchronous request and then 10 pending requests.
|
| - EXPECT_EQ(11U, completion_count());
|
| + // One initial asynchronous request and then 5 pending requests.
|
| + EXPECT_EQ(6U, completion_count());
|
|
|
| - // First part of requests, all with the same priority, finishes in FIFO order.
|
| + // The requests finish in FIFO order.
|
| EXPECT_EQ(1, GetOrderOfRequest(1));
|
| EXPECT_EQ(2, GetOrderOfRequest(2));
|
| EXPECT_EQ(3, GetOrderOfRequest(3));
|
| @@ -674,23 +576,11 @@ TEST_F(TransportClientSocketPoolTest, PendingRequests) {
|
| EXPECT_EQ(5, GetOrderOfRequest(5));
|
| EXPECT_EQ(6, GetOrderOfRequest(6));
|
|
|
| - // Make sure that rest of the requests complete in the order of priority.
|
| - EXPECT_EQ(7, GetOrderOfRequest(7));
|
| - EXPECT_EQ(14, GetOrderOfRequest(8));
|
| - EXPECT_EQ(15, GetOrderOfRequest(9));
|
| - EXPECT_EQ(10, GetOrderOfRequest(10));
|
| - EXPECT_EQ(13, GetOrderOfRequest(11));
|
| - EXPECT_EQ(8, GetOrderOfRequest(12));
|
| - EXPECT_EQ(16, GetOrderOfRequest(13));
|
| - EXPECT_EQ(11, GetOrderOfRequest(14));
|
| - EXPECT_EQ(12, GetOrderOfRequest(15));
|
| - EXPECT_EQ(9, GetOrderOfRequest(16));
|
| -
|
| // Make sure we test order of all requests made.
|
| - EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
|
| + EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(7));
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {
|
| // First request finishes asynchronously.
|
| EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
|
| @@ -698,14 +588,7 @@ TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {
|
| // Make all subsequent host resolutions complete synchronously.
|
| host_resolver_->set_synchronous_mode(true);
|
|
|
| - // Rest of them finish synchronously, until we reach the per-group limit.
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| -
|
| - // The rest are pending since we've used all active sockets.
|
| + // Rest of them wait foe the first socket to be released.
|
| EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| @@ -715,11 +598,11 @@ TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {
|
| ReleaseAllConnections(ClientSocketPoolTest::NO_KEEP_ALIVE);
|
|
|
| // The pending requests should finish successfully.
|
| - EXPECT_EQ(OK, (*requests())[6]->WaitForResult());
|
| - EXPECT_EQ(OK, (*requests())[7]->WaitForResult());
|
| - EXPECT_EQ(OK, (*requests())[8]->WaitForResult());
|
| - EXPECT_EQ(OK, (*requests())[9]->WaitForResult());
|
| - EXPECT_EQ(OK, (*requests())[10]->WaitForResult());
|
| + EXPECT_EQ(OK, (*requests())[1]->WaitForResult());
|
| + EXPECT_EQ(OK, (*requests())[2]->WaitForResult());
|
| + EXPECT_EQ(OK, (*requests())[3]->WaitForResult());
|
| + EXPECT_EQ(OK, (*requests())[4]->WaitForResult());
|
| + EXPECT_EQ(OK, (*requests())[5]->WaitForResult());
|
|
|
| EXPECT_EQ(static_cast<int>(requests()->size()),
|
| client_socket_factory_.allocation_count());
|
| @@ -731,27 +614,39 @@ TEST_F(TransportClientSocketPoolTest, PendingRequests_NoKeepAlive) {
|
| // This test will start up a RequestSocket() and then immediately Cancel() it.
|
| // The pending host resolution will eventually complete, and destroy the
|
| // ClientSocketPool which will crash if the group was not cleared properly.
|
| -TEST_F(TransportClientSocketPoolTest, CancelRequestClearGroup) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, CancelRequestClearGroup) {
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle.Init("a", params_, kDefaultPriority, callback.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle.Init("a",
|
| + params_,
|
| + kDefaultPriority,
|
| + callback.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
| handle.Reset();
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, TwoRequestsCancelOne) {
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle2;
|
| TestCompletionCallback callback2;
|
|
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle.Init("a", params_, kDefaultPriority, callback.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle.Init("a",
|
| + params_,
|
| + kDefaultPriority,
|
| + callback.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle2.Init("a", params_, kDefaultPriority, callback2.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle2.Init("a",
|
| + params_,
|
| + kDefaultPriority,
|
| + callback2.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
|
|
| handle.Reset();
|
|
|
| @@ -759,21 +654,29 @@ TEST_F(TransportClientSocketPoolTest, TwoRequestsCancelOne) {
|
| handle2.Reset();
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, ConnectCancelConnect) {
|
| client_socket_factory_.set_client_socket_type(
|
| MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET);
|
| ClientSocketHandle handle;
|
| TestCompletionCallback callback;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle.Init("a", params_, kDefaultPriority, callback.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle.Init("a",
|
| + params_,
|
| + kDefaultPriority,
|
| + callback.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
|
|
| handle.Reset();
|
|
|
| TestCompletionCallback callback2;
|
| EXPECT_EQ(ERR_IO_PENDING,
|
| - handle.Init("a", params_, kDefaultPriority, callback2.callback(),
|
| - &pool_, BoundNetLog()));
|
| + handle.Init("a",
|
| + params_,
|
| + kDefaultPriority,
|
| + callback2.callback(),
|
| + &pool_,
|
| + BoundNetLog()));
|
|
|
| host_resolver_->set_synchronous_mode(true);
|
| // At this point, handle has two ConnectingSockets out for it. Due to the
|
| @@ -791,7 +694,7 @@ TEST_F(TransportClientSocketPoolTest, ConnectCancelConnect) {
|
| handle.Reset();
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, CancelRequest) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, CancelRequest) {
|
| // First request finishes asynchronously.
|
| EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| EXPECT_EQ(OK, (*requests())[0]->WaitForResult());
|
| @@ -799,67 +702,42 @@ TEST_F(TransportClientSocketPoolTest, CancelRequest) {
|
| // Make all subsequent host resolutions complete synchronously.
|
| host_resolver_->set_synchronous_mode(true);
|
|
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| - EXPECT_EQ(OK, StartRequest("a", kDefaultPriority));
|
| -
|
| - // Reached per-group limit, queue up requests.
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", MEDIUM));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", HIGHEST));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOW));
|
| - EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", LOWEST));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
| + EXPECT_EQ(ERR_IO_PENDING, StartRequest("a", kDefaultPriority));
|
|
|
| // Cancel a request.
|
| - size_t index_to_cancel = kMaxSocketsPerGroup + 2;
|
| + const size_t index_to_cancel = 2;
|
| EXPECT_FALSE((*requests())[index_to_cancel]->handle()->is_initialized());
|
| (*requests())[index_to_cancel]->handle()->Reset();
|
|
|
| ReleaseAllConnections(ClientSocketPoolTest::KEEP_ALIVE);
|
|
|
| - EXPECT_EQ(kMaxSocketsPerGroup,
|
| - client_socket_factory_.allocation_count());
|
| - EXPECT_EQ(requests()->size() - kMaxSocketsPerGroup, completion_count());
|
| + EXPECT_EQ(5, client_socket_factory_.allocation_count());
|
|
|
| EXPECT_EQ(1, GetOrderOfRequest(1));
|
| EXPECT_EQ(2, GetOrderOfRequest(2));
|
| - EXPECT_EQ(3, GetOrderOfRequest(3));
|
| - EXPECT_EQ(4, GetOrderOfRequest(4));
|
| - EXPECT_EQ(5, GetOrderOfRequest(5));
|
| - EXPECT_EQ(6, GetOrderOfRequest(6));
|
| - EXPECT_EQ(14, GetOrderOfRequest(7));
|
| - EXPECT_EQ(7, GetOrderOfRequest(8));
|
| EXPECT_EQ(ClientSocketPoolTest::kRequestNotFound,
|
| - GetOrderOfRequest(9)); // Canceled request.
|
| - EXPECT_EQ(9, GetOrderOfRequest(10));
|
| - EXPECT_EQ(10, GetOrderOfRequest(11));
|
| - EXPECT_EQ(11, GetOrderOfRequest(12));
|
| - EXPECT_EQ(8, GetOrderOfRequest(13));
|
| - EXPECT_EQ(12, GetOrderOfRequest(14));
|
| - EXPECT_EQ(13, GetOrderOfRequest(15));
|
| - EXPECT_EQ(15, GetOrderOfRequest(16));
|
| + GetOrderOfRequest(3)); // Canceled request.
|
| + EXPECT_EQ(3, GetOrderOfRequest(4));
|
| + EXPECT_EQ(4, GetOrderOfRequest(5));
|
| + EXPECT_EQ(5, GetOrderOfRequest(6));
|
|
|
| // Make sure we test order of all requests made.
|
| - EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(17));
|
| + EXPECT_EQ(ClientSocketPoolTest::kIndexOutOfBounds, GetOrderOfRequest(7));
|
| }
|
|
|
| class RequestSocketCallback : public TestCompletionCallbackBase {
|
| public:
|
| RequestSocketCallback(ClientSocketHandle* handle,
|
| - TransportClientSocketPool* pool)
|
| + WebSocketTransportClientSocketPool* pool)
|
| : handle_(handle),
|
| pool_(pool),
|
| within_callback_(false),
|
| callback_(base::Bind(&RequestSocketCallback::OnComplete,
|
| - base::Unretained(this))) {
|
| - }
|
| + base::Unretained(this))) {}
|
|
|
| virtual ~RequestSocketCallback() {}
|
|
|
| @@ -881,31 +759,35 @@ class RequestSocketCallback : public TestCompletionCallbackBase {
|
| base::MessageLoop::current()->RunUntilIdle();
|
| }
|
| within_callback_ = true;
|
| - scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
|
| - HostPortPair("www.google.com", 80), false, false,
|
| - OnHostResolutionCallback()));
|
| - int rv = handle_->Init("a", dest, LOWEST, callback(), pool_,
|
| - BoundNetLog());
|
| + scoped_refptr<TransportSocketParams> dest(
|
| + new TransportSocketParams(HostPortPair("www.google.com", 80),
|
| + false,
|
| + false,
|
| + OnHostResolutionCallback()));
|
| + int rv =
|
| + handle_->Init("a", dest, LOWEST, callback(), pool_, BoundNetLog());
|
| EXPECT_EQ(OK, rv);
|
| }
|
| }
|
|
|
| ClientSocketHandle* const handle_;
|
| - TransportClientSocketPool* const pool_;
|
| + WebSocketTransportClientSocketPool* const pool_;
|
| bool within_callback_;
|
| CompletionCallback callback_;
|
|
|
| DISALLOW_COPY_AND_ASSIGN(RequestSocketCallback);
|
| };
|
|
|
| -TEST_F(TransportClientSocketPoolTest, RequestTwice) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, RequestTwice) {
|
| ClientSocketHandle handle;
|
| RequestSocketCallback callback(&handle, &pool_);
|
| - scoped_refptr<TransportSocketParams> dest(new TransportSocketParams(
|
| - HostPortPair("www.google.com", 80), false, false,
|
| - OnHostResolutionCallback()));
|
| - int rv = handle.Init("a", dest, LOWEST, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| + scoped_refptr<TransportSocketParams> dest(
|
| + new TransportSocketParams(HostPortPair("www.google.com", 80),
|
| + false,
|
| + false,
|
| + OnHostResolutionCallback()));
|
| + int rv = handle.Init(
|
| + "a", dest, LOWEST, callback.callback(), &pool_, BoundNetLog());
|
| ASSERT_EQ(ERR_IO_PENDING, rv);
|
|
|
| // The callback is going to request "www.google.com". We want it to complete
|
| @@ -919,7 +801,8 @@ TEST_F(TransportClientSocketPoolTest, RequestTwice) {
|
|
|
| // Make sure that pending requests get serviced after active requests get
|
| // cancelled.
|
| -TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest,
|
| + CancelActiveRequestWithPendingRequests) {
|
| client_socket_factory_.set_client_socket_type(
|
| MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET);
|
|
|
| @@ -949,7 +832,8 @@ TEST_F(TransportClientSocketPoolTest, CancelActiveRequestWithPendingRequests) {
|
| }
|
|
|
| // Make sure that pending requests get serviced after active requests fail.
|
| -TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest,
|
| + FailingActiveRequestWithPendingRequests) {
|
| client_socket_factory_.set_client_socket_type(
|
| MockClientSocketFactory::MOCK_PENDING_FAILING_CLIENT_SOCKET);
|
|
|
| @@ -964,287 +848,35 @@ TEST_F(TransportClientSocketPoolTest, FailingActiveRequestWithPendingRequests) {
|
| EXPECT_EQ(ERR_CONNECTION_FAILED, (*requests())[i]->WaitForResult());
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, IdleSocketLoadTiming) {
|
| - TestCompletionCallback callback;
|
| - ClientSocketHandle handle;
|
| - int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| - EXPECT_EQ(ERR_IO_PENDING, rv);
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| -
|
| - EXPECT_EQ(OK, callback.WaitForResult());
|
| - EXPECT_TRUE(handle.is_initialized());
|
| - EXPECT_TRUE(handle.socket());
|
| - TestLoadTimingInfoConnectedNotReused(handle);
|
| -
|
| - handle.Reset();
|
| - // Need to run all pending to release the socket back to the pool.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - // Now we should have 1 idle socket.
|
| - EXPECT_EQ(1, pool_.IdleSocketCount());
|
| -
|
| - rv = handle.Init("a", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| - EXPECT_EQ(OK, rv);
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| - TestLoadTimingInfoConnectedReused(handle);
|
| -}
|
| -
|
| -TEST_F(TransportClientSocketPoolTest, ResetIdleSocketsOnIPAddressChange) {
|
| - TestCompletionCallback callback;
|
| - ClientSocketHandle handle;
|
| - int rv = handle.Init("a", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| - EXPECT_EQ(ERR_IO_PENDING, rv);
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| -
|
| - EXPECT_EQ(OK, callback.WaitForResult());
|
| - EXPECT_TRUE(handle.is_initialized());
|
| - EXPECT_TRUE(handle.socket());
|
| -
|
| - handle.Reset();
|
| -
|
| - // Need to run all pending to release the socket back to the pool.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - // Now we should have 1 idle socket.
|
| - EXPECT_EQ(1, pool_.IdleSocketCount());
|
| -
|
| - // After an IP address change, we should have 0 idle sockets.
|
| - NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
|
| - base::MessageLoop::current()->RunUntilIdle(); // Notification happens async.
|
| -
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| -}
|
| -
|
| -TEST_F(TransportClientSocketPoolTest, BackupSocketConnect) {
|
| - // Case 1 tests the first socket stalling, and the backup connecting.
|
| - MockClientSocketFactory::ClientSocketType case1_types[] = {
|
| - // The first socket will not connect.
|
| - MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET,
|
| - // The second socket will connect more quickly.
|
| - MockClientSocketFactory::MOCK_CLIENT_SOCKET
|
| - };
|
| -
|
| - // Case 2 tests the first socket being slow, so that we start the
|
| - // second connect, but the second connect stalls, and we still
|
| - // complete the first.
|
| - MockClientSocketFactory::ClientSocketType case2_types[] = {
|
| - // The first socket will connect, although delayed.
|
| - MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET,
|
| - // The second socket will not connect.
|
| - MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET
|
| - };
|
| -
|
| - MockClientSocketFactory::ClientSocketType* cases[2] = {
|
| - case1_types,
|
| - case2_types
|
| - };
|
| -
|
| - for (size_t index = 0; index < arraysize(cases); ++index) {
|
| - client_socket_factory_.set_client_socket_types(cases[index], 2);
|
| -
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| -
|
| - TestCompletionCallback callback;
|
| - ClientSocketHandle handle;
|
| - int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| - EXPECT_EQ(ERR_IO_PENDING, rv);
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| -
|
| - // Create the first socket, set the timer.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - // Wait for the backup socket timer to fire.
|
| - base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
|
| - ClientSocketPool::kMaxConnectRetryIntervalMs + 50));
|
| -
|
| - // Let the appropriate socket connect.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - EXPECT_EQ(OK, callback.WaitForResult());
|
| - EXPECT_TRUE(handle.is_initialized());
|
| - EXPECT_TRUE(handle.socket());
|
| -
|
| - // One socket is stalled, the other is active.
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| - handle.Reset();
|
| -
|
| - // Close all pending connect jobs and existing sockets.
|
| - pool_.FlushWithError(ERR_NETWORK_CHANGED);
|
| - }
|
| -}
|
| -
|
| -// Test the case where a socket took long enough to start the creation
|
| -// of the backup socket, but then we cancelled the request after that.
|
| -TEST_F(TransportClientSocketPoolTest, BackupSocketCancel) {
|
| - client_socket_factory_.set_client_socket_type(
|
| - MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET);
|
| -
|
| - enum { CANCEL_BEFORE_WAIT, CANCEL_AFTER_WAIT };
|
| -
|
| - for (int index = CANCEL_BEFORE_WAIT; index < CANCEL_AFTER_WAIT; ++index) {
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| -
|
| - TestCompletionCallback callback;
|
| - ClientSocketHandle handle;
|
| - int rv = handle.Init("c", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| - EXPECT_EQ(ERR_IO_PENDING, rv);
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| -
|
| - // Create the first socket, set the timer.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - if (index == CANCEL_AFTER_WAIT) {
|
| - // Wait for the backup socket timer to fire.
|
| - base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
|
| - ClientSocketPool::kMaxConnectRetryIntervalMs));
|
| - }
|
| -
|
| - // Let the appropriate socket connect.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - handle.Reset();
|
| -
|
| - EXPECT_FALSE(callback.have_result());
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| -
|
| - // One socket is stalled, the other is active.
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| - }
|
| -}
|
| -
|
| -// Test the case where a socket took long enough to start the creation
|
| -// of the backup socket and never completes, and then the backup
|
| -// connection fails.
|
| -TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterStall) {
|
| - MockClientSocketFactory::ClientSocketType case_types[] = {
|
| - // The first socket will not connect.
|
| - MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET,
|
| - // The second socket will fail immediately.
|
| - MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET
|
| - };
|
| -
|
| - client_socket_factory_.set_client_socket_types(case_types, 2);
|
| -
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| -
|
| - TestCompletionCallback callback;
|
| - ClientSocketHandle handle;
|
| - int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| - EXPECT_EQ(ERR_IO_PENDING, rv);
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| -
|
| - // Create the first socket, set the timer.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - // Wait for the backup socket timer to fire.
|
| - base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
|
| - ClientSocketPool::kMaxConnectRetryIntervalMs));
|
| -
|
| - // Let the second connect be synchronous. Otherwise, the emulated
|
| - // host resolution takes an extra trip through the message loop.
|
| - host_resolver_->set_synchronous_mode(true);
|
| -
|
| - // Let the appropriate socket connect.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| - handle.Reset();
|
| -
|
| - // Reset for the next case.
|
| - host_resolver_->set_synchronous_mode(false);
|
| -}
|
| -
|
| -// Test the case where a socket took long enough to start the creation
|
| -// of the backup socket and eventually completes, but the backup socket
|
| -// fails.
|
| -TEST_F(TransportClientSocketPoolTest, BackupSocketFailAfterDelay) {
|
| - MockClientSocketFactory::ClientSocketType case_types[] = {
|
| - // The first socket will connect, although delayed.
|
| - MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET,
|
| - // The second socket will not connect.
|
| - MockClientSocketFactory::MOCK_FAILING_CLIENT_SOCKET
|
| - };
|
| -
|
| - client_socket_factory_.set_client_socket_types(case_types, 2);
|
| - client_socket_factory_.set_delay(base::TimeDelta::FromSeconds(5));
|
| -
|
| - EXPECT_EQ(0, pool_.IdleSocketCount());
|
| -
|
| - TestCompletionCallback callback;
|
| - ClientSocketHandle handle;
|
| - int rv = handle.Init("b", params_, LOW, callback.callback(), &pool_,
|
| - BoundNetLog());
|
| - EXPECT_EQ(ERR_IO_PENDING, rv);
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| -
|
| - // Create the first socket, set the timer.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - // Wait for the backup socket timer to fire.
|
| - base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(
|
| - ClientSocketPool::kMaxConnectRetryIntervalMs));
|
| -
|
| - // Let the second connect be synchronous. Otherwise, the emulated
|
| - // host resolution takes an extra trip through the message loop.
|
| - host_resolver_->set_synchronous_mode(true);
|
| -
|
| - // Let the appropriate socket connect.
|
| - base::MessageLoop::current()->RunUntilIdle();
|
| -
|
| - EXPECT_EQ(ERR_CONNECTION_FAILED, callback.WaitForResult());
|
| - EXPECT_FALSE(handle.is_initialized());
|
| - EXPECT_FALSE(handle.socket());
|
| - handle.Reset();
|
| -
|
| - // Reset for the next case.
|
| - host_resolver_->set_synchronous_mode(false);
|
| -}
|
| -
|
| // Test the case of the IPv6 address stalling, and falling back to the IPv4
|
| // socket which finishes first.
|
| -TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest,
|
| + IPv6FallbackSocketIPv4FinishesFirst) {
|
| // Create a pool without backup jobs.
|
| ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false);
|
| - TransportClientSocketPool pool(kMaxSockets,
|
| - kMaxSocketsPerGroup,
|
| - histograms_.get(),
|
| - host_resolver_.get(),
|
| - &client_socket_factory_,
|
| - NULL);
|
| + WebSocketTransportClientSocketPool pool(kMaxSockets,
|
| + kMaxSocketsPerGroup,
|
| + histograms_.get(),
|
| + host_resolver_.get(),
|
| + &client_socket_factory_,
|
| + NULL);
|
|
|
| MockClientSocketFactory::ClientSocketType case_types[] = {
|
| - // This is the IPv6 socket.
|
| - MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET,
|
| - // This is the IPv4 socket.
|
| - MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET
|
| - };
|
| + // This is the IPv6 socket.
|
| + MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET,
|
| + // This is the IPv4 socket.
|
| + MockClientSocketFactory::MOCK_PENDING_CLIENT_SOCKET};
|
|
|
| client_socket_factory_.set_client_socket_types(case_types, 2);
|
|
|
| // Resolve an AddressList with a IPv6 address first and then a IPv4 address.
|
| - host_resolver_->rules()
|
| - ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string());
|
| + host_resolver_->rules()->AddIPLiteralRule(
|
| + "*", "2:abcd::3:4:ff,2.2.2.2", std::string());
|
|
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| - int rv = handle.Init("a", params_, LOW, callback.callback(), &pool,
|
| - BoundNetLog());
|
| + int rv =
|
| + handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle.is_initialized());
|
| EXPECT_FALSE(handle.socket());
|
| @@ -1261,35 +893,35 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) {
|
| // Test the case of the IPv6 address being slow, thus falling back to trying to
|
| // connect to the IPv4 address, but having the connect to the IPv6 address
|
| // finish first.
|
| -TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest,
|
| + IPv6FallbackSocketIPv6FinishesFirst) {
|
| // Create a pool without backup jobs.
|
| ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false);
|
| - TransportClientSocketPool pool(kMaxSockets,
|
| - kMaxSocketsPerGroup,
|
| - histograms_.get(),
|
| - host_resolver_.get(),
|
| - &client_socket_factory_,
|
| - NULL);
|
| + WebSocketTransportClientSocketPool pool(kMaxSockets,
|
| + kMaxSocketsPerGroup,
|
| + histograms_.get(),
|
| + host_resolver_.get(),
|
| + &client_socket_factory_,
|
| + NULL);
|
|
|
| MockClientSocketFactory::ClientSocketType case_types[] = {
|
| - // This is the IPv6 socket.
|
| - MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET,
|
| - // This is the IPv4 socket.
|
| - MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET
|
| - };
|
| + // This is the IPv6 socket.
|
| + MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET,
|
| + // This is the IPv4 socket.
|
| + MockClientSocketFactory::MOCK_STALLED_CLIENT_SOCKET};
|
|
|
| client_socket_factory_.set_client_socket_types(case_types, 2);
|
| client_socket_factory_.set_delay(base::TimeDelta::FromMilliseconds(
|
| - TransportConnectJob::kIPv6FallbackTimerInMs + 50));
|
| + WebSocketTransportConnectJob::kIPv6FallbackTimerInMs + 50));
|
|
|
| // Resolve an AddressList with a IPv6 address first and then a IPv4 address.
|
| - host_resolver_->rules()
|
| - ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string());
|
| + host_resolver_->rules()->AddIPLiteralRule(
|
| + "*", "2:abcd::3:4:ff,2.2.2.2", std::string());
|
|
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| - int rv = handle.Init("a", params_, LOW, callback.callback(), &pool,
|
| - BoundNetLog());
|
| + int rv =
|
| + handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle.is_initialized());
|
| EXPECT_FALSE(handle.socket());
|
| @@ -1303,27 +935,28 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) {
|
| EXPECT_EQ(2, client_socket_factory_.allocation_count());
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, IPv6NoIPv4AddressesToFallbackTo) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest,
|
| + IPv6NoIPv4AddressesToFallbackTo) {
|
| // Create a pool without backup jobs.
|
| ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false);
|
| - TransportClientSocketPool pool(kMaxSockets,
|
| - kMaxSocketsPerGroup,
|
| - histograms_.get(),
|
| - host_resolver_.get(),
|
| - &client_socket_factory_,
|
| - NULL);
|
| + WebSocketTransportClientSocketPool pool(kMaxSockets,
|
| + kMaxSocketsPerGroup,
|
| + histograms_.get(),
|
| + host_resolver_.get(),
|
| + &client_socket_factory_,
|
| + NULL);
|
|
|
| client_socket_factory_.set_client_socket_type(
|
| MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
|
|
|
| // Resolve an AddressList with only IPv6 addresses.
|
| - host_resolver_->rules()
|
| - ->AddIPLiteralRule("*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string());
|
| + host_resolver_->rules()->AddIPLiteralRule(
|
| + "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string());
|
|
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| - int rv = handle.Init("a", params_, LOW, callback.callback(), &pool,
|
| - BoundNetLog());
|
| + int rv =
|
| + handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle.is_initialized());
|
| EXPECT_FALSE(handle.socket());
|
| @@ -1337,15 +970,15 @@ TEST_F(TransportClientSocketPoolTest, IPv6NoIPv4AddressesToFallbackTo) {
|
| EXPECT_EQ(1, client_socket_factory_.allocation_count());
|
| }
|
|
|
| -TEST_F(TransportClientSocketPoolTest, IPv4HasNoFallback) {
|
| +TEST_F(WebSocketTransportClientSocketPoolTest, IPv4HasNoFallback) {
|
| // Create a pool without backup jobs.
|
| ClientSocketPoolBaseHelper::set_connect_backup_jobs_enabled(false);
|
| - TransportClientSocketPool pool(kMaxSockets,
|
| - kMaxSocketsPerGroup,
|
| - histograms_.get(),
|
| - host_resolver_.get(),
|
| - &client_socket_factory_,
|
| - NULL);
|
| + WebSocketTransportClientSocketPool pool(kMaxSockets,
|
| + kMaxSocketsPerGroup,
|
| + histograms_.get(),
|
| + host_resolver_.get(),
|
| + &client_socket_factory_,
|
| + NULL);
|
|
|
| client_socket_factory_.set_client_socket_type(
|
| MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET);
|
| @@ -1355,8 +988,8 @@ TEST_F(TransportClientSocketPoolTest, IPv4HasNoFallback) {
|
|
|
| TestCompletionCallback callback;
|
| ClientSocketHandle handle;
|
| - int rv = handle.Init("a", params_, LOW, callback.callback(), &pool,
|
| - BoundNetLog());
|
| + int rv =
|
| + handle.Init("a", params_, LOW, callback.callback(), &pool, BoundNetLog());
|
| EXPECT_EQ(ERR_IO_PENDING, rv);
|
| EXPECT_FALSE(handle.is_initialized());
|
| EXPECT_FALSE(handle.socket());
|
|
|
Chromium Code Reviews
Issue 240873003:
Create WebSocketTransportClientSocketPool (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master