Fixes to socket_test_util.cc.

net/http/http_network_transaction_unittest.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 2130 matching lines @@
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
     MockRead(true, 0, 0),
   };
 
-  scoped_refptr<DelayedSocketData> spdy_data(
+  scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
@@ skipping 63 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp_data(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> body_data(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp_authentication, 2),
     CreateMockRead(*body_authentication, 3),
     CreateMockRead(*resp_data, 5),
     CreateMockRead(*body_data, 6),
     MockRead(true, 0, 7),
   };
 
-  scoped_refptr<OrderedSocketData> data(
+  scoped_ptr<OrderedSocketData> data(
       new OrderedSocketData(spdy_reads, arraysize(spdy_reads),
                             spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(data);
+  session_deps.socket_factory.AddSocketDataProvider(data.get());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   TestCompletionCallback callback1;
 
@@ skipping 70 matching lines @@
   scoped_ptr<spdy::SpdyFrame> wrapped_body(
       ConstructSpdyBodyFrame(1, "1234567890", 10, false));
   MockRead spdy_reads[] = {
     CreateMockRead(*conn_resp, 2, true),
     CreateMockRead(*wrapped_get_resp, 4, true),
     CreateMockRead(*wrapped_body, 5, true),
     CreateMockRead(*wrapped_body, 6, true),
     MockRead(true, 0, 7),
   };
 
-  scoped_refptr<OrderedSocketData> spdy_data(
+  scoped_ptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(true, OK);
   ssl2.was_npn_negotiated = false;
   ssl2.protocol_negotiated = SSLClientSocket::kProtoUnknown;
@@ skipping 50 matching lines @@
       ConstructWrappedSpdyFrame(get_resp, 1));
   scoped_ptr<spdy::SpdyFrame> body(ConstructSpdyBodyFrame(1, true));
   scoped_ptr<spdy::SpdyFrame> wrapped_body(ConstructWrappedSpdyFrame(body, 1));
   MockRead spdy_reads[] = {
     CreateMockRead(*conn_resp, 2, true),
     CreateMockRead(*wrapped_get_resp, 4, true),
     CreateMockRead(*wrapped_body, 5, true),
     MockRead(true, 0, 1),
   };
 
-  scoped_refptr<OrderedSocketData> spdy_data(
+  scoped_ptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(true, OK);
   ssl2.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl2.next_proto = "spdy/2";
@@ skipping 44 matching lines @@
       CreateMockWrite(*get, 3),
   };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdySynReplyError(1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp, 2, true),
     MockRead(true, 0, 4),
   };
 
-  scoped_refptr<OrderedSocketData> spdy_data(
+  scoped_ptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
   SSLSocketDataProvider ssl2(true, OK);
   ssl2.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl2.next_proto = "spdy/2";
@@ skipping 2232 matching lines @@
     "http://login.example.com/",
   };
   scoped_ptr<spdy::SpdyFrame> resp(
       ConstructSpdySynReplyError("302 Redirect", kExtraHeaders,
                                  arraysize(kExtraHeaders)/2, 1));
   MockRead data_reads[] = {
     CreateMockRead(*resp.get(), 1, false),
     MockRead(true, 0, 2),  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           data_reads, arraysize(data_reads),
           data_writes, arraysize(data_writes)));
   SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
   proxy_ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   proxy_ssl.next_proto = "spdy/2";
   proxy_ssl.was_npn_negotiated = true;
   proxy_ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
 
@@ skipping 99 matching lines @@
       ConstructSpdySynReplyError("404 Not Found", kExtraHeaders,
                                  arraysize(kExtraHeaders)/2, 1));
   scoped_ptr<spdy::SpdyFrame> body(
       ConstructSpdyBodyFrame(1, "The host does not exist", 23, true));
   MockRead data_reads[] = {
     CreateMockRead(*resp.get(), 1, false),
     CreateMockRead(*body.get(), 2, false),
     MockRead(true, 0, 3),  // EOF
   };
 
-  scoped_refptr<DelayedSocketData> data(
+  scoped_ptr<DelayedSocketData> data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           data_reads, arraysize(data_reads),
           data_writes, arraysize(data_writes)));
   SSLSocketDataProvider proxy_ssl(true, OK);  // SSL to the proxy
   proxy_ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   proxy_ssl.next_proto = "spdy/2";
   proxy_ssl.was_npn_negotiated = true;
   proxy_ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
 
