Update content/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/renderer_host/pepper/pepper_udp_socket_private_message_filter.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_udp_socket_private_message_filter.h"
 
 #include <cstring>
 #include <limits>
 
 #include "base/compiler_specific.h"
@@ skipping 147 matching lines @@
 int32_t PepperUDPSocketPrivateMessageFilter::OnMsgRecvFrom(
     const ppapi::host::HostMessageContext* context,
     int32_t num_bytes) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(context);
   DCHECK(socket_.get());
 
   if (closed_)
     return PP_ERROR_FAILED;
 
-  if (recvfrom_buffer_)
+  if (recvfrom_buffer_.get())
     return PP_ERROR_INPROGRESS;
   if (num_bytes > ppapi::proxy::UDPSocketPrivateResource::kMaxReadSize) {
     // |num_bytes| value is checked on the plugin side.
     NOTREACHED();
     num_bytes = ppapi::proxy::UDPSocketPrivateResource::kMaxReadSize;
   }
   recvfrom_buffer_ = new net::IOBuffer(num_bytes);
   int result = socket_->RecvFrom(
-      recvfrom_buffer_, num_bytes, &recvfrom_address_,
+      recvfrom_buffer_.get(),
+      num_bytes,
+      &recvfrom_address_,
       base::Bind(&PepperUDPSocketPrivateMessageFilter::OnRecvFromCompleted,
-                 this, context->MakeReplyMessageContext()));
+                 this,
+                 context->MakeReplyMessageContext()));
   if (result != net::ERR_IO_PENDING)
     OnRecvFromCompleted(context->MakeReplyMessageContext(), result);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PepperUDPSocketPrivateMessageFilter::OnMsgSendTo(
     const ppapi::host::HostMessageContext* context,
     const std::string& data,
     const PP_NetAddress_Private& addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 66 matching lines @@
     const std::string& data,
     const PP_NetAddress_Private& addr) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(socket_.get());
 
   if (closed_) {
     SendSendToError(context, PP_ERROR_FAILED);
     return;
   }
 
-  if (sendto_buffer_) {
+  if (sendto_buffer_.get()) {
     SendSendToError(context, PP_ERROR_INPROGRESS);
     return;
   }
 
   if (data.empty() ||
       data.size() > static_cast<size_t>(std::numeric_limits<int>::max())) {
     SendSendToError(context, PP_ERROR_BADARGUMENT);
     return;
   }
   size_t num_bytes = data.size();
   if (num_bytes > static_cast<size_t>(
           ppapi::proxy::UDPSocketPrivateResource::kMaxWriteSize)) {
     // Size of |data| is checked on the plugin side.
     NOTREACHED();
     num_bytes = static_cast<size_t>(
         ppapi::proxy::UDPSocketPrivateResource::kMaxWriteSize);
   }
   sendto_buffer_ = new net::IOBufferWithSize(num_bytes);
   memcpy(sendto_buffer_->data(), data.data(), num_bytes);
 
   net::IPAddressNumber address;
   int port;
   if (!NetAddressPrivateImpl::NetAddressToIPEndPoint(addr, &address, &port)) {
     SendSendToError(context, PP_ERROR_FAILED);
     return;
   }
 
   int result = socket_->SendTo(
-      sendto_buffer_, sendto_buffer_->size(), net::IPEndPoint(address, port),
-      base::Bind(&PepperUDPSocketPrivateMessageFilter::OnSendToCompleted, this,
+      sendto_buffer_.get(),
+      sendto_buffer_->size(),
+      net::IPEndPoint(address, port),
+      base::Bind(&PepperUDPSocketPrivateMessageFilter::OnSendToCompleted,
+                 this,
                  context));
   if (result != net::ERR_IO_PENDING)
     OnSendToCompleted(context, result);
 }
 
 void PepperUDPSocketPrivateMessageFilter::Close() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (socket_.get() && !closed_)
     socket_->Close();
   closed_ = true;
@@ skipping 79 matching lines @@
                     NetAddressPrivateImpl::kInvalidNetAddress);
 }
 
 void PepperUDPSocketPrivateMessageFilter::SendSendToError(
     const ppapi::host::ReplyMessageContext& context,
     int32_t result) {
   SendSendToReply(context, result, 0);
 }
 
 }  // namespace content