Convert //content/renderer from scoped_ptr to std::unique_ptr

content/renderer/pepper/video_decoder_shim.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 "content/renderer/pepper/video_decoder_shim.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <utility>
@@ skipping 638 matching lines @@
 
  private:
   void OnInitDone(bool success);
   void DoDecode();
   void OnDecodeComplete(media::DecodeStatus status);
   void OnOutputComplete(const scoped_refptr<media::VideoFrame>& frame);
   void OnResetComplete();
 
   // WeakPtr is bound to main_message_loop_. Use only in shim callbacks.
   base::WeakPtr<VideoDecoderShim> shim_;
-  scoped_ptr<media::VideoDecoder> decoder_;
+  std::unique_ptr<media::VideoDecoder> decoder_;
   bool initialized_ = false;
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   // Queue of decodes waiting for the decoder.
   typedef std::queue<PendingDecode> PendingDecodeQueue;
   PendingDecodeQueue pending_decodes_;
   bool awaiting_decoder_ = false;
   // VideoDecoder returns pictures without information about the decode buffer
   // that generated it, but VideoDecoder implementations used in this class
   // (media::FFmpegVideoDecoder and media::VpxVideoDecoder) always generate
   // corresponding frames before decode is finished. |decode_id_| is used to
@@ skipping 18 matching lines @@
     media::VideoDecoderConfig config) {
   DCHECK(!decoder_);
 #if !defined(MEDIA_DISABLE_LIBVPX)
   if (config.codec() == media::kCodecVP9) {
     decoder_.reset(new media::VpxVideoDecoder());
   } else
 #endif
 
 #if !defined(MEDIA_DISABLE_FFMPEG) && !defined(DISABLE_FFMPEG_VIDEO_DECODERS)
   {
-    scoped_ptr<media::FFmpegVideoDecoder> ffmpeg_video_decoder(
+    std::unique_ptr<media::FFmpegVideoDecoder> ffmpeg_video_decoder(
         new media::FFmpegVideoDecoder());
     ffmpeg_video_decoder->set_decode_nalus(true);
     decoder_ = std::move(ffmpeg_video_decoder);
   }
 #elif defined(MEDIA_DISABLE_LIBVPX)
   OnInitDone(false);
   return;
 #endif
 
   // VpxVideoDecoder and FFmpegVideoDecoder support only one pending Decode()
@@ skipping 14 matching lines @@
   DCHECK(decoder_);
   pending_decodes_.push(PendingDecode(decode_id, buffer));
   DoDecode();
 }
 
 void VideoDecoderShim::DecoderImpl::Reset() {
   DCHECK(decoder_);
   // Abort all pending decodes.
   while (!pending_decodes_.empty()) {
     const PendingDecode& decode = pending_decodes_.front();
-    scoped_ptr<PendingFrame> pending_frame(new PendingFrame(decode.decode_id));
+    std::unique_ptr<PendingFrame> pending_frame(
+        new PendingFrame(decode.decode_id));
     main_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoDecoderShim::OnDecodeComplete, shim_, PP_OK,
                               decode.decode_id));
     pending_decodes_.pop();
   }
   // Don't need to call Reset() if the |decoder_| hasn't been initialized.
   if (!initialized_) {
     OnResetComplete();
     return;
   }
@@ skipping 58 matching lines @@
 
   DoDecode();
 }
 
 void VideoDecoderShim::DecoderImpl::OnOutputComplete(
     const scoped_refptr<media::VideoFrame>& frame) {
   // Software decoders are expected to generated frames only when a Decode()
   // call is pending.
   DCHECK(awaiting_decoder_);
 
-  scoped_ptr<PendingFrame> pending_frame;
+  std::unique_ptr<PendingFrame> pending_frame;
   if (!frame->metadata()->IsTrue(media::VideoFrameMetadata::END_OF_STREAM))
     pending_frame.reset(new PendingFrame(decode_id_, frame));
   else
     pending_frame.reset(new PendingFrame(decode_id_));
 
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoDecoderShim::OnOutputComplete, shim_,
                             base::Passed(&pending_frame)));
 }
 
@@ skipping 181 matching lines @@
   num_pending_decodes_--;
   completed_decodes_.push(decode_id);
 
   // If frames are being queued because we're out of textures, don't notify
   // the host that decode has completed. This exerts "back pressure" to keep
   // the host from sending buffers that will cause pending_frames_ to grow.
   if (pending_frames_.empty())
     NotifyCompletedDecodes();
 }
 
-void VideoDecoderShim::OnOutputComplete(scoped_ptr<PendingFrame> frame) {
+void VideoDecoderShim::OnOutputComplete(std::unique_ptr<PendingFrame> frame) {
   DCHECK(RenderThreadImpl::current());
   DCHECK(host_);
 
   if (frame->video_frame) {
     if (texture_size_ != frame->video_frame->coded_size()) {
       // If the size has changed, all current textures must be dismissed. Add
       // all textures to |textures_to_dismiss_| and dismiss any that aren't in
       // use by the plugin. We will dismiss the rest as they are recycled.
       for (TextureIdMap::const_iterator it = texture_id_map_.begin();
            it != texture_id_map_.end();
@@ skipping 20 matching lines @@
 
     pending_frames_.push(std::move(frame));
     SendPictures();
   }
 }
 
 void VideoDecoderShim::SendPictures() {
   DCHECK(RenderThreadImpl::current());
   DCHECK(host_);
   while (!pending_frames_.empty() && !available_textures_.empty()) {
-    const scoped_ptr<PendingFrame>& frame = pending_frames_.front();
+    const std::unique_ptr<PendingFrame>& frame = pending_frames_.front();
 
     TextureIdSet::iterator it = available_textures_.begin();
     uint32_t texture_id = *it;
     available_textures_.erase(it);
 
     uint32_t local_texture_id = texture_id_map_[texture_id];
 
     yuv_converter_->Convert(frame->video_frame, local_texture_id);
 
     host_->PictureReady(media::Picture(texture_id, frame->decode_id,
@@ skipping 51 matching lines @@
 void VideoDecoderShim::DeleteTexture(uint32_t texture_id) {
   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
   gles2->DeleteTextures(1, &texture_id);
 }
 
 void VideoDecoderShim::FlushCommandBuffer() {
   context_provider_->ContextGL()->Flush();
 }
 
 }  // namespace content