summaryrefslogtreecommitdiffstats
path: root/net/http
diff options
context:
space:
mode:
Diffstat (limited to 'net/http')
-rw-r--r--net/http/http_network_transaction_spdy21_unittest.cc181
-rw-r--r--net/http/http_network_transaction_spdy2_unittest.cc181
-rw-r--r--net/http/http_network_transaction_spdy3_unittest.cc181
-rw-r--r--net/http/http_proxy_client_socket_pool.cc36
-rw-r--r--net/http/http_proxy_client_socket_pool.h13
5 files changed, 589 insertions, 3 deletions
diff --git a/net/http/http_network_transaction_spdy21_unittest.cc b/net/http/http_network_transaction_spdy21_unittest.cc
index 7744e7f..6a6e706 100644
--- a/net/http/http_network_transaction_spdy21_unittest.cc
+++ b/net/http/http_network_transaction_spdy21_unittest.cc
@@ -9363,4 +9363,185 @@ TEST_F(HttpNetworkTransactionSpdy21Test, SendPipelineEvictionFallback) {
EXPECT_EQ("hello world", out.response_data);
}
+TEST_F(HttpNetworkTransactionSpdy21Test, CloseIdleSpdySessionToOpenNewOne) {
+ HttpStreamFactory::SetNextProtos(SpdyNextProtos());
+ int old_max_sockets_per_group =
+ ClientSocketPoolManager::max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ int old_max_sockets_per_proxy_server =
+ ClientSocketPoolManager::max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ int old_max_sockets_per_pool =
+ ClientSocketPoolManager::max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ ClientSocketPoolManager::set_max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+ ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+ ClientSocketPoolManager::set_max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+
+ // Use two different hosts with different IPs so they don't get pooled.
+ SessionDependencies session_deps;
+ session_deps.host_resolver->rules()->AddRule("a.com", "10.0.0.1");
+ session_deps.host_resolver->rules()->AddRule("b.com", "10.0.0.2");
+ scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+ SSLSocketDataProvider ssl1(ASYNC, OK);
+ ssl1.SetNextProto(kProtoSPDY21);
+ SSLSocketDataProvider ssl2(ASYNC, OK);
+ ssl2.SetNextProto(kProtoSPDY21);
+ session_deps.socket_factory.AddSSLSocketDataProvider(&ssl1);
+ session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
+
+ scoped_ptr<SpdyFrame> host1_req(ConstructSpdyGet(
+ "https://www.a.com", false, 1, LOWEST));
+ MockWrite spdy1_writes[] = {
+ CreateMockWrite(*host1_req, 1),
+ };
+ scoped_ptr<SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
+ MockRead spdy1_reads[] = {
+ CreateMockRead(*host1_resp, 2),
+ CreateMockRead(*host1_resp_body, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ };
+
+ scoped_ptr<OrderedSocketData> spdy1_data(
+ new OrderedSocketData(
+ spdy1_reads, arraysize(spdy1_reads),
+ spdy1_writes, arraysize(spdy1_writes)));
+ session_deps.socket_factory.AddSocketDataProvider(spdy1_data.get());
+
+ scoped_ptr<SpdyFrame> host2_req(ConstructSpdyGet(
+ "https://www.b.com", false, 1, LOWEST));
+ MockWrite spdy2_writes[] = {
+ CreateMockWrite(*host2_req, 1),
+ };
+ scoped_ptr<SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(1, true));
+ MockRead spdy2_reads[] = {
+ CreateMockRead(*host2_resp, 2),
+ CreateMockRead(*host2_resp_body, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ };
+
+ scoped_ptr<OrderedSocketData> spdy2_data(
+ new OrderedSocketData(
+ spdy2_reads, arraysize(spdy2_reads),
+ spdy2_writes, arraysize(spdy2_writes)));
+ session_deps.socket_factory.AddSocketDataProvider(spdy2_data.get());
+
+ MockWrite http_write[] = {
+ MockWrite("GET / HTTP/1.1\r\n"
+ "Host: www.a.com\r\n"
+ "Connection: keep-alive\r\n\r\n"),
+ };
+
+ MockRead http_read[] = {
+ MockRead("HTTP/1.1 200 OK\r\n"),
+ MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+ MockRead("Content-Length: 6\r\n\r\n"),
+ MockRead("hello!"),
+ };
+ StaticSocketDataProvider http_data(http_read, arraysize(http_read),
+ http_write, arraysize(http_write));
+ session_deps.socket_factory.AddSocketDataProvider(&http_data);
+
+ HostPortPair host_port_pair_a("www.a.com", 443);
+ HostPortProxyPair host_port_proxy_pair_a(
+ host_port_pair_a, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+
+ TestCompletionCallback callback;
+ HttpRequestInfo request1;
+ request1.method = "GET";
+ request1.url = GURL("https://www.a.com/");
+ request1.load_flags = 0;
+ scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
+
+ int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ const HttpResponseInfo* response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_TRUE(response->was_fetched_via_spdy);
+ EXPECT_TRUE(response->was_npn_negotiated);
+
+ std::string response_data;
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ trans.reset();
+ EXPECT_TRUE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+
+ HostPortPair host_port_pair_b("www.b.com", 443);
+ HostPortProxyPair host_port_proxy_pair_b(
+ host_port_pair_b, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+ HttpRequestInfo request2;
+ request2.method = "GET";
+ request2.url = GURL("https://www.b.com/");
+ request2.load_flags = 0;
+ trans.reset(new HttpNetworkTransaction(session));
+
+ rv = trans->Start(&request2, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_TRUE(response->was_fetched_via_spdy);
+ EXPECT_TRUE(response->was_npn_negotiated);
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+ EXPECT_TRUE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+
+ HostPortPair host_port_pair_a1("www.a.com", 80);
+ HostPortProxyPair host_port_proxy_pair_a1(
+ host_port_pair_a1, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a1));
+ HttpRequestInfo request3;
+ request3.method = "GET";
+ request3.url = GURL("http://www.a.com/");
+ request3.load_flags = 0;
+ trans.reset(new HttpNetworkTransaction(session));
+
+ rv = trans->Start(&request3, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_FALSE(response->was_fetched_via_spdy);
+ EXPECT_FALSE(response->was_npn_negotiated);
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+
+ HttpStreamFactory::SetNextProtos(std::vector<std::string>());
+ ClientSocketPoolManager::set_max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_pool);
+ ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_proxy_server);
+ ClientSocketPoolManager::set_max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_group);
+}
+
} // namespace net
diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc
index 1eb3cec..29f8316 100644
--- a/net/http/http_network_transaction_spdy2_unittest.cc
+++ b/net/http/http_network_transaction_spdy2_unittest.cc
@@ -9362,4 +9362,185 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SendPipelineEvictionFallback) {
EXPECT_EQ("hello world", out.response_data);
}
+TEST_F(HttpNetworkTransactionSpdy2Test, CloseIdleSpdySessionToOpenNewOne) {
+ HttpStreamFactory::SetNextProtos(SpdyNextProtos());
+ int old_max_sockets_per_group =
+ ClientSocketPoolManager::max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ int old_max_sockets_per_proxy_server =
+ ClientSocketPoolManager::max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ int old_max_sockets_per_pool =
+ ClientSocketPoolManager::max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ ClientSocketPoolManager::set_max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+ ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+ ClientSocketPoolManager::set_max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+
+ // Use two different hosts with different IPs so they don't get pooled.
+ SessionDependencies session_deps;
+ session_deps.host_resolver->rules()->AddRule("a.com", "10.0.0.1");
+ session_deps.host_resolver->rules()->AddRule("b.com", "10.0.0.2");
+ scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+ SSLSocketDataProvider ssl1(ASYNC, OK);
+ ssl1.SetNextProto(kProtoSPDY2);
+ SSLSocketDataProvider ssl2(ASYNC, OK);
+ ssl2.SetNextProto(kProtoSPDY2);
+ session_deps.socket_factory.AddSSLSocketDataProvider(&ssl1);
+ session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
+
+ scoped_ptr<SpdyFrame> host1_req(ConstructSpdyGet(
+ "https://www.a.com", false, 1, LOWEST));
+ MockWrite spdy1_writes[] = {
+ CreateMockWrite(*host1_req, 1),
+ };
+ scoped_ptr<SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
+ MockRead spdy1_reads[] = {
+ CreateMockRead(*host1_resp, 2),
+ CreateMockRead(*host1_resp_body, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ };
+
+ scoped_ptr<OrderedSocketData> spdy1_data(
+ new OrderedSocketData(
+ spdy1_reads, arraysize(spdy1_reads),
+ spdy1_writes, arraysize(spdy1_writes)));
+ session_deps.socket_factory.AddSocketDataProvider(spdy1_data.get());
+
+ scoped_ptr<SpdyFrame> host2_req(ConstructSpdyGet(
+ "https://www.b.com", false, 1, LOWEST));
+ MockWrite spdy2_writes[] = {
+ CreateMockWrite(*host2_req, 1),
+ };
+ scoped_ptr<SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(1, true));
+ MockRead spdy2_reads[] = {
+ CreateMockRead(*host2_resp, 2),
+ CreateMockRead(*host2_resp_body, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ };
+
+ scoped_ptr<OrderedSocketData> spdy2_data(
+ new OrderedSocketData(
+ spdy2_reads, arraysize(spdy2_reads),
+ spdy2_writes, arraysize(spdy2_writes)));
+ session_deps.socket_factory.AddSocketDataProvider(spdy2_data.get());
+
+ MockWrite http_write[] = {
+ MockWrite("GET / HTTP/1.1\r\n"
+ "Host: www.a.com\r\n"
+ "Connection: keep-alive\r\n\r\n"),
+ };
+
+ MockRead http_read[] = {
+ MockRead("HTTP/1.1 200 OK\r\n"),
+ MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+ MockRead("Content-Length: 6\r\n\r\n"),
+ MockRead("hello!"),
+ };
+ StaticSocketDataProvider http_data(http_read, arraysize(http_read),
+ http_write, arraysize(http_write));
+ session_deps.socket_factory.AddSocketDataProvider(&http_data);
+
+ HostPortPair host_port_pair_a("www.a.com", 443);
+ HostPortProxyPair host_port_proxy_pair_a(
+ host_port_pair_a, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+
+ TestCompletionCallback callback;
+ HttpRequestInfo request1;
+ request1.method = "GET";
+ request1.url = GURL("https://www.a.com/");
+ request1.load_flags = 0;
+ scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
+
+ int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ const HttpResponseInfo* response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_TRUE(response->was_fetched_via_spdy);
+ EXPECT_TRUE(response->was_npn_negotiated);
+
+ std::string response_data;
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ trans.reset();
+ EXPECT_TRUE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+
+ HostPortPair host_port_pair_b("www.b.com", 443);
+ HostPortProxyPair host_port_proxy_pair_b(
+ host_port_pair_b, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+ HttpRequestInfo request2;
+ request2.method = "GET";
+ request2.url = GURL("https://www.b.com/");
+ request2.load_flags = 0;
+ trans.reset(new HttpNetworkTransaction(session));
+
+ rv = trans->Start(&request2, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_TRUE(response->was_fetched_via_spdy);
+ EXPECT_TRUE(response->was_npn_negotiated);
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+ EXPECT_TRUE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+
+ HostPortPair host_port_pair_a1("www.a.com", 80);
+ HostPortProxyPair host_port_proxy_pair_a1(
+ host_port_pair_a1, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a1));
+ HttpRequestInfo request3;
+ request3.method = "GET";
+ request3.url = GURL("http://www.a.com/");
+ request3.load_flags = 0;
+ trans.reset(new HttpNetworkTransaction(session));
+
+ rv = trans->Start(&request3, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_FALSE(response->was_fetched_via_spdy);
+ EXPECT_FALSE(response->was_npn_negotiated);
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+
+ HttpStreamFactory::SetNextProtos(std::vector<std::string>());
+ ClientSocketPoolManager::set_max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_pool);
+ ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_proxy_server);
+ ClientSocketPoolManager::set_max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_group);
+}
+
} // namespace net
diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc
index 587722d..d3d6dab 100644
--- a/net/http/http_network_transaction_spdy3_unittest.cc
+++ b/net/http/http_network_transaction_spdy3_unittest.cc
@@ -9361,4 +9361,185 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SendPipelineEvictionFallback) {
EXPECT_EQ("hello world", out.response_data);
}
+TEST_F(HttpNetworkTransactionSpdy3Test, CloseIdleSpdySessionToOpenNewOne) {
+ HttpStreamFactory::SetNextProtos(SpdyNextProtos());
+ int old_max_sockets_per_group =
+ ClientSocketPoolManager::max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ int old_max_sockets_per_proxy_server =
+ ClientSocketPoolManager::max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ int old_max_sockets_per_pool =
+ ClientSocketPoolManager::max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL);
+ ClientSocketPoolManager::set_max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+ ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+ ClientSocketPoolManager::set_max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
+
+ // Use two different hosts with different IPs so they don't get pooled.
+ SessionDependencies session_deps;
+ session_deps.host_resolver->rules()->AddRule("a.com", "10.0.0.1");
+ session_deps.host_resolver->rules()->AddRule("b.com", "10.0.0.2");
+ scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
+
+ SSLSocketDataProvider ssl1(ASYNC, OK);
+ ssl1.SetNextProto(kProtoSPDY3);
+ SSLSocketDataProvider ssl2(ASYNC, OK);
+ ssl2.SetNextProto(kProtoSPDY3);
+ session_deps.socket_factory.AddSSLSocketDataProvider(&ssl1);
+ session_deps.socket_factory.AddSSLSocketDataProvider(&ssl2);
+
+ scoped_ptr<SpdyFrame> host1_req(ConstructSpdyGet(
+ "https://www.a.com", false, 1, LOWEST));
+ MockWrite spdy1_writes[] = {
+ CreateMockWrite(*host1_req, 1),
+ };
+ scoped_ptr<SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
+ MockRead spdy1_reads[] = {
+ CreateMockRead(*host1_resp, 2),
+ CreateMockRead(*host1_resp_body, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ };
+
+ scoped_ptr<OrderedSocketData> spdy1_data(
+ new OrderedSocketData(
+ spdy1_reads, arraysize(spdy1_reads),
+ spdy1_writes, arraysize(spdy1_writes)));
+ session_deps.socket_factory.AddSocketDataProvider(spdy1_data.get());
+
+ scoped_ptr<SpdyFrame> host2_req(ConstructSpdyGet(
+ "https://www.b.com", false, 1, LOWEST));
+ MockWrite spdy2_writes[] = {
+ CreateMockWrite(*host2_req, 1),
+ };
+ scoped_ptr<SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
+ scoped_ptr<SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(1, true));
+ MockRead spdy2_reads[] = {
+ CreateMockRead(*host2_resp, 2),
+ CreateMockRead(*host2_resp_body, 3),
+ MockRead(ASYNC, ERR_IO_PENDING, 4),
+ };
+
+ scoped_ptr<OrderedSocketData> spdy2_data(
+ new OrderedSocketData(
+ spdy2_reads, arraysize(spdy2_reads),
+ spdy2_writes, arraysize(spdy2_writes)));
+ session_deps.socket_factory.AddSocketDataProvider(spdy2_data.get());
+
+ MockWrite http_write[] = {
+ MockWrite("GET / HTTP/1.1\r\n"
+ "Host: www.a.com\r\n"
+ "Connection: keep-alive\r\n\r\n"),
+ };
+
+ MockRead http_read[] = {
+ MockRead("HTTP/1.1 200 OK\r\n"),
+ MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+ MockRead("Content-Length: 6\r\n\r\n"),
+ MockRead("hello!"),
+ };
+ StaticSocketDataProvider http_data(http_read, arraysize(http_read),
+ http_write, arraysize(http_write));
+ session_deps.socket_factory.AddSocketDataProvider(&http_data);
+
+ HostPortPair host_port_pair_a("www.a.com", 443);
+ HostPortProxyPair host_port_proxy_pair_a(
+ host_port_pair_a, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+
+ TestCompletionCallback callback;
+ HttpRequestInfo request1;
+ request1.method = "GET";
+ request1.url = GURL("https://www.a.com/");
+ request1.load_flags = 0;
+ scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
+
+ int rv = trans->Start(&request1, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ const HttpResponseInfo* response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_TRUE(response->was_fetched_via_spdy);
+ EXPECT_TRUE(response->was_npn_negotiated);
+
+ std::string response_data;
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ trans.reset();
+ EXPECT_TRUE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+
+ HostPortPair host_port_pair_b("www.b.com", 443);
+ HostPortProxyPair host_port_proxy_pair_b(
+ host_port_pair_b, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+ HttpRequestInfo request2;
+ request2.method = "GET";
+ request2.url = GURL("https://www.b.com/");
+ request2.load_flags = 0;
+ trans.reset(new HttpNetworkTransaction(session));
+
+ rv = trans->Start(&request2, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_TRUE(response->was_fetched_via_spdy);
+ EXPECT_TRUE(response->was_npn_negotiated);
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+ EXPECT_TRUE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+
+ HostPortPair host_port_pair_a1("www.a.com", 80);
+ HostPortProxyPair host_port_proxy_pair_a1(
+ host_port_pair_a1, ProxyServer::Direct());
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a1));
+ HttpRequestInfo request3;
+ request3.method = "GET";
+ request3.url = GURL("http://www.a.com/");
+ request3.load_flags = 0;
+ trans.reset(new HttpNetworkTransaction(session));
+
+ rv = trans->Start(&request3, callback.callback(), BoundNetLog());
+ EXPECT_EQ(ERR_IO_PENDING, rv);
+ EXPECT_EQ(OK, callback.WaitForResult());
+
+ response = trans->GetResponseInfo();
+ ASSERT_TRUE(response != NULL);
+ ASSERT_TRUE(response->headers != NULL);
+ EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+ EXPECT_FALSE(response->was_fetched_via_spdy);
+ EXPECT_FALSE(response->was_npn_negotiated);
+ ASSERT_EQ(OK, ReadTransaction(trans.get(), &response_data));
+ EXPECT_EQ("hello!", response_data);
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_a));
+ EXPECT_FALSE(
+ session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
+
+ HttpStreamFactory::SetNextProtos(std::vector<std::string>());
+ ClientSocketPoolManager::set_max_sockets_per_pool(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_pool);
+ ClientSocketPoolManager::set_max_sockets_per_proxy_server(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_proxy_server);
+ ClientSocketPoolManager::set_max_sockets_per_group(
+ HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets_per_group);
+}
+
} // namespace net
diff --git a/net/http/http_proxy_client_socket_pool.cc b/net/http/http_proxy_client_socket_pool.cc
index 01dc023..e6adfac 100644
--- a/net/http/http_proxy_client_socket_pool.cc
+++ b/net/http/http_proxy_client_socket_pool.cc
@@ -397,9 +397,21 @@ HttpProxyClientSocketPool::HttpProxyClientSocketPool(
new HttpProxyConnectJobFactory(transport_pool,
ssl_pool,
host_resolver,
- net_log)) {}
+ net_log)) {
+ // We should always have a |transport_pool_| except in unit tests.
+ if (transport_pool_)
+ transport_pool_->AddLayeredPool(this);
+ if (ssl_pool_)
+ ssl_pool_->AddLayeredPool(this);
+}
-HttpProxyClientSocketPool::~HttpProxyClientSocketPool() {}
+HttpProxyClientSocketPool::~HttpProxyClientSocketPool() {
+ if (ssl_pool_)
+ ssl_pool_->RemoveLayeredPool(this);
+ // We should always have a |transport_pool_| except in unit tests.
+ if (transport_pool_)
+ transport_pool_->RemoveLayeredPool(this);
+}
int HttpProxyClientSocketPool::RequestSocket(
const std::string& group_name, const void* socket_params,
@@ -438,6 +450,12 @@ void HttpProxyClientSocketPool::Flush() {
base_.Flush();
}
+bool HttpProxyClientSocketPool::IsStalled() const {
+ return base_.IsStalled() ||
+ (transport_pool_ && transport_pool_->IsStalled()) ||
+ (ssl_pool_ && ssl_pool_->IsStalled());
+}
+
void HttpProxyClientSocketPool::CloseIdleSockets() {
base_.CloseIdleSockets();
}
@@ -456,6 +474,14 @@ LoadState HttpProxyClientSocketPool::GetLoadState(
return base_.GetLoadState(group_name, handle);
}
+void HttpProxyClientSocketPool::AddLayeredPool(LayeredPool* layered_pool) {
+ base_.AddLayeredPool(layered_pool);
+}
+
+void HttpProxyClientSocketPool::RemoveLayeredPool(LayeredPool* layered_pool) {
+ base_.RemoveLayeredPool(layered_pool);
+}
+
DictionaryValue* HttpProxyClientSocketPool::GetInfoAsValue(
const std::string& name,
const std::string& type,
@@ -486,4 +512,10 @@ ClientSocketPoolHistograms* HttpProxyClientSocketPool::histograms() const {
return base_.histograms();
}
+bool HttpProxyClientSocketPool::CloseOneIdleConnection() {
+ if (base_.CloseOneIdleSocket())
+ return true;
+ return base_.CloseOneIdleConnectionInLayeredPool();
+}
+
} // namespace net
diff --git a/net/http/http_proxy_client_socket_pool.h b/net/http/http_proxy_client_socket_pool.h
index 1b0afb4..48a4b27 100644
--- a/net/http/http_proxy_client_socket_pool.h
+++ b/net/http/http_proxy_client_socket_pool.h
@@ -170,7 +170,9 @@ class HttpProxyConnectJob : public ConnectJob {
DISALLOW_COPY_AND_ASSIGN(HttpProxyConnectJob);
};
-class NET_EXPORT_PRIVATE HttpProxyClientSocketPool : public ClientSocketPool {
+class NET_EXPORT_PRIVATE HttpProxyClientSocketPool
+ : public ClientSocketPool,
+ public LayeredPool {
public:
HttpProxyClientSocketPool(
int max_sockets,
@@ -205,6 +207,8 @@ class NET_EXPORT_PRIVATE HttpProxyClientSocketPool : public ClientSocketPool {
virtual void Flush() OVERRIDE;
+ virtual bool IsStalled() const OVERRIDE;
+
virtual void CloseIdleSockets() OVERRIDE;
virtual int IdleSocketCount() const OVERRIDE;
@@ -216,6 +220,10 @@ class NET_EXPORT_PRIVATE HttpProxyClientSocketPool : public ClientSocketPool {
const std::string& group_name,
const ClientSocketHandle* handle) const OVERRIDE;
+ virtual void AddLayeredPool(LayeredPool* layered_pool) OVERRIDE;
+
+ virtual void RemoveLayeredPool(LayeredPool* layered_pool) OVERRIDE;
+
virtual base::DictionaryValue* GetInfoAsValue(
const std::string& name,
const std::string& type,
@@ -225,6 +233,9 @@ class NET_EXPORT_PRIVATE HttpProxyClientSocketPool : public ClientSocketPool {
virtual ClientSocketPoolHistograms* histograms() const OVERRIDE;
+ // LayeredPool implementation.
+ virtual bool CloseOneIdleConnection() OVERRIDE;
+
private:
typedef ClientSocketPoolBase<HttpProxySocketParams> PoolBase;
generated by cgit v1.1 at 2025-02-12 18:52:58 +0000