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

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2012 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/filters/ffmpeg_demuxer.h"
 
 #include <algorithm>
+#include <memory>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 164 matching lines @@
                             const std::string& key,
                             base::TimeDelta value) {
   if (value == kInfiniteDuration())
     event->params.SetString(key, "kInfiniteDuration");
   else if (value == kNoTimestamp())
     event->params.SetString(key, "kNoTimestamp");
   else
     event->params.SetDouble(key, value.InSecondsF());
 }
 
-scoped_ptr<FFmpegDemuxerStream> FFmpegDemuxerStream::Create(
+std::unique_ptr<FFmpegDemuxerStream> FFmpegDemuxerStream::Create(
     FFmpegDemuxer* demuxer,
     AVStream* stream,
     const scoped_refptr<MediaLog>& media_log) {
   if (!demuxer || !stream)
     return nullptr;
 
-  scoped_ptr<FFmpegDemuxerStream> demuxer_stream;
-  scoped_ptr<AudioDecoderConfig> audio_config;
-  scoped_ptr<VideoDecoderConfig> video_config;
+  std::unique_ptr<FFmpegDemuxerStream> demuxer_stream;
+  std::unique_ptr<AudioDecoderConfig> audio_config;
+  std::unique_ptr<VideoDecoderConfig> video_config;
 
   if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
     audio_config.reset(new AudioDecoderConfig());
 
     // IsValidConfig() checks that the codec is supported and that the channel
     // layout and sample format are valid.
     //
     // TODO(chcunningham): Change AVStreamToAudioDecoderConfig to check
     // IsValidConfig internally and return a null scoped_ptr if not valid.
     if (!AVStreamToAudioDecoderConfig(stream, audio_config.get()) ||
@@ skipping 17 matching lines @@
         !video_config->IsValidConfig()) {
       MEDIA_LOG(ERROR, media_log)
           << "FFmpegDemuxer: failed creating video stream";
       return nullptr;
     }
 
     MEDIA_LOG(INFO, media_log) << "FFmpegDemuxer: created video stream, config "
                                << video_config->AsHumanReadableString();
   }
 
-  return make_scoped_ptr(new FFmpegDemuxerStream(
+  return base::WrapUnique(new FFmpegDemuxerStream(
       demuxer, stream, std::move(audio_config), std::move(video_config)));
 }
 
 //
 // FFmpegDemuxerStream
 //
 FFmpegDemuxerStream::FFmpegDemuxerStream(
     FFmpegDemuxer* demuxer,
     AVStream* stream,
-    scoped_ptr<AudioDecoderConfig> audio_config,
-    scoped_ptr<VideoDecoderConfig> video_config)
+    std::unique_ptr<AudioDecoderConfig> audio_config,
+    std::unique_ptr<VideoDecoderConfig> video_config)
     : demuxer_(demuxer),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       stream_(stream),
       audio_config_(audio_config.release()),
       video_config_(video_config.release()),
       type_(UNKNOWN),
       liveness_(LIVENESS_UNKNOWN),
       end_of_stream_(false),
       last_packet_timestamp_(kNoTimestamp()),
       last_packet_duration_(kNoTimestamp()),
@@ skipping 113 matching lines @@
                  settings_data, settings_data + settings_size,
                  &side_data);
 
     buffer = DecoderBuffer::CopyFrom(packet.get()->data, packet.get()->size,
                                      side_data.data(), side_data.size());
   } else {
     int side_data_size = 0;
     uint8_t* side_data = av_packet_get_side_data(
         packet.get(), AV_PKT_DATA_MATROSKA_BLOCKADDITIONAL, &side_data_size);
 
-    scoped_ptr<DecryptConfig> decrypt_config;
+    std::unique_ptr<DecryptConfig> decrypt_config;
     int data_offset = 0;
     if ((type() == DemuxerStream::AUDIO && audio_config_->is_encrypted()) ||
         (type() == DemuxerStream::VIDEO && video_config_->is_encrypted())) {
       if (!WebMCreateDecryptConfig(
               packet->data, packet->size,
               reinterpret_cast<const uint8_t*>(encryption_key_id_.data()),
               encryption_key_id_.size(), &decrypt_config, &data_offset)) {
         LOG(ERROR) << "Creation of DecryptConfig failed.";
       }
     }
@@ skipping 702 matching lines @@
       if (packet_buffer->pkt.pts != static_cast<int64_t>(AV_NOPTS_VALUE)) {
         const base::TimeDelta packet_pts =
             ConvertFromTimeBase(stream->time_base, packet_buffer->pkt.pts);
         if (packet_pts < start_time_estimates[stream->index])
           start_time_estimates[stream->index] = packet_pts;
       }
       packet_buffer = packet_buffer->next;
     }
   }
 
