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

This patch was generated by running the rewrite_scoped_refptr clang tool
on a Linux build.

BUG=110610

Review URL: https://codereview.chromium.org/503113004

Cr-Commit-Position: refs/heads/master@{#291788}

net/socket/socket_libevent.cc

@@ -440,7 +440,7 @@ int SocketLibevent::DoRead(IOBuffer* buf, int buf_len) {
 }
 
 void SocketLibevent::ReadCompleted() {
-  int rv = DoRead(read_buf_, read_buf_len_);
+  int rv = DoRead(read_buf_.get(), read_buf_len_);
   if (rv == ERR_IO_PENDING)
     return;
 
@@ -457,7 +457,7 @@ int SocketLibevent::DoWrite(IOBuffer* buf, int buf_len) {
 }
 
 void SocketLibevent::WriteCompleted() {
-  int rv = DoWrite(write_buf_, write_buf_len_);
+  int rv = DoWrite(write_buf_.get(), write_buf_len_);
   if (rv == ERR_IO_PENDING)
     return;
 

net/socket/socket_test_util.cc

@@ -857,7 +857,7 @@ int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len,
     return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
-  DCHECK(pending_buf_ == NULL);
+  DCHECK(pending_buf_.get() == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
@@ -965,7 +965,7 @@ bool MockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
 
 void MockTCPClientSocket::OnReadComplete(const MockRead& data) {
   // There must be a read pending.
-  DCHECK(pending_buf_);
+  DCHECK(pending_buf_.get());
   // You can't complete a read with another ERR_IO_PENDING status code.
   DCHECK_NE(ERR_IO_PENDING, data.result);
   // Since we've been waiting for data, need_read_data_ should be true.
@@ -989,7 +989,7 @@ void MockTCPClientSocket::OnConnectComplete(const MockConnect& data) {
 }
 
 int MockTCPClientSocket::CompleteRead() {
-  DCHECK(pending_buf_);
+  DCHECK(pending_buf_.get());
   DCHECK(pending_buf_len_ > 0);
 
   was_used_to_convey_data_ = true;
@@ -1560,7 +1560,7 @@ int MockUDPClientSocket::Read(IOBuffer* buf,
     return ERR_UNEXPECTED;
 
   // If the buffer is already in use, a read is already in progress!
-  DCHECK(pending_buf_ == NULL);
+  DCHECK(pending_buf_.get() == NULL);
 
   // Store our async IO data.
   pending_buf_ = buf;
@@ -1637,7 +1637,7 @@ int MockUDPClientSocket::Connect(const IPEndPoint& address) {
 
 void MockUDPClientSocket::OnReadComplete(const MockRead& data) {
   // There must be a read pending.
-  DCHECK(pending_buf_);
+  DCHECK(pending_buf_.get());
   // You can't complete a read with another ERR_IO_PENDING status code.
   DCHECK_NE(ERR_IO_PENDING, data.result);
   // Since we've been waiting for data, need_read_data_ should be true.
@@ -1660,7 +1660,7 @@ void MockUDPClientSocket::OnConnectComplete(const MockConnect& data) {
 }
 
 int MockUDPClientSocket::CompleteRead() {
-  DCHECK(pending_buf_);
+  DCHECK(pending_buf_.get());
   DCHECK(pending_buf_len_ > 0);
 
   // Save the pending async IO data and reset our |pending_| state.

net/socket/ssl_client_socket_nss.cc

@@ -3451,7 +3451,7 @@ void SSLClientSocketNSS::VerifyCT() {
   // gets all the data it needs for SCT verification and does not do any
   // external communication.
   int result = cert_transparency_verifier_->Verify(
-      server_cert_verify_result_.verified_cert,
+      server_cert_verify_result_.verified_cert.get(),
       core_->state().stapled_ocsp_response,
       core_->state().sct_list_from_tls_extension,
       &ct_verify_result_,

net/socket/ssl_client_socket_unittest.cc

@@ -433,7 +433,7 @@ int FakeBlockingStreamSocket::Write(IOBuffer* buf,
     return transport_->Write(buf, len, callback);
 
   // Schedule the write, but do nothing.
-  DCHECK(!pending_write_buf_);
+  DCHECK(!pending_write_buf_.get());
   DCHECK_EQ(-1, pending_write_len_);
   DCHECK(pending_write_callback_.is_null());
   DCHECK(!callback.is_null());
@@ -489,11 +489,11 @@ void FakeBlockingStreamSocket::UnblockWrite() {
 
   // Do nothing if UnblockWrite() was called after BlockWrite(),
   // without a Write() in between.
-  if (!pending_write_buf_)
+  if (!pending_write_buf_.get())
     return;
 
-  int rv = transport_->Write(pending_write_buf_, pending_write_len_,
-                             pending_write_callback_);
+  int rv = transport_->Write(
+      pending_write_buf_.get(), pending_write_len_, pending_write_callback_);
   pending_write_buf_ = NULL;
   pending_write_len_ = -1;
   if (rv == ERR_IO_PENDING) {
@@ -507,12 +507,12 @@ void FakeBlockingStreamSocket::WaitForWrite() {
   DCHECK(should_block_write_);
   DCHECK(!write_loop_);
 
-  if (pending_write_buf_)
+  if (pending_write_buf_.get())
     return;
   write_loop_.reset(new base::RunLoop);
   write_loop_->Run();
   write_loop_.reset();
-  DCHECK(pending_write_buf_);
+  DCHECK(pending_write_buf_.get());
 }
 
 void FakeBlockingStreamSocket::OnReadCompleted(int result) {
@@ -2345,7 +2345,7 @@ TEST_F(SSLClientSocketTest, VerifyReturnChainProperlyOrdered) {
   // Load and install the root for the validated chain.
   scoped_refptr<X509Certificate> root_cert = ImportCertFromFile(
       GetTestCertsDirectory(), "redundant-validated-chain-root.pem");
-  ASSERT_NE(static_cast<X509Certificate*>(NULL), root_cert);
+  ASSERT_NE(static_cast<X509Certificate*>(NULL), root_cert.get());
   ScopedTestRoot scoped_root(root_cert.get());
 
   // Set up a test server with CERT_CHAIN_WRONG_ROOT.

net/socket/ssl_server_socket_unittest.cc

@@ -63,7 +63,7 @@ class FakeDataChannel {
 
   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback) {
     DCHECK(read_callback_.is_null());
-    DCHECK(!read_buf_);
+    DCHECK(!read_buf_.get());
     if (closed_)
       return 0;
     if (data_.empty()) {

net/socket/tcp_socket_libevent.cc

@@ -499,7 +499,7 @@ void TCPSocketLibevent::ReadCompleted(const scoped_refptr<IOBuffer>& buf,
   // TODO(rdsmith,jri): Change histogram name to indicate it could be called on
   // error.
   RecordFastOpenStatus();
-  callback.Run(HandleReadCompleted(buf, rv));
+  callback.Run(HandleReadCompleted(buf.get(), rv));
 }
 
 int TCPSocketLibevent::HandleReadCompleted(IOBuffer* buf, int rv) {
@@ -520,7 +520,7 @@ void TCPSocketLibevent::WriteCompleted(const scoped_refptr<IOBuffer>& buf,
                                        const CompletionCallback& callback,
                                        int rv) const {
   DCHECK_NE(ERR_IO_PENDING, rv);
-  callback.Run(HandleWriteCompleted(buf, rv));
+  callback.Run(HandleWriteCompleted(buf.get(), rv));
 }
 
 int TCPSocketLibevent::HandleWriteCompleted(IOBuffer* buf, int rv) const {

net/socket/unix_domain_client_socket_posix_unittest.cc

@@ -62,8 +62,8 @@ int ReadSynchronously(StreamSocket* socket,
                            // 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
@@ -96,7 +96,8 @@ int WriteSynchronously(StreamSocket* socket,
   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)
@@ -219,8 +220,8 @@ TEST_F(UnixDomainClientSocketTest, DisconnectFromClient) {
   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();
@@ -252,8 +253,8 @@ TEST_F(UnixDomainClientSocketTest, DisconnectFromServer) {
   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();
@@ -284,17 +285,16 @@ TEST_F(UnixDomainClientSocketTest, ReadAfterWrite) {
   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),
@@ -302,15 +302,14 @@ TEST_F(UnixDomainClientSocketTest, ReadAfterWrite) {
 
   // 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),
@@ -318,7 +317,7 @@ TEST_F(UnixDomainClientSocketTest, ReadAfterWrite) {
 
   EXPECT_EQ(kWriteDataSize - kSmallReadBufferSize,
             ReadSynchronously(&client_socket,
-                              read_buffer,
+                              read_buffer.get(),
                               kReadBufferSize,
                               kWriteDataSize - kSmallReadBufferSize));
   EXPECT_EQ(std::string(write_buffer->data() + kSmallReadBufferSize,
@@ -327,11 +326,9 @@ TEST_F(UnixDomainClientSocketTest, ReadAfterWrite) {
                         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();
@@ -360,16 +357,16 @@ TEST_F(UnixDomainClientSocketTest, ReadBeforeWrite) {
   // 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();
@@ -381,15 +378,13 @@ TEST_F(UnixDomainClientSocketTest, ReadBeforeWrite) {
   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();

net/socket/unix_domain_server_socket_posix_unittest.cc

@@ -97,8 +97,8 @@ TEST_F(UnixDomainServerSocketTest, AcceptWithForbiddenUser) {
   const int read_buffer_size = 10;
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(read_buffer_size));
   TestCompletionCallback read_callback;
-  rv = read_callback.GetResult(client_socket.Read(read_buffer, read_buffer_size,
-                                                  read_callback.callback()));
+  rv = read_callback.GetResult(client_socket.Read(
+      read_buffer.get(), read_buffer_size, read_callback.callback()));
 
   // The server should have disconnected gracefully, without sending any data.
   ASSERT_EQ(0, rv);