@@ skipping 1983 matching lines @@
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
     MockRead(true, 0, 0),
   };
 
-  scoped_refptr<DelayedSocketData> spdy_data(
+  scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   MockConnect never_finishing_connect(false, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
 
   TestCompletionCallback callback;
@@ skipping 83 matching lines @@
   scoped_ptr<spdy::SpdyFrame> resp2(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> data2(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp1),
     CreateMockRead(*data1),
     CreateMockRead(*resp2),
     CreateMockRead(*data2),
     MockRead(true, 0, 0),
   };
 
-  scoped_refptr<DelayedSocketData> spdy_data(
+  scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           2,  // wait for writes to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
   // Socket 4 is the successful Alternate-Protocol for transaction 3.
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   // Socket 5 is the unsuccessful non-Alternate-Protocol for transaction 3.
   session_deps.socket_factory.AddSocketDataProvider(&hanging_socket);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   TestCompletionCallback callback1;
   HttpNetworkTransaction trans1(session);
 
   int rv = trans1.Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 218 matching lines @@
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     MockRead(true, kCONNECTResponse, arraysize(kCONNECTResponse) - 1, 1),  // 1
     CreateMockRead(*resp.get(), 4),  // 2, 4
     CreateMockRead(*data.get(), 4),  // 5
     MockRead(true, 0, 0, 4),  // 6
   };
 
-  scoped_refptr<OrderedSocketData> spdy_data(
+  scoped_ptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   MockConnect never_finishing_connect(false, ERR_IO_PENDING);
   StaticSocketDataProvider hanging_non_alternate_protocol_socket(
       NULL, 0, NULL, 0);
   hanging_non_alternate_protocol_socket.set_connect_data(
       never_finishing_connect);
   session_deps.socket_factory.AddSocketDataProvider(
       &hanging_non_alternate_protocol_socket);
 
   TestCompletionCallback callback;
@@ skipping 76 matching lines @@
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
     MockRead(true, 0, 0),
   };
 
-  scoped_refptr<DelayedSocketData> spdy_data(
+  scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(OK, callback.WaitForResult());
@@ skipping 855 matching lines @@
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_ptr<spdy::SpdyFrame> req(ConstructSpdyGet(NULL, 0, false, 1, LOWEST));
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   MockRead spdy_reads[] = {
     MockRead(false, 0, 0)   // Not async - return 0 immediately.
   };
 
-  scoped_refptr<DelayedSocketData> spdy_data(
+  scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           0,  // don't wait in this case, immediate hangup.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   TestCompletionCallback callback;
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
   scoped_ptr<HttpNetworkTransaction> trans(new HttpNetworkTransaction(session));
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_EQ(ERR_CONNECTION_CLOSED, callback.WaitForResult());
 
@@ skipping 90 matching lines @@
 
     // Second connection attempt passes
     MockRead(true, kAcceptConnectResponse,
              arraysize(kAcceptConnectResponse) -1, 4),
 
     // SPDY response
     CreateMockRead(*resp.get(), 6),
     CreateMockRead(*data.get(), 6),
     MockRead(true, 0, 0, 6),
   };
-  scoped_refptr<OrderedSocketData> data_2(
+  scoped_ptr<OrderedSocketData> data_2(
       new OrderedSocketData(data_reads_2, arraysize(data_reads_2),
                             data_writes_2, arraysize(data_writes_2)));
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
 
   MockConnect never_finishing_connect(false, ERR_IO_PENDING);
@@ skipping 260 matching lines @@
   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
 
   scoped_ptr<spdy::SpdyFrame> resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> data(ConstructSpdyBodyFrame(1, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*resp),
     CreateMockRead(*data),
     MockRead(true, 0, 0),
   };
 
-  scoped_refptr<DelayedSocketData> spdy_data(
+  scoped_ptr<DelayedSocketData> spdy_data(
       new DelayedSocketData(
           1,  // wait for one write to finish before reading.
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   SSLSocketDataProvider ssl(true, OK);
   ssl.next_proto_status = SSLClientSocket::kNextProtoNegotiated;
   ssl.next_proto = "spdy/2";
   ssl.was_npn_negotiated = true;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY2;
   session_deps.socket_factory.AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps));
 
@@ skipping 445 matching lines @@
   scoped_ptr<spdy::SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     CreateMockRead(*host2_resp, 5),
     CreateMockRead(*host2_resp_body, 6),
     MockRead(true, 0, 7),
   };
 
-  scoped_refptr<OrderedSocketData> spdy_data(
+  scoped_ptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
   HttpNetworkTransaction trans1(session);
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 129 matching lines @@
   scoped_ptr<spdy::SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 3));
   scoped_ptr<spdy::SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(3, true));
   MockRead spdy_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     CreateMockRead(*host2_resp, 5),
     CreateMockRead(*host2_resp_body, 6),
     MockRead(true, 0, 7),
   };
 
-  scoped_refptr<OrderedSocketData> spdy_data(
+  scoped_ptr<OrderedSocketData> spdy_data(
       new OrderedSocketData(
           spdy_reads, arraysize(spdy_reads),
           spdy_writes, arraysize(spdy_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy_data.get());
 
   TestCompletionCallback callback;
   HttpRequestInfo request1;
   request1.method = "GET";
   request1.url = GURL("https://www.google.com/");
   request1.load_flags = 0;
   HttpNetworkTransaction trans1(session);
 
   int rv = trans1.Start(&request1, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 130 matching lines @@
     CreateMockWrite(*host1_req, 1),
   };
   scoped_ptr<spdy::SpdyFrame> host1_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> host1_resp_body(ConstructSpdyBodyFrame(1, true));
   MockRead spdy1_reads[] = {
     CreateMockRead(*host1_resp, 2),
     CreateMockRead(*host1_resp_body, 3),
     MockRead(true, ERR_IO_PENDING, 4),
   };
 
-  scoped_refptr<OrderedSocketData> spdy1_data(
+  scoped_ptr<OrderedSocketData> spdy1_data(
       new OrderedSocketData(
           spdy1_reads, arraysize(spdy1_reads),
           spdy1_writes, arraysize(spdy1_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy1_data);
+  session_deps.socket_factory.AddSocketDataProvider(spdy1_data.get());
 
   scoped_ptr<spdy::SpdyFrame> host2_req(ConstructSpdyGet(
       "https://www.b.com", false, 1, LOWEST));
   MockWrite spdy2_writes[] = {
     CreateMockWrite(*host2_req, 1),
   };
   scoped_ptr<spdy::SpdyFrame> host2_resp(ConstructSpdyGetSynReply(NULL, 0, 1));
   scoped_ptr<spdy::SpdyFrame> host2_resp_body(ConstructSpdyBodyFrame(1, true));
   MockRead spdy2_reads[] = {
     CreateMockRead(*host2_resp, 2),
     CreateMockRead(*host2_resp_body, 3),
     MockRead(true, ERR_IO_PENDING, 4),
   };
 
-  scoped_refptr<OrderedSocketData> spdy2_data(
+  scoped_ptr<OrderedSocketData> spdy2_data(
       new OrderedSocketData(
           spdy2_reads, arraysize(spdy2_reads),
           spdy2_writes, arraysize(spdy2_writes)));
-  session_deps.socket_factory.AddSocketDataProvider(spdy2_data);
+  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"),
@@ skipping 93 matching lines @@
       session->spdy_session_pool()->HasSession(host_port_proxy_pair_b));
 
   HttpStreamFactory::set_next_protos(std::vector<std::string>());
   ClientSocketPoolManager::set_max_sockets_per_pool(old_max_sockets_per_pool);
   ClientSocketPoolManager::set_max_sockets_per_proxy_server(
       old_max_sockets_per_proxy_server);
   ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets_per_group);
 }
 
 }  // namespace net