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

media/cast/receiver/frame_receiver.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/receiver/frame_receiver.h"
 
 #include <algorithm>
+#include <utility>
 
 #include "base/big_endian.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/constants.h"
 
@@ skipping 98 matching lines @@
 
   scoped_ptr<PacketEvent> receive_event(new PacketEvent());
   receive_event->timestamp = now;
   receive_event->type = PACKET_RECEIVED;
   receive_event->media_type = event_media_type_;
   receive_event->rtp_timestamp = rtp_header.rtp_timestamp;
   receive_event->frame_id = rtp_header.frame_id;
   receive_event->packet_id = rtp_header.packet_id;
   receive_event->max_packet_id = rtp_header.max_packet_id;
   receive_event->size = payload_size;
-  cast_environment_->logger()->DispatchPacketEvent(receive_event.Pass());
+  cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
 
   bool duplicate = false;
   const bool complete =
       framer_.InsertPacket(payload_data, payload_size, rtp_header, &duplicate);
 
   // Duplicate packets are ignored.
   if (duplicate)
     return;
 
   // Update lip-sync values upon receiving the first packet of each frame, or if
@@ skipping 38 matching lines @@
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpTimestamp rtp_timestamp =
       frame_id_to_rtp_timestamp_[cast_message.ack_frame_id & 0xff];
 
   scoped_ptr<FrameEvent> ack_sent_event(new FrameEvent());
   ack_sent_event->timestamp = now;
   ack_sent_event->type = FRAME_ACK_SENT;
   ack_sent_event->media_type = event_media_type_;
   ack_sent_event->rtp_timestamp = rtp_timestamp;
   ack_sent_event->frame_id = cast_message.ack_frame_id;
-  cast_environment_->logger()->DispatchFrameEvent(ack_sent_event.Pass());
+  cast_environment_->logger()->DispatchFrameEvent(std::move(ack_sent_event));
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber_.GetRtcpEventsWithRedundancy(&rtcp_events);
   transport_->SendRtcpFromRtpReceiver(rtcp_.GetLocalSsrc(),
                                       rtcp_.GetRemoteSsrc(),
                                       rtcp_.ConvertToNTPAndSave(now),
                                       &cast_message,
                                       target_playout_delay_,
                                       &rtcp_events,
                                       NULL);
@@ skipping 90 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   DCHECK(is_waiting_for_consecutive_frame_);
   is_waiting_for_consecutive_frame_ = false;
   EmitAvailableEncodedFrames();
 }
 
 void FrameReceiver::EmitOneFrame(const ReceiveEncodedFrameCallback& callback,
                                  scoped_ptr<EncodedFrame> encoded_frame) const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!callback.is_null())
-    callback.Run(encoded_frame.Pass());
+    callback.Run(std::move(encoded_frame));
 }
 
 base::TimeTicks FrameReceiver::GetPlayoutTime(const EncodedFrame& frame) const {
   base::TimeDelta target_playout_delay = target_playout_delay_;
   if (frame.new_playout_delay_ms) {
     target_playout_delay = base::TimeDelta::FromMilliseconds(
         frame.new_playout_delay_ms);
   }
   return lip_sync_reference_time_ + lip_sync_drift_.Current() +
          RtpDeltaToTimeDelta(static_cast<int32_t>(frame.rtp_timestamp -
@@ skipping 43 matching lines @@
                                       rtcp_.ConvertToNTPAndSave(now),
                                       NULL,
                                       base::TimeDelta(),
                                       NULL,
                                       &stats);
   ScheduleNextRtcpReport();
 }
 
 }  // namespace cast
 }  // namespace media