Remove implicit scoped_refptr operator T*

content/browser/renderer_host/p2p/socket_host_tcp.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/p2p/socket_host_tcp.h"
 
 #include "base/sys_byteorder.h"
 #include "content/common/p2p_messages.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
@@ skipping 90 matching lines @@
 
   VLOG(1) << "Local address: " << address.ToString();
   state_ = STATE_OPEN;
   message_sender_->Send(new P2PMsg_OnSocketCreated(id_, address));
   DoRead();
 }
 
 void P2PSocketHostTcp::DoRead() {
   int result;
   do {
-    if (!read_buffer_) {
+    if (!read_buffer_.get()) {
       read_buffer_ = new net::GrowableIOBuffer();
       read_buffer_->SetCapacity(kReadBufferSize);
     } else if (read_buffer_->RemainingCapacity() < kReadBufferSize) {
       // Make sure that we always have at least kReadBufferSize of
       // remaining capacity in the read buffer. Normally all packets
       // are smaller than kReadBufferSize, so this is not really
       // required.
       read_buffer_->SetCapacity(read_buffer_->capacity() + kReadBufferSize -
                                 read_buffer_->RemainingCapacity());
     }
-    result = socket_->Read(read_buffer_, read_buffer_->RemainingCapacity(),
-                           base::Bind(&P2PSocketHostTcp::OnRead,
-                                      base::Unretained(this)));
+    result = socket_->
+        Read(read_buffer_.get(), read_buffer_->RemainingCapacity(),
+             base::Bind(&P2PSocketHostTcp::OnRead,
+                        base::Unretained(this)));
     DidCompleteRead(result);
   } while (result > 0);
 }
 
 void P2PSocketHostTcp::OnRead(int result) {
   DidCompleteRead(result);
   if (state_ == STATE_OPEN) {
     DoRead();
   }
 }
@@ skipping 48 matching lines @@
 }
 
 void P2PSocketHostTcp::Send(const net::IPEndPoint& to,
                             const std::vector<char>& data) {
   if (!socket_.get()) {
     // The Send message may be sent after the an OnError message was
     // sent by hasn't been processed the renderer.
     return;
   }
 
-  if (write_buffer_) {
+  if (write_buffer_.get()) {
     // Silently drop packet if we haven't finished sending previous
     // packet.
     VLOG(1) << "Dropping TCP packet.";
     return;
   }
 
   if (!(to == remote_address_)) {
     // Renderer should use this socket only to send data to
     // |remote_address_|.
     NOTREACHED();
@@ skipping 16 matching lines @@
   write_buffer_ = new net::DrainableIOBuffer(new net::IOBuffer(size), size);
   *reinterpret_cast<uint16*>(write_buffer_->data()) =
       base::HostToNet16(data.size());
   memcpy(write_buffer_->data() + kPacketHeaderSize, &data[0], data.size());
 
   DoWrite();
 }
 
 void P2PSocketHostTcp::DoWrite() {
   while (true) {
-    int result = socket_->Write(write_buffer_, write_buffer_->BytesRemaining(),
-                                base::Bind(&P2PSocketHostTcp::OnWritten,
-                                           base::Unretained(this)));
+    int result = socket_->
+        Write(write_buffer_.get(), write_buffer_->BytesRemaining(),
+              base::Bind(&P2PSocketHostTcp::OnWritten,
+                         base::Unretained(this)));
     if (result >= 0) {
       write_buffer_->DidConsume(result);
       if (write_buffer_->BytesRemaining() == 0) {
         write_buffer_ = NULL;
         break;
       }
     } else {
       if (result != net::ERR_IO_PENDING) {
         LOG(ERROR) << "Error when sending data in TCP socket: " << result;
         OnError();
@@ skipping 23 matching lines @@
 }
 
 P2PSocketHost* P2PSocketHostTcp::AcceptIncomingTcpConnection(
     const net::IPEndPoint& remote_address, int id) {
   NOTREACHED();
   OnError();
   return NULL;
 }
 
 } // namespace content