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

media/cast/receiver/video_decoder.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/video_decoder.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
            Codec codec)
       : cast_environment_(cast_environment),
         codec_(codec),
         operational_status_(STATUS_UNINITIALIZED),
         seen_first_frame_(false) {}
 
   OperationalStatus InitializationResult() const {
     return operational_status_;
   }
 
-  void DecodeFrame(scoped_ptr<EncodedFrame> encoded_frame,
+  void DecodeFrame(std::unique_ptr<EncodedFrame> encoded_frame,
                    const DecodeFrameCallback& callback) {
     DCHECK_EQ(operational_status_, STATUS_INITIALIZED);
 
     static_assert(sizeof(encoded_frame->frame_id) == sizeof(last_frame_id_),
                   "size of frame_id types do not match");
     bool is_continuous = true;
     if (seen_first_frame_) {
       const uint32_t frames_ahead = encoded_frame->frame_id - last_frame_id_;
       if (frames_ahead > 1) {
         RecoverBecauseFramesWereDropped();
         is_continuous = false;
       }
     } else {
       seen_first_frame_ = true;
     }
     last_frame_id_ = encoded_frame->frame_id;
 
     const scoped_refptr<VideoFrame> decoded_frame = Decode(
         encoded_frame->mutable_bytes(),
         static_cast<int>(encoded_frame->data.size()));
     decoded_frame->set_timestamp(
         encoded_frame->rtp_timestamp.ToTimeDelta(kVideoFrequency));
 
-    scoped_ptr<FrameEvent> decode_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> decode_event(new FrameEvent());
     decode_event->timestamp = cast_environment_->Clock()->NowTicks();
     decode_event->type = FRAME_DECODED;
     decode_event->media_type = VIDEO_EVENT;
     decode_event->rtp_timestamp = encoded_frame->rtp_timestamp;
     decode_event->frame_id = encoded_frame->frame_id;
     cast_environment_->logger()->DispatchFrameEvent(std::move(decode_event));
 
     cast_environment_->PostTask(
         CastEnvironment::MAIN,
         FROM_HERE,
@@ skipping 114 matching lines @@
   }
 
  private:
   ~FakeImpl() final {}
 
   scoped_refptr<VideoFrame> Decode(uint8_t* data, int len) final {
     // Make sure this is a JSON string.
     if (!len || data[0] != '{')
       return NULL;
     base::JSONReader reader;
-    scoped_ptr<base::Value> values(
+    std::unique_ptr<base::Value> values(
         reader.Read(base::StringPiece(reinterpret_cast<char*>(data), len)));
     if (!values)
       return NULL;
     base::DictionaryValue* dict = NULL;
     values->GetAsDictionary(&dict);
 
     bool key = false;
     int id = 0;
     int ref = 0;
     dict->GetBoolean("key", &key);
@@ skipping 34 matching lines @@
 }
 
 VideoDecoder::~VideoDecoder() {}
 
 OperationalStatus VideoDecoder::InitializationResult() const {
   if (impl_.get())
     return impl_->InitializationResult();
   return STATUS_UNSUPPORTED_CODEC;
 }
 
-void VideoDecoder::DecodeFrame(
-    scoped_ptr<EncodedFrame> encoded_frame,
-    const DecodeFrameCallback& callback) {
+void VideoDecoder::DecodeFrame(std::unique_ptr<EncodedFrame> encoded_frame,
+                               const DecodeFrameCallback& callback) {
   DCHECK(encoded_frame.get());
   DCHECK(!callback.is_null());
   if (!impl_.get() || impl_->InitializationResult() != STATUS_INITIALIZED) {
     callback.Run(make_scoped_refptr<VideoFrame>(NULL), false);
     return;
   }
   cast_environment_->PostTask(CastEnvironment::VIDEO,
                               FROM_HERE,
                               base::Bind(&VideoDecoder::ImplBase::DecodeFrame,
                                          impl_,
                                          base::Passed(&encoded_frame),
                                          callback));
 }
 
 }  // namespace cast
 }  // namespace media