Convert //media/cast from scoped_ptr to std::unique_ptr

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 <string>
 
 #include "base/big_endian.h"
@@ skipping 63 matching lines @@
   cast_environment_->logger()->Unsubscribe(&event_subscriber_);
 }
 
 void FrameReceiver::RequestEncodedFrame(
     const ReceiveEncodedFrameCallback& callback) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   frame_request_queue_.push_back(callback);
   EmitAvailableEncodedFrames();
 }
 
-bool FrameReceiver::ProcessPacket(scoped_ptr<Packet> packet) {
+bool FrameReceiver::ProcessPacket(std::unique_ptr<Packet> packet) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   if (IsRtcpPacket(&packet->front(), packet->size())) {
     rtcp_.IncomingRtcpPacket(&packet->front(), packet->size());
   } else {
     RtpCastHeader rtp_header;
     const uint8_t* payload_data;
     size_t payload_size;
     if (!packet_parser_.ParsePacket(&packet->front(),
                                     packet->size(),
@@ skipping 19 matching lines @@
 void FrameReceiver::ProcessParsedPacket(const RtpCastHeader& rtp_header,
                                         const uint8_t* payload_data,
                                         size_t payload_size) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
 
   frame_id_to_rtp_timestamp_[rtp_header.frame_id & 0xff] =
       rtp_header.rtp_timestamp;
 
-  scoped_ptr<PacketEvent> receive_event(new PacketEvent());
+  std::unique_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 = base::checked_cast<uint32_t>(payload_size);
   cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
 
@@ skipping 42 matching lines @@
     EmitAvailableEncodedFrames();
 }
 
 void FrameReceiver::CastFeedback(const RtcpCastMessage& cast_message) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   RtpTimeTicks rtp_timestamp =
       frame_id_to_rtp_timestamp_[cast_message.ack_frame_id & 0xff];
 
-  scoped_ptr<FrameEvent> ack_sent_event(new FrameEvent());
+  std::unique_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(std::move(ack_sent_event));
 
   ReceiverRtcpEventSubscriber::RtcpEvents rtcp_events;
   event_subscriber_.GetRtcpEventsWithRedundancy(&rtcp_events);
   SendRtcpReport(rtcp_.local_ssrc(), rtcp_.remote_ssrc(),
                  CreateRtcpTimeData(now), &cast_message, nullptr,
                  target_playout_delay_, &rtcp_events, nullptr);
 }
 
 void FrameReceiver::EmitAvailableEncodedFrames() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   while (!frame_request_queue_.empty()) {
     // Attempt to peek at the next completed frame from the |framer_|.
     // TODO(miu): We should only be peeking at the metadata, and not copying the
     // payload yet!  Or, at least, peek using a StringPiece instead of a copy.
-    scoped_ptr<EncodedFrame> encoded_frame(
-        new EncodedFrame());
+    std::unique_ptr<EncodedFrame> encoded_frame(new EncodedFrame());
     bool is_consecutively_next_frame = false;
     bool have_multiple_complete_frames = false;
     if (!framer_.GetEncodedFrame(encoded_frame.get(),
                                  &is_consecutively_next_frame,
                                  &have_multiple_complete_frames)) {
       VLOG(1) << "Wait for more packets to produce a completed frame.";
       return;  // ProcessParsedPacket() will invoke this method in the future.
     }
 
     const base::TimeTicks now = cast_environment_->Clock()->NowTicks();
@@ skipping 65 matching lines @@
   }
 }
 
 void FrameReceiver::EmitAvailableEncodedFramesAfterWaiting() {
   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 {
+void FrameReceiver::EmitOneFrame(
+    const ReceiveEncodedFrameCallback& callback,
+    std::unique_ptr<EncodedFrame> encoded_frame) const {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (!callback.is_null())
     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);
@@ skipping 86 matching lines @@
     transport_->AddCastFeedback(*cast_message, target_delay);
   if (pli_message)
     transport_->AddPli(*pli_message);
   if (rtcp_events)
     transport_->AddRtcpEvents(*rtcp_events);
   transport_->SendRtcpFromRtpReceiver();
 }
 
 }  // namespace cast
 }  // namespace media