Convert Pass()→std::move() in //media

media/cast/net/cast_transport_sender_impl.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/cast_transport_sender_impl.h"
 
 #include <stddef.h>
+#include <utility>
 
 #include "base/single_thread_task_runner.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "media/cast/net/cast_transport_defines.h"
 #include "media/cast/net/udp_transport.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_interfaces.h"
 
 namespace media {
@@ skipping 41 matching lines @@
     net::NetLog* net_log,
     base::TickClock* clock,
     const net::IPEndPoint& local_end_point,
     const net::IPEndPoint& remote_end_point,
     scoped_ptr<base::DictionaryValue> options,
     const CastTransportStatusCallback& status_callback,
     const BulkRawEventsCallback& raw_events_callback,
     base::TimeDelta raw_events_callback_interval,
     const PacketReceiverCallback& packet_callback,
     const scoped_refptr<base::SingleThreadTaskRunner>& transport_task_runner) {
-  return scoped_ptr<CastTransportSender>(
-      new CastTransportSenderImpl(net_log,
-                                  clock,
-                                  local_end_point,
-                                  remote_end_point,
-                                  options.Pass(),
-                                  status_callback,
-                                  raw_events_callback,
-                                  raw_events_callback_interval,
-                                  transport_task_runner.get(),
-                                  packet_callback,
-                                  NULL));
+  return scoped_ptr<CastTransportSender>(new CastTransportSenderImpl(
+      net_log, clock, local_end_point, remote_end_point, std::move(options),
+      status_callback, raw_events_callback, raw_events_callback_interval,
+      transport_task_runner.get(), packet_callback, NULL));
 }
 
 PacketReceiverCallback CastTransportSender::PacketReceiverForTesting() {
   return PacketReceiverCallback();
 }
 
 CastTransportSenderImpl::CastTransportSenderImpl(
     net::NetLog* net_log,
     base::TickClock* clock,
     const net::IPEndPoint& local_end_point,
@@ skipping 251 matching lines @@
 void CastTransportSenderImpl::SendRawEvents() {
   DCHECK(!raw_events_callback_.is_null());
 
   if (!recent_frame_events_.empty() || !recent_packet_events_.empty()) {
     scoped_ptr<std::vector<FrameEvent>> frame_events(
         new std::vector<FrameEvent>());
     frame_events->swap(recent_frame_events_);
     scoped_ptr<std::vector<PacketEvent>> packet_events(
         new std::vector<PacketEvent>());
     packet_events->swap(recent_packet_events_);
-    raw_events_callback_.Run(frame_events.Pass(), packet_events.Pass());
+    raw_events_callback_.Run(std::move(frame_events), std::move(packet_events));
   }
 
   transport_task_runner_->PostDelayedTask(
       FROM_HERE,
       base::Bind(&CastTransportSenderImpl::SendRawEvents,
                  weak_factory_.GetWeakPtr()),
       raw_events_callback_interval_);
 }
 
 bool CastTransportSenderImpl::OnReceivedPacket(scoped_ptr<Packet> packet) {
@@ skipping 16 matching lines @@
     return true;
   }
   if (video_rtcp_session_ &&
       video_rtcp_session_->IncomingRtcpPacket(data, length)) {
     return true;
   }
   if (packet_callback_.is_null()) {
     VLOG(1) << "Stale packet received.";
     return false;
   }
-  packet_callback_.Run(packet.Pass());
+  packet_callback_.Run(std::move(packet));
   return true;
 }
 
 void CastTransportSenderImpl::OnReceivedLogMessage(
     EventMediaType media_type,
     const RtcpReceiverLogMessage& log) {
   if (raw_events_callback_.is_null())
     return;
 
   // Add received log messages into our log system.
@@ skipping 90 matching lines @@
                   sender_ssrc);
   rtcp.SendRtcpFromRtpReceiver(time_data,
                                cast_message,
                                target_delay,
                                rtcp_events,
                                rtp_receiver_statistics);
 }
 
 }  // namespace cast
 }  // namespace media