Convert media/formats to std::unique_ptr

media/formats/webm/webm_stream_parser_unittest.cc

 // Copyright 2016 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/webm/webm_stream_parser.h"
+
+#include <memory>
+
 #include "base/bind.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/media_tracks.h"
 #include "media/base/mock_media_log.h"
 #include "media/base/stream_parser.h"
 #include "media/base/test_data_util.h"
 #include "media/base/text_track_config.h"
-#include "media/formats/webm/webm_stream_parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::SaveArg;
 using testing::_;
 
 namespace media {
 
 class WebMStreamParserTest : public testing::Test {
  public:
   WebMStreamParserTest()
@@ skipping 38 matching lines @@
               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);
     InitCB(params);
   }
 
   MOCK_METHOD1(InitCB, void(const StreamParser::InitParameters& params));
 
-  bool NewConfigCB(scoped_ptr<MediaTracks> tracks,
+  bool NewConfigCB(std::unique_ptr<MediaTracks> tracks,
                    const StreamParser::TextTrackConfigMap& text_track_map) {
     DCHECK(tracks.get());
     media_tracks_ = std::move(tracks);
     return true;
   }
 
   MOCK_METHOD3(NewBuffersCB,
                bool(const StreamParser::BufferQueue&,
                     const StreamParser::BufferQueue&,
                     const StreamParser::TextBufferQueueMap&));
   MOCK_METHOD2(OnEncryptedMediaInitData,
                void(EmeInitDataType init_data_type,
                     const std::vector<uint8_t>& init_data));
   MOCK_METHOD0(NewMediaSegmentCB, void());
   MOCK_METHOD0(EndMediaSegmentCB, void());
 
   scoped_refptr<testing::StrictMock<MockMediaLog>> media_log_;
-  scoped_ptr<WebMStreamParser> parser_;
-  scoped_ptr<MediaTracks> media_tracks_;
+  std::unique_ptr<WebMStreamParser> parser_;
+  std::unique_ptr<MediaTracks> media_tracks_;
 };
 
 TEST_F(WebMStreamParserTest, VerifyMediaTrackMetadata) {
   EXPECT_MEDIA_LOG(testing::HasSubstr("Estimating WebM block duration"))
       .Times(testing::AnyNumber());
   StreamParser::InitParameters params(kInfiniteDuration());
   params.detected_audio_track_count = 1;
   params.detected_video_track_count = 1;
   params.detected_text_track_count = 0;
   ParseWebMFile("bear.webm", params);
@@ skipping 45 matching lines @@
   params.detected_audio_track_count = 1;
   params.detected_video_track_count = 1;
   params.detected_text_track_count = 1;
   ParseWebMFile("bear-vp8-webvtt.webm", params);
   EXPECT_EQ(media_tracks_->tracks().size(), 2u);
   EXPECT_EQ(media_tracks_->tracks()[0]->type(), MediaTrack::Video);
   EXPECT_EQ(media_tracks_->tracks()[1]->type(), MediaTrack::Audio);
 }
 
 }  // namespace media