Convert media/formats to std::unique_ptr

media/formats/mp2t/mp2t_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/mp2t/mp2t_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/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/mp2t/mp2t_stream_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace mp2t {
 
 namespace {
 
 bool IsMonotonic(const StreamParser::BufferQueue& buffers) {
   if (buffers.empty())
     return true;
@@ skipping 25 matching lines @@
         has_video_(true),
         audio_min_dts_(kNoDecodeTimestamp()),
         audio_max_dts_(kNoDecodeTimestamp()),
         video_min_dts_(kNoDecodeTimestamp()),
         video_max_dts_(kNoDecodeTimestamp()) {
     bool has_sbr = false;
     parser_.reset(new Mp2tStreamParser(has_sbr));
   }
 
  protected:
-  scoped_ptr<Mp2tStreamParser> parser_;
+  std::unique_ptr<Mp2tStreamParser> parser_;
   int segment_count_;
   int config_count_;
   int audio_frame_count_;
   int video_frame_count_;
   bool has_video_;
   DecodeTimestamp audio_min_dts_;
   DecodeTimestamp audio_max_dts_;
   DecodeTimestamp video_min_dts_;
   DecodeTimestamp video_max_dts_;
 
@@ skipping 25 matching lines @@
       start += append_size;
     }
     return true;
   }
 
   void OnInit(const StreamParser::InitParameters& params) {
     DVLOG(1) << "OnInit: dur=" << params.duration.InMilliseconds()
              << ", autoTimestampOffset=" << params.auto_update_timestamp_offset;
   }
 
-  bool OnNewConfig(scoped_ptr<MediaTracks> tracks,
+  bool OnNewConfig(std::unique_ptr<MediaTracks> tracks,
                    const StreamParser::TextTrackConfigMap& tc) {
     const AudioDecoderConfig& ac = tracks->getFirstAudioConfig();
     const VideoDecoderConfig& vc = tracks->getFirstVideoConfig();
     DVLOG(1) << "OnNewConfig: media tracks count=" << tracks->tracks().size()
              << ", audio=" << ac.IsValidConfig()
              << ", video=" << vc.IsValidConfig();
     config_count_++;
     EXPECT_TRUE(ac.IsValidConfig());
     EXPECT_EQ(vc.IsValidConfig(), has_video_);
     return true;
@@ skipping 167 matching lines @@
   parser_->Flush();
   EXPECT_EQ(audio_frame_count_, 40);
   EXPECT_EQ(video_frame_count_, 0);
   // This stream has no mid-stream configuration change.
   EXPECT_EQ(config_count_, 1);
   EXPECT_EQ(segment_count_, 1);
 }
 
 }  // namespace mp2t
 }  // namespace media