Remove implicit conversions from scoped_refptr to T* in media/

media/cast/net/udp_transport.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 "media/cast/net/udp_transport.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 98 matching lines @@
   DCHECK(io_thread_proxy_->RunsTasksOnCurrentThread());
 
   // Loop while UdpSocket is delivering data synchronously.  When it responds
   // with a "pending" status, break and expect this method to be called back in
   // the future when a packet is ready.
   while (true) {
     if (length_or_status == net::ERR_IO_PENDING) {
       next_packet_.reset(new Packet(kMaxPacketSize));
       recv_buf_ = new net::WrappedIOBuffer(
           reinterpret_cast<char*>(&next_packet_->front()));
-      length_or_status = udp_socket_->RecvFrom(
-          recv_buf_,
-          kMaxPacketSize,
-          &recv_addr_,
-          base::Bind(&UdpTransport::ReceiveNextPacket,
-                     weak_factory_.GetWeakPtr()));
+      length_or_status =
+          udp_socket_->RecvFrom(recv_buf_.get(),
+                                kMaxPacketSize,
+                                &recv_addr_,
+                                base::Bind(&UdpTransport::ReceiveNextPacket,
+                                           weak_factory_.GetWeakPtr()));
       if (length_or_status == net::ERR_IO_PENDING) {
         receive_pending_ = true;
         return;
       }
     }
 
     // Note: At this point, either a packet is ready or an error has occurred.
     if (length_or_status < 0) {
       VLOG(1) << "Failed to receive packet: Status code is "
               << length_or_status;
@@ skipping 54 matching lines @@
   int result;
   base::Callback<void(int)> callback = base::Bind(&UdpTransport::OnSent,
                                                   weak_factory_.GetWeakPtr(),
                                                   buf,
                                                   packet,
                                                   cb);
   if (client_connected_) {
     // If we called Connect() before we must call Write() instead of
     // SendTo(). Otherwise on some platforms we might get
     // ERR_SOCKET_IS_CONNECTED.
-    result = udp_socket_->Write(buf,
-                                static_cast<int>(packet->data.size()),
-                                callback);
+    result = udp_socket_->Write(
+        buf.get(), static_cast<int>(packet->data.size()), callback);
   } else if (!IsEmpty(remote_addr_)) {
-    result = udp_socket_->SendTo(buf,
+    result = udp_socket_->SendTo(buf.get(),
                                  static_cast<int>(packet->data.size()),
                                  remote_addr_,
                                  callback);
   } else {
     VLOG(1) << "Failed to send packet; socket is neither bound nor "
             << "connected.";
     return true;
   }
 
   if (result == net::ERR_IO_PENDING) {
@@ skipping 20 matching lines @@
   }
   ScheduleReceiveNextPacket();
 
   if (!cb.is_null()) {
     cb.Run();
   }
 }
 
 }  // namespace cast
 }  // namespace media