Convert media/formats to std::unique_ptr

media/formats/mp4/track_run_iterator_unittest.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 <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "media/base/mock_media_log.h"
 #include "media/formats/mp4/box_definitions.h"
 #include "media/formats/mp4/rcheck.h"
-#include "media/formats/mp4/track_run_iterator.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::StrictMock;
 
 namespace {
 
 // The sum of the elements in a vector initialized with SumAscending,
 // less the value of the last element.
 const int kSumAscending1 = 45;
@@ skipping 80 matching lines @@
 
 class TrackRunIteratorTest : public testing::Test {
  public:
   TrackRunIteratorTest() : media_log_(new StrictMock<MockMediaLog>()) {
     CreateMovie();
   }
 
  protected:
   Movie moov_;
   scoped_refptr<StrictMock<MockMediaLog>> media_log_;
-  scoped_ptr<TrackRunIterator> iter_;
+  std::unique_ptr<TrackRunIterator> iter_;
 
   void CreateMovie() {
     moov_.header.timescale = 1000;
     moov_.tracks.resize(3);
     moov_.extends.tracks.resize(2);
     moov_.tracks[0].header.track_id = 1;
     moov_.tracks[0].media.header.timescale = kAudioScale;
     SampleDescription& desc1 =
         moov_.tracks[0].media.information.sample_table.description;
     AudioSampleEntry aud_desc;
@@ skipping 442 matching lines @@
   // data_offset.
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 2u);
 
   EXPECT_TRUE(iter_->is_encrypted());
   // No need to cache aux info as it is already available in SampleEncryption.
   EXPECT_FALSE(iter_->AuxInfoNeedsToBeCached());
   EXPECT_EQ(iter_->aux_info_size(), 0);
   EXPECT_EQ(iter_->sample_offset(), 200);
   EXPECT_EQ(iter_->GetMaxClearOffset(), moof.tracks[1].runs[0].data_offset);
-  scoped_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
+  std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
   EXPECT_EQ(
       std::string(reinterpret_cast<const char*>(kKeyId), arraysize(kKeyId)),
       config->key_id());
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), arraysize(kIv1)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 0u);
   iter_->AdvanceSample();
   config = iter_->GetDecryptConfig();
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv2), arraysize(kIv2)),
             config->iv());
@@ skipping 23 matching lines @@
   // data_offset.
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->track_id(), 2u);
 
   EXPECT_TRUE(iter_->is_encrypted());
   // No need to cache aux info as it is already available in SampleEncryption.
   EXPECT_FALSE(iter_->AuxInfoNeedsToBeCached());
   EXPECT_EQ(iter_->aux_info_size(), 0);
   EXPECT_EQ(iter_->sample_offset(), 200);
   EXPECT_EQ(iter_->GetMaxClearOffset(), moof.tracks[1].runs[0].data_offset);
-  scoped_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
+  std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), arraysize(kIv1)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 1u);
   EXPECT_EQ(config->subsamples()[0].clear_bytes, 1u);
   EXPECT_EQ(config->subsamples()[0].cypher_bytes, 2u);
   iter_->AdvanceSample();
   config = iter_->GetDecryptConfig();
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv3), arraysize(kIv3)),
             config->iv());
   EXPECT_EQ(config->subsamples().size(), 2u);
@@ skipping 20 matching lines @@
   EXPECT_EQ(static_cast<uint32_t>(iter_->aux_info_size()), arraysize(kAuxInfo));
   EXPECT_EQ(iter_->aux_info_offset(), 50);
   EXPECT_EQ(iter_->GetMaxClearOffset(), 50);
   EXPECT_FALSE(iter_->CacheAuxInfo(NULL, 0));
   EXPECT_FALSE(iter_->CacheAuxInfo(kAuxInfo, 3));
   EXPECT_TRUE(iter_->AuxInfoNeedsToBeCached());
   EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
   EXPECT_FALSE(iter_->AuxInfoNeedsToBeCached());
   EXPECT_EQ(iter_->sample_offset(), 200);
   EXPECT_EQ(iter_->GetMaxClearOffset(), moof.tracks[0].runs[0].data_offset);
-  scoped_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
+  std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
   EXPECT_EQ(
       std::string(reinterpret_cast<const char*>(kKeyId), arraysize(kKeyId)),
       config->key_id());
   EXPECT_EQ(std::string(reinterpret_cast<const char*>(kIv1), arraysize(kIv1)),
             config->iv());
   EXPECT_TRUE(config->subsamples().empty());
   iter_->AdvanceSample();
   config = iter_->GetDecryptConfig();
   EXPECT_EQ(config->subsamples().size(), 2u);
   EXPECT_EQ(config->subsamples()[0].clear_bytes, 1u);
@@ skipping 93 matching lines @@
   MovieFragment moof = CreateFragment();
   moof.tracks[0].runs.resize(1);
   AddAuxInfoHeaders(50, &moof.tracks[0]);
   AddAuxInfoHeaders(50, &moof.tracks[1]);
   moof.tracks[0].auxiliary_size.default_sample_info_size = 8;
 
   ASSERT_TRUE(iter_->Init(moof));
   EXPECT_EQ(iter_->track_id(), 1u);
   EXPECT_EQ(iter_->aux_info_offset(), 50);
   EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
-  scoped_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
+  std::unique_ptr<DecryptConfig> config = iter_->GetDecryptConfig();
   ASSERT_EQ(arraysize(kIv1), config->iv().size());
   EXPECT_TRUE(!memcmp(kIv1, config->iv().data(), config->iv().size()));
   iter_->AdvanceSample();
   EXPECT_EQ(iter_->GetMaxClearOffset(), 50);
   iter_->AdvanceRun();
   EXPECT_EQ(iter_->GetMaxClearOffset(), 50);
   EXPECT_EQ(iter_->aux_info_offset(), 50);
   EXPECT_TRUE(iter_->CacheAuxInfo(kAuxInfo, arraysize(kAuxInfo)));
   EXPECT_EQ(iter_->GetMaxClearOffset(), 200);
   ASSERT_EQ(arraysize(kIv1), config->iv().size());
@@ skipping 83 matching lines @@
   // no dependents, but we occasionally encounter media where all samples are
   // marked "sync" and we must rely on combining the two flags to pick out the
   // true key frames. See http://crbug.com/310712 and http://crbug.com/507916.
   // Realiably knowing the keyframes for video is also critical to SPS PPS
   // insertion.
   EXPECT_EQ("2 K P P P K P", KeyframeAndRAPInfo(iter_.get()));
 }
 
 }  // namespace mp4
 }  // namespace media