Remove ref-counting from StreamListenSocket

net/socket/transport_client_socket_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/socket/tcp_client_socket.h"
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/address_list.h"
@@ skipping 30 matching lines @@
       : listen_port_(0),
         socket_factory_(ClientSocketFactory::GetDefaultFactory()),
         close_server_socket_on_next_send_(false) {
   }
 
   virtual ~TransportClientSocketTest() {
   }
 
   // Implement StreamListenSocket::Delegate methods
   virtual void DidAccept(StreamListenSocket* server,
-                         StreamListenSocket* connection) OVERRIDE {
-    connected_sock_ = reinterpret_cast<TCPListenSocket*>(connection);
+                         scoped_ptr<StreamListenSocket> connection) OVERRIDE {
+    connected_sock_.reset(
+        static_cast<TCPListenSocket*>(connection.release()));
   }
   virtual void DidRead(StreamListenSocket*, const char* str, int len) OVERRIDE {
     // TODO(dkegel): this might not be long enough to tickle some bugs.
     connected_sock_->Send(kServerReply, arraysize(kServerReply) - 1,
                           false /* Don't append line feed */);
     if (close_server_socket_on_next_send_)
       CloseServerSocket();
   }
   virtual void DidClose(StreamListenSocket* sock) OVERRIDE {}
 
   // Testcase hooks
   virtual void SetUp();
 
   void CloseServerSocket() {
     // delete the connected_sock_, which will close it.
-    connected_sock_ = NULL;
+    connected_sock_.reset();
   }
 
   void PauseServerReads() {
     connected_sock_->PauseReads();
   }
 
   void ResumeServerReads() {
     connected_sock_->ResumeReads();
   }
 
   int DrainClientSocket(IOBuffer* buf,
                         uint32 buf_len,
                         uint32 bytes_to_read,
                         TestCompletionCallback* callback);
 
   void SendClientRequest();
 
   void set_close_server_socket_on_next_send(bool close) {
     close_server_socket_on_next_send_ = close;
   }
 
  protected:
   int listen_port_;
   CapturingNetLog net_log_;
   ClientSocketFactory* const socket_factory_;
   scoped_ptr<StreamSocket> sock_;
 
  private:
-  scoped_refptr<TCPListenSocket> listen_sock_;
-  scoped_refptr<TCPListenSocket> connected_sock_;
+  scoped_ptr<TCPListenSocket> listen_sock_;
+  scoped_ptr<TCPListenSocket> connected_sock_;
   bool close_server_socket_on_next_send_;
 };
 
 void TransportClientSocketTest::SetUp() {
   ::testing::TestWithParam<ClientSocketTestTypes>::SetUp();
 
   // Find a free port to listen on
-  scoped_refptr<TCPListenSocket> sock;
+  scoped_ptr<TCPListenSocket> sock;
   int port;
   // Range of ports to listen on.  Shouldn't need to try many.
   const int kMinPort = 10100;
   const int kMaxPort = 10200;
 #if defined(OS_WIN)
   EnsureWinsockInit();
 #endif
   for (port = kMinPort; port < kMaxPort; port++) {
     sock = TCPListenSocket::CreateAndListen("127.0.0.1", port, this);
     if (sock.get())
       break;
   }
   ASSERT_TRUE(sock.get() != NULL);
-  listen_sock_ = sock;
+  listen_sock_ = sock.Pass();
   listen_port_ = port;
 
   AddressList addr;
   // MockHostResolver resolves everything to 127.0.0.1.
   scoped_ptr<HostResolver> resolver(new MockHostResolver());
   HostResolver::RequestInfo info(HostPortPair("localhost", listen_port_));
   TestCompletionCallback callback;
   int rv = resolver->Resolve(
       info, DEFAULT_PRIORITY, &addr, callback.callback(), NULL, BoundNetLog());
   CHECK_EQ(ERR_IO_PENDING, rv);
@@ skipping 309 matching lines @@
 
   // It's possible the read is blocked because it's already read all the data.
   // Close the server socket, so there will at least be a 0-byte read.
   CloseServerSocket();
 
   rv = callback.WaitForResult();
   EXPECT_GE(rv, 0);
 }
 
 }  // namespace net