Remove implicit scoped_refptr operator T*

content/browser/renderer_host/pepper/pepper_tcp_socket.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 "content/browser/renderer_host/pepper/pepper_tcp_socket.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 150 matching lines @@
     SendReadACKError();
     return;
   }
 
   if (bytes_to_read > ppapi::TCPSocketPrivateImpl::kMaxReadSize) {
     NOTREACHED();
     bytes_to_read = ppapi::TCPSocketPrivateImpl::kMaxReadSize;
   }
 
   read_buffer_ = new net::IOBuffer(bytes_to_read);
-  int result = socket_->Read(read_buffer_, bytes_to_read,
+  int result = socket_->Read(read_buffer_.get(), bytes_to_read,
                              base::Bind(&PepperTCPSocket::OnReadCompleted,
                                         base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnReadCompleted(result);
 }
 
 void PepperTCPSocket::Write(const std::string& data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   if (!IsConnected() || write_buffer_base_.get() || write_buffer_.get() ||
       data.empty()) {
     SendWriteACKError();
     return;
   }
 
   int data_size = data.size();
   if (data_size > ppapi::TCPSocketPrivateImpl::kMaxWriteSize) {
     NOTREACHED();
     data_size = ppapi::TCPSocketPrivateImpl::kMaxWriteSize;
   }
 
   write_buffer_base_ = new net::IOBuffer(data_size);
   memcpy(write_buffer_base_->data(), data.data(), data_size);
-  write_buffer_ = new net::DrainableIOBuffer(write_buffer_base_, data_size);
+  write_buffer_ =
+      new net::DrainableIOBuffer(write_buffer_base_.get(), data_size);
   DoWrite();
 }
 
 void PepperTCPSocket::StartConnect(const net::AddressList& addresses) {
   DCHECK(connection_state_ == CONNECT_IN_PROGRESS);
 
   socket_.reset(
       new net::TCPClientSocket(addresses, NULL, net::NetLog::Source()));
   int result = socket_->Connect(
       base::Bind(&PepperTCPSocket::OnConnectCompleted,
@@ skipping 58 matching lines @@
 
 // static
 bool PepperTCPSocket::GetCertificateFields(
     const char* der,
     uint32_t length,
     ppapi::PPB_X509Certificate_Fields* fields) {
   scoped_refptr<net::X509Certificate> cert =
       net::X509Certificate::CreateFromBytes(der, length);
   if (!cert.get())
     return false;
-  return GetCertificateFields(*cert, fields);
+  return GetCertificateFields(*cert.get(), fields);
 }
 
 void PepperTCPSocket::SendReadACKError() {
   manager_->Send(new PpapiMsg_PPBTCPSocket_ReadACK(
     routing_id_, plugin_dispatcher_id_, socket_id_, false, std::string()));
 }
 
 void PepperTCPSocket::SendWriteACKError() {
   manager_->Send(new PpapiMsg_PPBTCPSocket_WriteACK(
       routing_id_, plugin_dispatcher_id_, socket_id_, false, 0));
 }
 
 void PepperTCPSocket::SendSSLHandshakeACK(bool succeeded) {
   ppapi::PPB_X509Certificate_Fields certificate_fields;
   if (succeeded) {
     // Our socket is guaranteed to be an SSL socket if we get here.
     net::SSLClientSocket* ssl_socket =
         static_cast<net::SSLClientSocket*>(socket_.get());
     net::SSLInfo ssl_info;
     ssl_socket->GetSSLInfo(&ssl_info);
     if (ssl_info.cert.get())
-      GetCertificateFields(*ssl_info.cert, &certificate_fields);
+      GetCertificateFields(*ssl_info.cert.get(), &certificate_fields);
   }
   manager_->Send(new PpapiMsg_PPBTCPSocket_SSLHandshakeACK(
       routing_id_,
       plugin_dispatcher_id_,
       socket_id_,
       succeeded,
       certificate_fields));
 }
 
 void PepperTCPSocket::OnResolveCompleted(int result) {
@@ skipping 96 matching lines @@
 
 bool PepperTCPSocket::IsConnected() const {
   return connection_state_ == CONNECTED || connection_state_ == SSL_CONNECTED;
 }
 
 void PepperTCPSocket::DoWrite() {
   DCHECK(write_buffer_base_.get());
   DCHECK(write_buffer_.get());
   DCHECK_GT(write_buffer_->BytesRemaining(), 0);
 
-  int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
-                              base::Bind(&PepperTCPSocket::OnWriteCompleted,
-                                         base::Unretained(this)));
+  int result = socket_->
+      Write(write_buffer_.get(), write_buffer_->BytesRemaining(),
+            base::Bind(&PepperTCPSocket::OnWriteCompleted,
+                       base::Unretained(this)));
   if (result != net::ERR_IO_PENDING)
     OnWriteCompleted(result);
 }
 
 }  // namespace content