DeterministicSocketDataProvider should not be RefCounted

net/http/http_proxy_client_socket_pool_spdy2_unittest.cc

 // Copyright (c) 2012 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_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 136 matching lines @@
   }
 
   DeterministicMockClientSocketFactory& socket_factory() {
     return socket_factory_;
   }
 
   void Initialize(MockRead* reads, size_t reads_count,
                   MockWrite* writes, size_t writes_count,
                   MockRead* spdy_reads, size_t spdy_reads_count,
                   MockWrite* spdy_writes, size_t spdy_writes_count) {
-    if (GetParam() == SPDY)
-      data_ = new DeterministicSocketData(spdy_reads, spdy_reads_count,
-                                          spdy_writes, spdy_writes_count);
-    else
-      data_ = new DeterministicSocketData(reads, reads_count, writes,
-                                          writes_count);
+    if (GetParam() == SPDY) {
+      data_.reset(new DeterministicSocketData(spdy_reads, spdy_reads_count,
+                                              spdy_writes, spdy_writes_count));
+    } else {
+      data_.reset(new DeterministicSocketData(reads, reads_count, writes,
+                                              writes_count));
+    }
 
     data_->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     data_->StopAfter(2);  // Request / Response
 
     socket_factory_.AddSocketDataProvider(data_.get());
 
     if (GetParam() != HTTP) {
       ssl_data_.reset(new SSLSocketDataProvider(SYNCHRONOUS, OK));
       if (GetParam() == SPDY) {
         InitializeSpdySsl();
@@ skipping 37 matching lines @@
   SSLClientSocketPool ssl_socket_pool_;
 
   const scoped_ptr<HttpAuthHandlerFactory> http_auth_handler_factory_;
   HttpServerPropertiesImpl http_server_properties_;
   const scoped_refptr<HttpNetworkSession> session_;
   ClientSocketPoolHistograms http_proxy_histograms_;
   SpdyTestStateHelper spdy_state_;
 
  protected:
   scoped_ptr<SSLSocketDataProvider> ssl_data_;
-  scoped_refptr<DeterministicSocketData> data_;
+  scoped_ptr<DeterministicSocketData> data_;
   HttpProxyClientSocketPool pool_;
   ClientSocketHandle handle_;
   TestCompletionCallback callback_;
 };
 
 //-----------------------------------------------------------------------------
 // All tests are run with three different proxy types: HTTP, HTTPS (non-SPDY)
 // and SPDY.
 INSTANTIATE_TEST_CASE_P(HttpProxyClientSocketPoolSpdy2Tests,
                         HttpProxyClientSocketPoolSpdy2Test,
@@ skipping 147 matching lines @@
   EXPECT_EQ(OK, callback_.WaitForResult());
   EXPECT_TRUE(handle_.is_initialized());
   ASSERT_TRUE(handle_.socket());
   HttpProxyClientSocket* tunnel_socket =
           static_cast<HttpProxyClientSocket*>(handle_.socket());
   EXPECT_TRUE(tunnel_socket->IsConnected());
 }
 
 TEST_P(HttpProxyClientSocketPoolSpdy2Test, TCPError) {
   if (GetParam() == SPDY) return;
-  data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
+  data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
   data_->set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_CLOSED));
 
   socket_factory().AddSocketDataProvider(data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CONNECTION_FAILED, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
 TEST_P(HttpProxyClientSocketPoolSpdy2Test, SSLError) {
   if (GetParam() == HTTP) return;
-  data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
+  data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
   data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory().AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
                                             ERR_CERT_AUTHORITY_INVALID));
   if (GetParam() == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory().AddSSLSocketDataProvider(ssl_data_.get());
 
   int rv = handle_.Init("a", GetTunnelParams(), LOW, callback_.callback(),
                         &pool_, BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 
   EXPECT_EQ(ERR_PROXY_CERTIFICATE_INVALID, callback_.WaitForResult());
 
   EXPECT_FALSE(handle_.is_initialized());
   EXPECT_FALSE(handle_.socket());
 }
 
 TEST_P(HttpProxyClientSocketPoolSpdy2Test, SslClientAuth) {
   if (GetParam() == HTTP) return;
-  data_ = new DeterministicSocketData(NULL, 0, NULL, 0);
+  data_.reset(new DeterministicSocketData(NULL, 0, NULL, 0));
   data_->set_connect_data(MockConnect(ASYNC, OK));
   socket_factory().AddSocketDataProvider(data_.get());
 
   ssl_data_.reset(new SSLSocketDataProvider(ASYNC,
                                             ERR_SSL_CLIENT_AUTH_CERT_NEEDED));
   if (GetParam() == SPDY) {
     InitializeSpdySsl();
   }
   socket_factory().AddSSLSocketDataProvider(ssl_data_.get());
 
@@ skipping 94 matching lines @@
     // HTTPS or SPDY Proxy CONNECT responses are trustworthy
     EXPECT_EQ(ERR_HTTPS_PROXY_TUNNEL_RESPONSE, rv);
     EXPECT_TRUE(handle_.is_initialized());
     EXPECT_TRUE(handle_.socket());
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace net