Remove implicit conversions from scoped_refptr to T* in net/socket/

net/socket/unix_domain_client_socket_posix_unittest.cc

 // Copyright 2014 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/unix_domain_client_socket_posix.h"
 
 #include <unistd.h>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 44 matching lines @@
   scoped_refptr<DrainableIOBuffer> read_buf(
       new DrainableIOBuffer(buf, buf_len));
   TestCompletionCallback read_callback;
   // Iterate reading several times (but not infinite) until it reads at least
   // |min_data_len| bytes into |buf|.
   for (int retry_count = 10;
        retry_count > 0 && (read_buf->BytesConsumed() < min_data_len ||
                            // Try at least once when min_data_len == 0.
                            min_data_len == 0);
        --retry_count) {
-    int rv = socket->Read(read_buf, read_buf->BytesRemaining(),
-                          read_callback.callback());
+    int rv = socket->Read(
+        read_buf.get(), read_buf->BytesRemaining(), read_callback.callback());
     EXPECT_GE(read_buf->BytesRemaining(), rv);
     if (rv == ERR_IO_PENDING) {
       // If |min_data_len| is 0, returns ERR_IO_PENDING to distinguish the case
       // when some data has been read.
       if (min_data_len == 0) {
         // No data has been read because of for-loop condition.
         DCHECK_EQ(0, read_buf->BytesConsumed());
         return ERR_IO_PENDING;
       }
       rv = read_callback.WaitForResult();
@@ skipping 12 matching lines @@
 int WriteSynchronously(StreamSocket* socket,
                        IOBuffer* buf,
                        int buf_len) {
   scoped_refptr<DrainableIOBuffer> write_buf(
       new DrainableIOBuffer(buf, buf_len));
   TestCompletionCallback write_callback;
   // Iterate writing several times (but not infinite) until it writes buf fully.
   for (int retry_count = 10;
        retry_count > 0 && write_buf->BytesRemaining() > 0;
        --retry_count) {
-    int rv = socket->Write(write_buf, write_buf->BytesRemaining(),
+    int rv = socket->Write(write_buf.get(),
+                           write_buf->BytesRemaining(),
                            write_callback.callback());
     EXPECT_GE(write_buf->BytesRemaining(), rv);
     if (rv == ERR_IO_PENDING)
       rv = write_callback.WaitForResult();
     EXPECT_NE(ERR_IO_PENDING, rv);
     if (rv < 0)
       return rv;
     write_buf->DidConsume(rv);
   }
   EXPECT_LE(0, write_buf->BytesRemaining());
@@ skipping 102 matching lines @@
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Try to read data.
   const int kReadDataSize = 10;
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize));
   TestCompletionCallback read_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            accepted_socket->Read(read_buffer, kReadDataSize,
-                                  read_callback.callback()));
+            accepted_socket->Read(
+                read_buffer.get(), kReadDataSize, read_callback.callback()));
 
   // Disconnect from client side.
   client_socket.Disconnect();
   EXPECT_FALSE(client_socket.IsConnected());
   EXPECT_FALSE(accepted_socket->IsConnected());
 
   // Connection closed by peer.
   EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult());
   // Note that read callback won't be called when the connection is closed
   // locally before the peer closes it. SocketLibevent just clears callbacks.
@@ skipping 11 matching lines @@
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Try to read data.
   const int kReadDataSize = 10;
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadDataSize));
   TestCompletionCallback read_callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            client_socket.Read(read_buffer, kReadDataSize,
-                               read_callback.callback()));
+            client_socket.Read(
+                read_buffer.get(), kReadDataSize, read_callback.callback()));
 
   // Disconnect from server side.
   accepted_socket->Disconnect();
   EXPECT_FALSE(accepted_socket->IsConnected());
   EXPECT_FALSE(client_socket.IsConnected());
 
   // Connection closed by peer.
   EXPECT_EQ(0 /* EOF */, read_callback.WaitForResult());
   // Note that read callback won't be called when the connection is closed
   // locally before the peer closes it. SocketLibevent just clears callbacks.
@@ skipping 10 matching lines @@
   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Send data from client to server.
   const int kWriteDataSize = 10;
   scoped_refptr<IOBuffer> write_buffer(
       new StringIOBuffer(std::string(kWriteDataSize, 'd')));
-  EXPECT_EQ(kWriteDataSize,
-            WriteSynchronously(&client_socket,
-                               write_buffer,
-                               kWriteDataSize));
+  EXPECT_EQ(
+      kWriteDataSize,
+      WriteSynchronously(&client_socket, write_buffer.get(), kWriteDataSize));
 
   // The buffer is bigger than write data size.
   const int kReadBufferSize = kWriteDataSize * 2;
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   EXPECT_EQ(kWriteDataSize,
             ReadSynchronously(accepted_socket.get(),
-                              read_buffer,
+                              read_buffer.get(),
                               kReadBufferSize,
                               kWriteDataSize));
   EXPECT_EQ(std::string(write_buffer->data(), kWriteDataSize),
             std::string(read_buffer->data(), kWriteDataSize));
 
   // Send data from server and client.
   EXPECT_EQ(kWriteDataSize,
-            WriteSynchronously(accepted_socket.get(),
-                               write_buffer,
-                               kWriteDataSize));
+            WriteSynchronously(
+                accepted_socket.get(), write_buffer.get(), kWriteDataSize));
 
   // Read multiple times.
   const int kSmallReadBufferSize = kWriteDataSize / 3;
   EXPECT_EQ(kSmallReadBufferSize,
             ReadSynchronously(&client_socket,
-                              read_buffer,
+                              read_buffer.get(),
                               kSmallReadBufferSize,
                               kSmallReadBufferSize));
   EXPECT_EQ(std::string(write_buffer->data(), kSmallReadBufferSize),
             std::string(read_buffer->data(), kSmallReadBufferSize));
 
   EXPECT_EQ(kWriteDataSize - kSmallReadBufferSize,
             ReadSynchronously(&client_socket,
-                              read_buffer,
+                              read_buffer.get(),
                               kReadBufferSize,
                               kWriteDataSize - kSmallReadBufferSize));
   EXPECT_EQ(std::string(write_buffer->data() + kSmallReadBufferSize,
                         kWriteDataSize - kSmallReadBufferSize),
             std::string(read_buffer->data(),
                         kWriteDataSize - kSmallReadBufferSize));
 
   // No more data.
-  EXPECT_EQ(ERR_IO_PENDING,
-            ReadSynchronously(&client_socket,
-                              read_buffer,
-                              kReadBufferSize,
-                              0));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      ReadSynchronously(&client_socket, read_buffer.get(), kReadBufferSize, 0));
 
   // Disconnect from server side after read-write.
   accepted_socket->Disconnect();
   EXPECT_FALSE(accepted_socket->IsConnected());
   EXPECT_FALSE(client_socket.IsConnected());
 }
 
 TEST_F(UnixDomainClientSocketTest, ReadBeforeWrite) {
   UnixDomainServerSocket server_socket(CreateAuthCallback(true), false);
   EXPECT_EQ(OK, server_socket.ListenWithAddressAndPort(socket_path_, 0, 1));
   scoped_ptr<StreamSocket> accepted_socket;
   TestCompletionCallback accept_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             server_socket.Accept(&accepted_socket, accept_callback.callback()));
   UnixDomainClientSocket client_socket(socket_path_, false);
   EXPECT_EQ(OK, ConnectSynchronously(&client_socket));
 
   EXPECT_EQ(OK, accept_callback.WaitForResult());
   EXPECT_TRUE(accepted_socket->IsConnected());
   EXPECT_TRUE(client_socket.IsConnected());
 
   // Wait for data from client.
   const int kWriteDataSize = 10;
   const int kReadBufferSize = kWriteDataSize * 2;
   const int kSmallReadBufferSize = kWriteDataSize / 3;
   // Read smaller than write data size first.
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   TestCompletionCallback read_callback;
-  EXPECT_EQ(ERR_IO_PENDING,
-            accepted_socket->Read(read_buffer, kSmallReadBufferSize,
-                                  read_callback.callback()));
+  EXPECT_EQ(
+      ERR_IO_PENDING,
+      accepted_socket->Read(
+          read_buffer.get(), kSmallReadBufferSize, read_callback.callback()));
 
   scoped_refptr<IOBuffer> write_buffer(
       new StringIOBuffer(std::string(kWriteDataSize, 'd')));
-  EXPECT_EQ(kWriteDataSize,
-            WriteSynchronously(&client_socket,
-                               write_buffer,
-                               kWriteDataSize));
+  EXPECT_EQ(
+      kWriteDataSize,
+      WriteSynchronously(&client_socket, write_buffer.get(), kWriteDataSize));
 
   // First read completed.
   int rv = read_callback.WaitForResult();
   EXPECT_LT(0, rv);
   EXPECT_LE(rv, kSmallReadBufferSize);
 
   // Read remaining data.
   const int kExpectedRemainingDataSize = kWriteDataSize - rv;
   EXPECT_LE(0, kExpectedRemainingDataSize);
   EXPECT_EQ(kExpectedRemainingDataSize,
             ReadSynchronously(accepted_socket.get(),
-                              read_buffer,
+                              read_buffer.get(),
                               kReadBufferSize,
                               kExpectedRemainingDataSize));
   // No more data.
   EXPECT_EQ(ERR_IO_PENDING,
-            ReadSynchronously(accepted_socket.get(),
-                              read_buffer,
-                              kReadBufferSize,
-                              0));
+            ReadSynchronously(
+                accepted_socket.get(), read_buffer.get(), kReadBufferSize, 0));
 
   // Disconnect from server side after read-write.
   accepted_socket->Disconnect();
   EXPECT_FALSE(accepted_socket->IsConnected());
   EXPECT_FALSE(client_socket.IsConnected());
 }
 
 }  // namespace
 }  // namespace net