Convert media/formats to std::unique_ptr

media/formats/mp4/mp4_stream_parser_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/mp4_stream_parser.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
+#include <memory>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_track.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mock_media_log.h"
 #include "media/base/stream_parser.h"
 #include "media/base/stream_parser_buffer.h"
 #include "media/base/test_data_util.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/formats/mp4/es_descriptor.h"
 #include "media/formats/mp4/fourccs.h"
-#include "media/formats/mp4/mp4_stream_parser.h"
 #include "media/media_features.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::InSequence;
 using ::testing::StrictMock;
 using base::TimeDelta;
 
 namespace media {
 namespace mp4 {
@@ skipping 22 matching lines @@
         configs_received_(false),
         lower_bound_(
             DecodeTimestamp::FromPresentationTime(base::TimeDelta::Max())) {
     std::set<int> audio_object_types;
     audio_object_types.insert(kISO_14496_3);
     parser_.reset(new MP4StreamParser(audio_object_types, false));
   }
 
  protected:
   scoped_refptr<StrictMock<MockMediaLog>> media_log_;
-  scoped_ptr<MP4StreamParser> parser_;
+  std::unique_ptr<MP4StreamParser> parser_;
   bool configs_received_;
-  scoped_ptr<MediaTracks> media_tracks_;
+  std::unique_ptr<MediaTracks> media_tracks_;
   AudioDecoderConfig audio_decoder_config_;
   VideoDecoderConfig video_decoder_config_;
   DecodeTimestamp lower_bound_;
 
   bool AppendData(const uint8_t* data, size_t length) {
     return parser_->Parse(data, length);
   }
 
   bool AppendDataInPieces(const uint8_t* data,
                           size_t length,
@@ skipping 20 matching lines @@
               params.auto_update_timestamp_offset);
     EXPECT_EQ(expected_params.liveness, params.liveness);
     EXPECT_EQ(expected_params.detected_audio_track_count,
               params.detected_audio_track_count);
     EXPECT_EQ(expected_params.detected_video_track_count,
               params.detected_video_track_count);
     EXPECT_EQ(expected_params.detected_text_track_count,
               params.detected_text_track_count);
   }
 
-  bool NewConfigF(scoped_ptr<MediaTracks> tracks,
+  bool NewConfigF(std::unique_ptr<MediaTracks> tracks,
                   const StreamParser::TextTrackConfigMap& tc) {
     configs_received_ = true;
     CHECK(tracks.get());
     media_tracks_ = std::move(tracks);
     audio_decoder_config_ = media_tracks_->getFirstAudioConfig();
     video_decoder_config_ = media_tracks_->getFirstVideoConfig();
     DVLOG(1) << "NewConfigF: track count=" << media_tracks_->tracks().size()
              << " audio=" << audio_decoder_config_.IsValidConfig()
              << " video=" << video_decoder_config_.IsValidConfig();
     return true;
@@ skipping 393 matching lines @@
   scoped_refptr<DecoderBuffer> buffer =
       ReadTestDataFile("bear-1280x720-avt_subt_frag.mp4");
 
   EXPECT_MEDIA_LOG(AudioCodecLog("mp4a.40.2"));
   EXPECT_MEDIA_LOG(VideoCodecLog("avc1.64001F"));
   EXPECT_TRUE(AppendDataInPieces(buffer->data(), buffer->data_size(), 512));
 }
 
 }  // namespace mp4
 }  // namespace media