Remove implicit conversions from scoped_refptr to T* in media/

media/cast/test/utility/udp_proxy.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 <math.h>
 #include <stdlib.h>
 #include <vector>
 
 #include "media/cast/test/utility/udp_proxy.h"
 
@@ skipping 420 matching lines @@
   ComputeRates();
 }
 
 InterruptedPoissonProcess::~InterruptedPoissonProcess() {
 }
 
 void InterruptedPoissonProcess::InitOnIOThread(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     base::TickClock* clock) {
   // Already initialized and started.
-  if (task_runner_ &&  clock_)
+  if (task_runner_.get() && clock_)
     return;
   task_runner_ = task_runner;
   clock_ = clock;
   UpdateRates();
   SwitchOn();
   SendPacket();
 }
 
 scoped_ptr<PacketPipe> InterruptedPoissonProcess::NewBuffer(size_t size) {
   scoped_ptr<InternalBuffer> buffer(
@@ skipping 233 matching lines @@
     // If it didn't work we just drop the packet at and call it a day.
     scoped_refptr<net::IOBuffer> buf =
         new net::WrappedIOBuffer(reinterpret_cast<char*>(&packet->front()));
     size_t buf_size = packet->size();
     int result;
     if (destination.address().empty()) {
       VLOG(1) << "Destination has not been set yet.";
       result = net::ERR_INVALID_ARGUMENT;
     } else {
       VLOG(1) << "Destination:" << destination.ToString();
-      result = socket_->SendTo(buf,
+      result = socket_->SendTo(buf.get(),

[ddorwin, 2014/08/25 21:26:39]

I believe this is a pointer to a RefCounted object, so it was fine as-is?

I'm not sure whether Cast actually uses this code, but this is what I'm looking
at.
https://code.google.com/p/chromium/codesearch#chromium/src/net/udp/udp_socket...

[dcheng, 2014/08/25 21:33:25]

Right, but before it was depending on the conversion operator to be invoked.
Since we're removing the implicit conversion, we need to force an explicit
conversion with .get().

[hubbe, 2014/08/27 00:46:21]

Explicit conversion is fine here.
The buffers lifetime is (intentionally) maintained by the callback below.

                                static_cast<int>(buf_size),
                                destination,
                                base::Bind(&UDPProxyImpl::AllowWrite,
                                           weak_factory_.GetWeakPtr(),
                                           buf,
                                           base::Passed(&packet)));
     }
     if (result == net::ERR_IO_PENDING) {
       blocked_ = true;
     } else if (result < 0) {
@@ skipping 60 matching lines @@
     ProcessPacket(recv_buf, len);
     PollRead();
   }
 
   void PollRead() {
     while (true) {
       packet_.reset(new Packet(kMaxPacketSize));
       scoped_refptr<net::IOBuffer> recv_buf =
           new net::WrappedIOBuffer(reinterpret_cast<char*>(&packet_->front()));
       int len = socket_->RecvFrom(
-          recv_buf,
+          recv_buf.get(),

[ddorwin, 2014/08/25 21:26:40]

ditto

[dcheng, 2014/08/25 21:33:25]

See above.

           kMaxPacketSize,
           &recv_address_,
-          base::Bind(&UDPProxyImpl::ReadCallback,
-                     base::Unretained(this),
-                     recv_buf));
+          base::Bind(
+              &UDPProxyImpl::ReadCallback, base::Unretained(this), recv_buf));
       if (len == net::ERR_IO_PENDING)
         break;
       ProcessPacket(recv_buf, len);
     }
   }
 
   void AllowWrite(scoped_refptr<net::IOBuffer> buf,
                   scoped_ptr<Packet> packet,
                   int unused_len) {
     DCHECK(blocked_);
@@ skipping 39 matching lines @@
                                             destination,
                                             to_dest_pipe.Pass(),
                                             from_dest_pipe.Pass(),
                                             net_log));
   return ret.Pass();
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media