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

media/cast/sender/frame_sender.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/sender/frame_sender.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 #include <vector>
@@ skipping 195 matching lines @@
 base::TimeDelta FrameSender::GetAllowedInFlightMediaDuration() const {
   // The total amount allowed in-flight media should equal the amount that fits
   // within the entire playout delay window, plus the amount of time it takes to
   // receive an ACK from the receiver.
   // TODO(miu): Research is needed, but there is likely a better formula.
   return target_playout_delay_ + (current_round_trip_time_ / 2);
 }
 
 void FrameSender::SendEncodedFrame(
     int requested_bitrate_before_encode,
-    scoped_ptr<SenderEncodedFrame> encoded_frame) {
+    std::unique_ptr<SenderEncodedFrame> encoded_frame) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   VLOG(2) << SENDER_SSRC << "About to send another frame: last_sent="
           << last_sent_frame_id_ << ", latest_acked=" << latest_acked_frame_id_;
 
   const uint32_t frame_id = encoded_frame->frame_id;
   const bool is_first_frame_to_be_sent = last_send_time_.is_null();
 
   if (picture_lost_at_receiver_ &&
       (encoded_frame->dependency == EncodedFrame::KEY)) {
@@ skipping 13 matching lines @@
   // |latest_acked_frame_id_| to indicate the receiver starts out all caught up.
   // Also, schedule the periodic frame re-send checks.
   if (is_first_frame_to_be_sent) {
     latest_acked_frame_id_ = frame_id - 1;
     ScheduleNextResendCheck();
   }
 
   VLOG_IF(1, !is_audio_ && encoded_frame->dependency == EncodedFrame::KEY)
       << SENDER_SSRC << "Sending encoded key frame, id=" << frame_id;
 
-  scoped_ptr<FrameEvent> encode_event(new FrameEvent());
+  std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
   encode_event->timestamp = encoded_frame->encode_completion_time;
   encode_event->type = FRAME_ENCODED;
   encode_event->media_type = is_audio_ ? AUDIO_EVENT : VIDEO_EVENT;
   encode_event->rtp_timestamp = encoded_frame->rtp_timestamp;
   encode_event->frame_id = frame_id;
   encode_event->size = base::checked_cast<uint32_t>(encoded_frame->data.size());
   encode_event->key_frame = encoded_frame->dependency == EncodedFrame::KEY;
   encode_event->target_bitrate = requested_bitrate_before_encode;
   encode_event->encoder_cpu_utilization = encoded_frame->deadline_utilization;
   encode_event->idealized_bitrate_utilization =
@@ skipping 93 matching lines @@
   }
 
   base::TimeTicks now = cast_environment_->Clock()->NowTicks();
   congestion_control_->AckFrame(cast_feedback.ack_frame_id, now);
   if (!cast_feedback.received_later_frames.empty()) {
     // Ack the received frames.
     congestion_control_->AckLaterFrames(cast_feedback.received_later_frames,
                                         now);
   }
 
-  scoped_ptr<FrameEvent> ack_event(new FrameEvent());
+  std::unique_ptr<FrameEvent> ack_event(new FrameEvent());
   ack_event->timestamp = now;
   ack_event->type = FRAME_ACK_RECEIVED;
   ack_event->media_type = is_audio_ ? AUDIO_EVENT : VIDEO_EVENT;
   ack_event->rtp_timestamp =
       GetRecordedRtpTimestamp(cast_feedback.ack_frame_id);
   ack_event->frame_id = cast_feedback.ack_frame_id;
   cast_environment_->logger()->DispatchFrameEvent(std::move(ack_event));
 
   const bool is_acked_out_of_order =
       static_cast<int32_t>(cast_feedback.ack_frame_id -
@@ skipping 69 matching lines @@
     VLOG(1) << SENDER_SSRC << "Dropping: In-flight duration would be too high.";
     return true;
   }
 
   // Next frame is accepted.
   return false;
 }
 
 }  // namespace cast
 }  // namespace media