Remove ref-counting from StreamListenSocket

net/socket/unix_domain_socket_posix_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 <errno.h>
 #include <fcntl.h>
 #include <poll.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/time.h>
@@ skipping 85 matching lines @@
   base::ConditionVariable condition_;
 };
 
 class TestListenSocketDelegate : public StreamListenSocket::Delegate {
  public:
   explicit TestListenSocketDelegate(
       const scoped_refptr<EventManager>& event_manager)
       : event_manager_(event_manager) {}
 
   virtual void DidAccept(StreamListenSocket* server,
-                         StreamListenSocket* connection) OVERRIDE {
+                         scoped_ptr<StreamListenSocket> connection) OVERRIDE {
     LOG(ERROR) << __PRETTY_FUNCTION__;
-    connection_ = connection;
+    connection_ = connection.Pass();
     Notify(EVENT_ACCEPT);
   }
 
   virtual void DidRead(StreamListenSocket* connection,
                        const char* data,
                        int len) OVERRIDE {
     {
       base::AutoLock lock(mutex_);
       DCHECK(len);
       data_.assign(data, len - 1);
@@ skipping 13 matching lines @@
     base::AutoLock lock(mutex_);
     return data_;
   }
 
  private:
   void Notify(EventType event) {
     event_manager_->Notify(event);
   }
 
   const scoped_refptr<EventManager> event_manager_;
-  scoped_refptr<StreamListenSocket> connection_;
+  scoped_ptr<StreamListenSocket> connection_;
   base::Lock mutex_;
   string data_;
 };
 
 bool UserCanConnectCallback(
     bool allow_user, const scoped_refptr<EventManager>& event_manager,
     uid_t, gid_t) {
   event_manager->Notify(
       allow_user ? EVENT_AUTH_GRANTED : EVENT_AUTH_DENIED);
   return allow_user;
@@ skipping 13 matching lines @@
         allow_user_(allow_user) {}
 
   virtual void SetUp() OVERRIDE {
     event_manager_ = new EventManager();
     socket_delegate_.reset(new TestListenSocketDelegate(event_manager_));
     DeleteSocketFile();
   }
 
   virtual void TearDown() OVERRIDE {
     DeleteSocketFile();
-    socket_ = NULL;
+    socket_.reset();
     socket_delegate_.reset();
     event_manager_ = NULL;
   }
 
   UnixDomainSocket::AuthCallback MakeAuthCallback() {
     return base::Bind(&UserCanConnectCallback, allow_user_, event_manager_);
   }
 
   void DeleteSocketFile() {
     ASSERT_FALSE(file_path_.empty());
@@ skipping 28 matching lines @@
         FROM_HERE,
         base::Bind(&UnixDomainSocketTestHelper::CreateAndListen,
                    base::Unretained(this)));
     return thread.Pass();
   }
 
   const base::FilePath file_path_;
   const bool allow_user_;
   scoped_refptr<EventManager> event_manager_;
   scoped_ptr<TestListenSocketDelegate> socket_delegate_;
-  scoped_refptr<UnixDomainSocket> socket_;
+  scoped_ptr<UnixDomainSocket> socket_;
 };
 
 class UnixDomainSocketTest : public UnixDomainSocketTestHelper {
  protected:
   UnixDomainSocketTest()
       : UnixDomainSocketTestHelper(MakeSocketPath(), true /* allow user */) {}
 };
 
 class UnixDomainSocketTestWithInvalidPath : public UnixDomainSocketTestHelper {
  protected:
@@ skipping 22 matching lines @@
 // Test with an invalid path to make sure that the socket is not backed by a
 // file.
 TEST_F(UnixDomainSocketTestWithInvalidPath,
        CreateAndListenWithAbstractNamespace) {
   socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
       file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
   EXPECT_FALSE(socket_.get() == NULL);
 }
 
 TEST_F(UnixDomainSocketTest, TestFallbackName) {
-  scoped_refptr<UnixDomainSocket> existing_socket =
+  scoped_ptr<UnixDomainSocket> existing_socket =
       UnixDomainSocket::CreateAndListenWithAbstractNamespace(
           file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
   EXPECT_FALSE(existing_socket.get() == NULL);
   // First, try to bind socket with the same name with no fallback name.
   socket_ =
       UnixDomainSocket::CreateAndListenWithAbstractNamespace(
           file_path_.value(), "", socket_delegate_.get(), MakeAuthCallback());
   EXPECT_TRUE(socket_.get() == NULL);
   // Now with a fallback name.
   socket_ = UnixDomainSocket::CreateAndListenWithAbstractNamespace(
       file_path_.value(),
       MakeSocketPath(kFallbackSocketName),
       socket_delegate_.get(),
       MakeAuthCallback());
   EXPECT_FALSE(socket_.get() == NULL);
-  existing_socket = NULL;
 }
 #endif
 
 TEST_F(UnixDomainSocketTest, TestWithClient) {
   const scoped_ptr<base::Thread> server_thread = CreateAndRunServerThread();
   EventType event = event_manager_->WaitForEvent();
   ASSERT_EQ(EVENT_LISTEN, event);
 
   // Create the client socket.
   const SocketDescriptor sock = CreateClientSocket();
@@ skipping 35 matching lines @@
 
   // Send() must fail.
   ssize_t ret = HANDLE_EINTR(send(sock, kMsg, sizeof(kMsg), 0));
   ASSERT_EQ(-1, ret);
   ASSERT_EQ(EPIPE, errno);
   ASSERT_FALSE(event_manager_->HasPendingEvent());
 }
 
 }  // namespace
 }  // namespace net