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

media/cast/sender/external_video_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/external_video_encoder.h"
 
 #include <cmath>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 63 matching lines @@
 // to encode media::VideoFrames and emit media::cast::EncodedFrames.  All
 // methods must be called on the thread associated with the given
 // SingleThreadTaskRunner, except for the task_runner() accessor.
 class ExternalVideoEncoder::VEAClientImpl
     : public VideoEncodeAccelerator::Client,
       public base::RefCountedThreadSafe<VEAClientImpl> {
  public:
   VEAClientImpl(
       const scoped_refptr<CastEnvironment>& cast_environment,
       const scoped_refptr<base::SingleThreadTaskRunner>& encoder_task_runner,
-      scoped_ptr<media::VideoEncodeAccelerator> vea,
+      std::unique_ptr<media::VideoEncodeAccelerator> vea,
       int max_frame_rate,
       const StatusChangeCallback& status_change_cb,
       const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
       : cast_environment_(cast_environment),
         task_runner_(encoder_task_runner),
         max_frame_rate_(max_frame_rate),
         status_change_cb_(status_change_cb),
         create_video_encode_memory_cb_(create_video_encode_memory_cb),
         video_encode_accelerator_(std::move(vea)),
         encoder_active_(false),
@@ skipping 121 matching lines @@
       // Save the bitstream buffer in |stream_header_| to be sent later along
       // with the first key frame.
       //
       // TODO(miu): Should |stream_header_| be an std::ostringstream for
       // performance reasons?
       stream_header_.append(static_cast<const char*>(output_buffer->memory()),
                             payload_size);
     } else if (!in_progress_frame_encodes_.empty()) {
       const InProgressFrameEncode& request = in_progress_frame_encodes_.front();
 
-      scoped_ptr<SenderEncodedFrame> encoded_frame(new SenderEncodedFrame());
+      std::unique_ptr<SenderEncodedFrame> encoded_frame(
+          new SenderEncodedFrame());
       encoded_frame->dependency = key_frame ? EncodedFrame::KEY :
           EncodedFrame::DEPENDENT;
       encoded_frame->frame_id = next_frame_id_++;
       if (key_frame)
         encoded_frame->referenced_frame_id = encoded_frame->frame_id;
       else
         encoded_frame->referenced_frame_id = encoded_frame->frame_id - 1;
       encoded_frame->rtp_timestamp = RtpTimeTicks::FromTimeDelta(
           request.video_frame->timestamp(), kVideoFrequency);
       encoded_frame->reference_time = request.reference_time;
@@ skipping 117 matching lines @@
   ~VEAClientImpl() final {
     // According to the media::VideoEncodeAccelerator interface, Destroy()
     // should be called instead of invoking its private destructor.
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&media::VideoEncodeAccelerator::Destroy,
                    base::Unretained(video_encode_accelerator_.release())));
   }
 
   // Note: This method can be called on any thread.
-  void OnCreateSharedMemory(scoped_ptr<base::SharedMemory> memory) {
+  void OnCreateSharedMemory(std::unique_ptr<base::SharedMemory> memory) {
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&VEAClientImpl::OnReceivedSharedMemory,
                                       this,
                                       base::Passed(&memory)));
   }
 
-  void OnReceivedSharedMemory(scoped_ptr<base::SharedMemory> memory) {
+  void OnReceivedSharedMemory(std::unique_ptr<base::SharedMemory> memory) {
     DCHECK(task_runner_->RunsTasksOnCurrentThread());
 
     output_buffers_.push_back(std::move(memory));
 
     // Wait until all requested buffers are received.
     if (output_buffers_.size() < kOutputBufferCount)
       return;
 
     // Immediately provide all output buffers to the VEA.
     for (size_t i = 0; i < output_buffers_.size(); ++i) {
@@ skipping 61 matching lines @@
       }
     }
     return (num_slices == 0) ? -1 : (total_quantizer / num_slices);
   }
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   const int max_frame_rate_;
   const StatusChangeCallback status_change_cb_;  // Must be run on MAIN thread.
   const CreateVideoEncodeMemoryCallback create_video_encode_memory_cb_;
-  scoped_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
+  std::unique_ptr<media::VideoEncodeAccelerator> video_encode_accelerator_;
   bool encoder_active_;
   uint32_t next_frame_id_;
   bool key_frame_encountered_;
   std::string stream_header_;
   VideoCodecProfile codec_profile_;
   bool key_frame_quantizer_parsable_;
   H264Parser h264_parser_;
 
   // Shared memory buffers for output with the VideoAccelerator.
   ScopedVector<base::SharedMemory> output_buffers_;
@@ skipping 96 matching lines @@
 void ExternalVideoEncoder::GenerateKeyFrame() {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   key_frame_requested_ = true;
 }
 
 void ExternalVideoEncoder::OnCreateVideoEncodeAccelerator(
     const VideoSenderConfig& video_config,
     uint32_t first_frame_id,
     const StatusChangeCallback& status_change_cb,
     scoped_refptr<base::SingleThreadTaskRunner> encoder_task_runner,
-    scoped_ptr<media::VideoEncodeAccelerator> vea) {
+    std::unique_ptr<media::VideoEncodeAccelerator> vea) {
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
 
   // The callback will be invoked with null pointers in the case where the
   // system does not support or lacks the resources to provide GPU-accelerated
   // video encoding.
   if (!encoder_task_runner || !vea) {
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
         base::Bind(status_change_cb, STATUS_CODEC_INIT_FAILED));
@@ skipping 39 matching lines @@
     const CreateVideoEncodeAcceleratorCallback& create_vea_cb,
     const CreateVideoEncodeMemoryCallback& create_video_encode_memory_cb)
     : SizeAdaptableVideoEncoderBase(cast_environment,
                                     video_config,
                                     status_change_cb),
       create_vea_cb_(create_vea_cb),
       create_video_encode_memory_cb_(create_video_encode_memory_cb) {}
 
 SizeAdaptableExternalVideoEncoder::~SizeAdaptableExternalVideoEncoder() {}
 
-scoped_ptr<VideoEncoder> SizeAdaptableExternalVideoEncoder::CreateEncoder() {
-  return scoped_ptr<VideoEncoder>(new ExternalVideoEncoder(
-      cast_environment(),
-      video_config(),
-      frame_size(),
-      last_frame_id() + 1,
-      CreateEncoderStatusChangeCallback(),
-      create_vea_cb_,
+std::unique_ptr<VideoEncoder>
+SizeAdaptableExternalVideoEncoder::CreateEncoder() {
+  return std::unique_ptr<VideoEncoder>(new ExternalVideoEncoder(
+      cast_environment(), video_config(), frame_size(), last_frame_id() + 1,
+      CreateEncoderStatusChangeCallback(), create_vea_cb_,
       create_video_encode_memory_cb_));
 }
 
 QuantizerEstimator::QuantizerEstimator() {}
 
 QuantizerEstimator::~QuantizerEstimator() {}
 
 void QuantizerEstimator::Reset() {
   last_frame_pixel_buffer_.reset();
 }
@@ skipping 139 matching lines @@
   const double kEntropyAtMaxQuantizer = 7.5;
   const double slope =
       (MAX_VP8_QUANTIZER - MIN_VP8_QUANTIZER) / kEntropyAtMaxQuantizer;
   const double quantizer = std::min<double>(
       MAX_VP8_QUANTIZER, MIN_VP8_QUANTIZER + slope * shannon_entropy);
   return quantizer;
 }
 
 }  //  namespace cast
 }  //  namespace media