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

media/cast/sender/h264_vt_encoder.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/h264_vt_encoder.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 389 matching lines @@
     DLOG(ERROR) << "WrapVideoFrameInCVPixelBuffer failed.";
     return false;
   }
 
   // Convert the frame timestamp to CMTime.
   auto timestamp_cm = CoreMediaGlue::CMTimeMake(
       video_frame->timestamp().InMicroseconds(), USEC_PER_SEC);
 
   // Wrap information we'll need after the frame is encoded in a heap object.
   // We'll get the pointer back from the VideoToolbox completion callback.
-  scoped_ptr<InProgressFrameEncode> request(new InProgressFrameEncode(
+  std::unique_ptr<InProgressFrameEncode> request(new InProgressFrameEncode(
       RtpTimeTicks::FromTimeDelta(video_frame->timestamp(), kVideoFrequency),
       reference_time, frame_encoded_callback));
 
   // Build a suitable frame properties dictionary for keyframes.
   base::ScopedCFTypeRef<CFDictionaryRef> frame_props;
   if (encode_next_frame_as_keyframe_) {
     frame_props = video_toolbox::DictionaryWithKeyValue(
         videotoolbox_glue_->kVTEncodeFrameOptionKey_ForceKeyFrame(),
         kCFBooleanTrue);
     encode_next_frame_as_keyframe_ = false;
@@ skipping 42 matching lines @@
 void H264VideoToolboxEncoder::SetBitRate(int /*new_bit_rate*/) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // VideoToolbox does not seem to support bitrate reconfiguration.
 }
 
 void H264VideoToolboxEncoder::GenerateKeyFrame() {
   DCHECK(thread_checker_.CalledOnValidThread());
   encode_next_frame_as_keyframe_ = true;
 }
 
-scoped_ptr<VideoFrameFactory>
+std::unique_ptr<VideoFrameFactory>
 H264VideoToolboxEncoder::CreateVideoFrameFactory() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  return scoped_ptr<VideoFrameFactory>(
+  return std::unique_ptr<VideoFrameFactory>(
       new VideoFrameFactoryImpl::Proxy(video_frame_factory_));
 }
 
 void H264VideoToolboxEncoder::EmitFrames() {
   DCHECK(thread_checker_.CalledOnValidThread());
   if (!compression_session_)
     return;
 
   OSStatus status = videotoolbox_glue_->VTCompressionSessionCompleteFrames(
       compression_session_, CoreMediaGlue::CMTime{0, 0, 0, 0});
@@ skipping 22 matching lines @@
     ResetCompressionSession();
   }
 }
 
 void H264VideoToolboxEncoder::CompressionCallback(void* encoder_opaque,
                                                   void* request_opaque,
                                                   OSStatus status,
                                                   VTEncodeInfoFlags info,
                                                   CMSampleBufferRef sbuf) {
   auto encoder = reinterpret_cast<H264VideoToolboxEncoder*>(encoder_opaque);
-  const scoped_ptr<InProgressFrameEncode> request(
+  const std::unique_ptr<InProgressFrameEncode> request(
       reinterpret_cast<InProgressFrameEncode*>(request_opaque));
   bool keyframe = false;
   bool has_frame_data = false;
 
   if (status != noErr) {
     DLOG(ERROR) << " encoding failed: " << status;
     encoder->cast_environment_->PostTask(
         CastEnvironment::MAIN, FROM_HERE,
         base::Bind(encoder->status_change_cb_, STATUS_CODEC_RUNTIME_ERROR));
   } else if ((info & VideoToolboxGlue::kVTEncodeInfo_FrameDropped)) {
@@ skipping 10 matching lines @@
     keyframe = !CFDictionaryContainsKey(
                    sample_attachments,
                    CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
     has_frame_data = true;
   }
 
   // Increment the encoder-scoped frame id and assign the new value to this
   // frame. VideoToolbox calls the output callback serially, so this is safe.
   const uint32_t frame_id = ++encoder->last_frame_id_;
 
-  scoped_ptr<SenderEncodedFrame> encoded_frame(new SenderEncodedFrame());
+  std::unique_ptr<SenderEncodedFrame> encoded_frame(new SenderEncodedFrame());
   encoded_frame->frame_id = frame_id;
   encoded_frame->reference_time = request->reference_time;
   encoded_frame->rtp_timestamp = request->rtp_timestamp;
   if (keyframe) {
     encoded_frame->dependency = EncodedFrame::KEY;
     encoded_frame->referenced_frame_id = frame_id;
   } else {
     encoded_frame->dependency = EncodedFrame::DEPENDENT;
     // H.264 supports complex frame reference schemes (multiple reference
     // frames, slice references, backward and forward references, etc). Cast
@@ skipping 18 matching lines @@
   encoded_frame->encode_completion_time =
       encoder->cast_environment_->Clock()->NowTicks();
   encoder->cast_environment_->PostTask(
       CastEnvironment::MAIN, FROM_HERE,
       base::Bind(request->frame_encoded_callback,
                  base::Passed(&encoded_frame)));
 }
 
 }  // namespace cast
 }  // namespace media