Convert media/formats to std::unique_ptr

media/formats/mp4/track_run_iterator.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/formats/mp4/track_run_iterator.h"
 
 #include <algorithm>
 #include <iomanip>
 #include <limits>
+#include <memory>
 
 #include "base/macros.h"
 #include "media/formats/mp4/rcheck.h"
 #include "media/formats/mp4/sample_to_group_iterator.h"
 
 namespace media {
 namespace mp4 {
 
 struct SampleInfo {
   int size;
@@ skipping 253 matching lines @@
       DVLOG(1) << "Skipping unhandled track type";
       continue;
     }
     size_t desc_idx = traf.header.sample_description_index;
     if (!desc_idx) desc_idx = trex->default_sample_description_index;
     RCHECK(desc_idx > 0);  // Descriptions are one-indexed in the file
     desc_idx -= 1;
 
     const std::vector<uint8_t>& sample_encryption_data =
         traf.sample_encryption.sample_encryption_data;
-    scoped_ptr<BufferReader> sample_encryption_reader;
+    std::unique_ptr<BufferReader> sample_encryption_reader;
     uint32_t sample_encrytion_entries_count = 0;
     if (!sample_encryption_data.empty()) {
       sample_encryption_reader.reset(new BufferReader(
           sample_encryption_data.data(), sample_encryption_data.size()));
       RCHECK(sample_encryption_reader->Read4(&sample_encrytion_entries_count));
     }
 
     // Process edit list to remove CTS offset introduced in the presence of
     // B-frames (those that contain a single edit with a nonnegative media
     // time). Other uses of edit lists are not supported, as they are
@@ skipping 288 matching lines @@
   DCHECK(IsSampleValid());
   return sample_itr_->is_keyframe;
 }
 
 const TrackEncryption& TrackRunIterator::track_encryption() const {
   if (is_audio())
     return audio_description().sinf.info.track_encryption;
   return video_description().sinf.info.track_encryption;
 }
 
-scoped_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
+std::unique_ptr<DecryptConfig> TrackRunIterator::GetDecryptConfig() {
   DCHECK(is_encrypted());
 
   if (run_itr_->sample_encryption_entries.empty()) {
     DCHECK_EQ(0, aux_info_size());
     MEDIA_LOG(ERROR, media_log_) << "Sample encryption info is not available.";
-    return scoped_ptr<DecryptConfig>();
+    return std::unique_ptr<DecryptConfig>();
   }
 
   size_t sample_idx = sample_itr_ - run_itr_->samples.begin();
   DCHECK_LT(sample_idx, run_itr_->sample_encryption_entries.size());
   const SampleEncryptionEntry& sample_encryption_entry =
       run_itr_->sample_encryption_entries[sample_idx];
 
   size_t total_size = 0;
   if (!sample_encryption_entry.subsamples.empty() &&
       (!sample_encryption_entry.GetTotalSizeOfSubsamples(&total_size) ||
        total_size != static_cast<size_t>(sample_size()))) {
     MEDIA_LOG(ERROR, media_log_) << "Incorrect CENC subsample size.";
-    return scoped_ptr<DecryptConfig>();
+    return std::unique_ptr<DecryptConfig>();
   }
 
   const std::vector<uint8_t>& kid = GetKeyId(sample_idx);
-  return scoped_ptr<DecryptConfig>(new DecryptConfig(
+  return std::unique_ptr<DecryptConfig>(new DecryptConfig(
       std::string(reinterpret_cast<const char*>(&kid[0]), kid.size()),
       std::string(reinterpret_cast<const char*>(
                       sample_encryption_entry.initialization_vector),
                   arraysize(sample_encryption_entry.initialization_vector)),
       sample_encryption_entry.subsamples));
 }
 
 uint32_t TrackRunIterator::GetGroupDescriptionIndex(
     uint32_t sample_index) const {
   DCHECK(IsRunValid());
@@ skipping 16 matching lines @@
 }
 
 uint8_t TrackRunIterator::GetIvSize(size_t sample_index) const {
   uint32_t index = GetGroupDescriptionIndex(sample_index);
   return (index == 0) ? track_encryption().default_iv_size
                       : GetSampleEncryptionInfoEntry(*run_itr_, index)->iv_size;
 }
 
 }  // namespace mp4
 }  // namespace media