-  scoped_ptr<MediaTracks> media_tracks(new MediaTracks());
+  std::unique_ptr<MediaTracks> media_tracks(new MediaTracks());
   AVStream* audio_stream = NULL;
   AudioDecoderConfig audio_config;
   AVStream* video_stream = NULL;
   VideoDecoderConfig video_config;
 
   // If available, |start_time_| will be set to the lowest stream start time.
   start_time_ = kInfiniteDuration();
 
   base::TimeDelta max_duration;
   int detected_audio_track_count = 0;
@@ skipping 55 matching lines @@
       if (codec_context->codec_id != AV_CODEC_ID_WEBVTT || !text_enabled_) {
         continue;
       }
     } else {
       continue;
     }
 
     // Attempt to create a FFmpegDemuxerStream from the AVStream. This will
     // return nullptr if the AVStream is invalid. Validity checks will verify
     // things like: codec, channel layout, sample/pixel format, etc...
-    scoped_ptr<FFmpegDemuxerStream> demuxer_stream =
+    std::unique_ptr<FFmpegDemuxerStream> demuxer_stream =
         FFmpegDemuxerStream::Create(this, stream, media_log_);
     if (demuxer_stream.get()) {
       streams_[i] = demuxer_stream.release();
     } else {
       if (codec_type == AVMEDIA_TYPE_AUDIO) {
         MEDIA_LOG(INFO, media_log_)
             << GetDisplayName()
             << ": skipping invalid or unsupported audio track";
       } else if (codec_type == AVMEDIA_TYPE_VIDEO) {
         MEDIA_LOG(INFO, media_log_)
@@ skipping 161 matching lines @@
   duration_known_ = (max_duration != kInfiniteDuration());
 
   int64_t filesize_in_bytes = 0;
   url_protocol_->GetSize(&filesize_in_bytes);
   bitrate_ = CalculateBitrate(format_context, max_duration, filesize_in_bytes);
   if (bitrate_ > 0)
     data_source_->SetBitrate(bitrate_);
 
   // Use a single MediaLogEvent to batch all parameter updates at once; this
   // prevents throttling of events due to the large number of updates here.
-  scoped_ptr<MediaLogEvent> metadata_event =
+  std::unique_ptr<MediaLogEvent> metadata_event =
       media_log_->CreateEvent(MediaLogEvent::PROPERTY_CHANGE);
 
   // Audio logging.
   metadata_event->params.SetBoolean("found_audio_stream", !!audio_stream);
   if (audio_stream) {
     const AVCodecContext* audio_codec = audio_stream->codec;
     metadata_event->params.SetString("audio_codec_name",
                                      GetCodecName(audio_codec));
     metadata_event->params.SetInteger("audio_channels_count",
                                       audio_codec->channels);
@@ skipping 206 matching lines @@
 
 void FFmpegDemuxer::SetLiveness(DemuxerStream::Liveness liveness) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   for (const auto& stream : streams_) {  // |stream| is a ref to a pointer.
     if (stream)
       stream->SetLiveness(liveness);
   }
 }
 
 }  // namespace media