Convert //media/filters from scoped_ptr to std::unique_ptr

media/filters/chunk_demuxer_unittest.cc

 // Copyright (c) 2012 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/filters/chunk_demuxer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>

[ddorwin, 2016/04/21 22:54:54]

Why isn't <memory> included in this file like the other unit tests?

 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decoder_buffer.h"
@@ skipping 223 matching lines @@
 
 class ChunkDemuxerTest : public ::testing::Test {
  protected:
   enum CodecsIndex {
     AUDIO,
     VIDEO,
     MAX_CODECS_INDEX
   };
 
   // Default cluster to append first for simple tests.
-  scoped_ptr<Cluster> kDefaultFirstCluster() {
+  std::unique_ptr<Cluster> kDefaultFirstCluster() {
     return GenerateCluster(0, 4);
   }
 
   // Default cluster to append after kDefaultFirstCluster()
   // has been appended. This cluster starts with blocks that
   // have timestamps consistent with the end times of the blocks
   // in kDefaultFirstCluster() so that these two clusters represent
   // a continuous region.
-  scoped_ptr<Cluster> kDefaultSecondCluster() {
+  std::unique_ptr<Cluster> kDefaultSecondCluster() {
     return GenerateCluster(46, 66, 5);
   }
 
   ChunkDemuxerTest()
       : media_log_(new StrictMock<MockMediaLog>()),
         append_window_end_for_next_append_(kInfiniteDuration()) {
     init_segment_received_cb_ = base::Bind(
         &ChunkDemuxerTest::InitSegmentReceived, base::Unretained(this));
     CreateNewDemuxer();
   }
 
   void CreateNewDemuxer() {
     base::Closure open_cb =
         base::Bind(&ChunkDemuxerTest::DemuxerOpened, base::Unretained(this));
     Demuxer::EncryptedMediaInitDataCB encrypted_media_init_data_cb = base::Bind(
         &ChunkDemuxerTest::OnEncryptedMediaInitData, base::Unretained(this));
     demuxer_.reset(new ChunkDemuxer(open_cb, encrypted_media_init_data_cb,
                                     media_log_, true));
   }
 
   virtual ~ChunkDemuxerTest() {
     ShutdownDemuxer();
   }
 
   void CreateInitSegment(int stream_flags,
-                                 bool is_audio_encrypted,
-                                 bool is_video_encrypted,
-                                 scoped_ptr<uint8_t[]>* buffer,
-                                 int* size) {
+                         bool is_audio_encrypted,
+                         bool is_video_encrypted,
+                         std::unique_ptr<uint8_t[]>* buffer,
+                         int* size) {
     bool has_audio = (stream_flags & HAS_AUDIO) != 0;
     bool has_video = (stream_flags & HAS_VIDEO) != 0;
     bool has_text = (stream_flags & HAS_TEXT) != 0;
     scoped_refptr<DecoderBuffer> ebml_header;
     scoped_refptr<DecoderBuffer> info;
     scoped_refptr<DecoderBuffer> audio_track_entry;
     scoped_refptr<DecoderBuffer> video_track_entry;
     scoped_refptr<DecoderBuffer> audio_content_encodings;
     scoped_refptr<DecoderBuffer> video_content_encodings;
     scoped_refptr<DecoderBuffer> text_track_entry;
@@ skipping 168 matching lines @@
                                 base::Unretained(this)));
     return status;
   }
 #endif
 
   void AppendData(const uint8_t* data, size_t length) {
     AppendData(kSourceId, data, length);
   }
 
   void AppendCluster(const std::string& source_id,
-                     scoped_ptr<Cluster> cluster) {
+                     std::unique_ptr<Cluster> cluster) {
     AppendData(source_id, cluster->data(), cluster->size());
   }
 
-  void AppendCluster(scoped_ptr<Cluster> cluster) {
+  void AppendCluster(std::unique_ptr<Cluster> cluster) {
     AppendCluster(kSourceId, std::move(cluster));
   }
 
   void AppendCluster(int timecode, int block_count) {
     AppendCluster(GenerateCluster(timecode, block_count));
   }
 
   void AppendSingleStreamCluster(const std::string& source_id, int track_number,
                                  int timecode, int block_count) {
     int block_duration = 0;
@@ skipping 96 matching lines @@
       }
 
       if (track_number == kAudioTrackNum ||
           track_number == kAlternateAudioTrackNum)
         ASSERT_TRUE(block_info.flags & kWebMFlagKeyframe);
 
       blocks->push_back(block_info);
     }
   }
 
-  scoped_ptr<Cluster> GenerateCluster(const std::vector<BlockInfo>& blocks,
-                                      bool unknown_size) {
+  std::unique_ptr<Cluster> GenerateCluster(const std::vector<BlockInfo>& blocks,
+                                           bool unknown_size) {
     DCHECK_GT(blocks.size(), 0u);
     ClusterBuilder cb;
 
     std::vector<uint8_t> data(10);
     for (size_t i = 0; i < blocks.size(); ++i) {
       if (i == 0)
         cb.SetClusterTimecode(blocks[i].timestamp_in_ms);
 
       if (blocks[i].duration) {
         if (blocks[i].track_number == kVideoTrackNum ||
             blocks[i].track_number == kAlternateVideoTrackNum) {
           AddVideoBlockGroup(&cb,
                              blocks[i].track_number, blocks[i].timestamp_in_ms,
                              blocks[i].duration, blocks[i].flags);
         } else {
           cb.AddBlockGroup(blocks[i].track_number, blocks[i].timestamp_in_ms,
                            blocks[i].duration, blocks[i].flags,
                            &data[0], data.size());
         }
       } else {
         cb.AddSimpleBlock(blocks[i].track_number, blocks[i].timestamp_in_ms,
                           blocks[i].flags,
                           &data[0], data.size());
       }
     }
 
     return unknown_size ? cb.FinishWithUnknownSize() : cb.Finish();
   }
 
-  scoped_ptr<Cluster> GenerateCluster(
+  std::unique_ptr<Cluster> GenerateCluster(
       std::priority_queue<BlockInfo> block_queue,
       bool unknown_size) {
     std::vector<BlockInfo> blocks(block_queue.size());
     for (size_t i = block_queue.size() - 1; !block_queue.empty(); --i) {
       blocks[i] = block_queue.top();
       block_queue.pop();
     }
 
     return GenerateCluster(blocks, unknown_size);
   }
@@ skipping 48 matching lines @@
   void AppendMuxedCluster(const MuxedStreamInfo& msi_1,
                           const MuxedStreamInfo& msi_2,
                           const MuxedStreamInfo& msi_3) {
     std::vector<MuxedStreamInfo> msi(3);
     msi[0] = msi_1;
     msi[1] = msi_2;
     msi[2] = msi_3;
     AppendMuxedCluster(msi);
   }
 
-  scoped_ptr<Cluster> GenerateMuxedCluster(
+  std::unique_ptr<Cluster> GenerateMuxedCluster(
       const std::vector<MuxedStreamInfo> msi) {
     std::priority_queue<BlockInfo> block_queue;
     for (size_t i = 0; i < msi.size(); ++i) {
       std::vector<BlockInfo> track_blocks;
       ParseBlockDescriptions(msi[i].track_number, msi[i].block_descriptions,
                              &track_blocks);
 
       for (size_t j = 0; j < track_blocks.size(); ++j) {
         block_queue.push(track_blocks[j]);
       }
@@ skipping 43 matching lines @@
 
   void AppendInitSegmentWithSourceId(const std::string& source_id,
                                      int stream_flags) {
     AppendInitSegmentWithEncryptedInfo(source_id, stream_flags, false, false);
   }
 
   void AppendInitSegmentWithEncryptedInfo(const std::string& source_id,
                                           int stream_flags,
                                           bool is_audio_encrypted,
                                           bool is_video_encrypted) {
-    scoped_ptr<uint8_t[]> info_tracks;
+    std::unique_ptr<uint8_t[]> info_tracks;
     int info_tracks_size = 0;
     CreateInitSegment(stream_flags,
                       is_audio_encrypted, is_video_encrypted,
                       &info_tracks, &info_tracks_size);
     AppendData(source_id, info_tracks.get(), info_tracks_size);
   }
 
   void AppendGarbage() {
     // Fill up an array with gibberish.
     int garbage_cluster_size = 10;
-    scoped_ptr<uint8_t[]> garbage_cluster(new uint8_t[garbage_cluster_size]);
+    std::unique_ptr<uint8_t[]> garbage_cluster(
+        new uint8_t[garbage_cluster_size]);
     for (int i = 0; i < garbage_cluster_size; ++i)
       garbage_cluster[i] = i;
     AppendData(garbage_cluster.get(), garbage_cluster_size);
   }
 
   void InitDoneCalled(PipelineStatus expected_status,
                       PipelineStatus status) {
     EXPECT_EQ(status, expected_status);
   }
 
@@ skipping 202 matching lines @@
       demuxer_->Shutdown();
       message_loop_.RunUntilIdle();
     }
   }
 
   void AddSimpleBlock(ClusterBuilder* cb, int track_num, int64_t timecode) {
     uint8_t data[] = {0x00};
     cb->AddSimpleBlock(track_num, timecode, 0, data, sizeof(data));
   }
 
-  scoped_ptr<Cluster> GenerateCluster(int timecode, int block_count) {
+  std::unique_ptr<Cluster> GenerateCluster(int timecode, int block_count) {
     return GenerateCluster(timecode, timecode, block_count);
   }
 
   void AddVideoBlockGroup(ClusterBuilder* cb,
                           int track_num,
                           int64_t timecode,
                           int duration,
                           int flags) {
     const uint8_t* data =
         (flags & kWebMFlagKeyframe) != 0 ? kVP8Keyframe : kVP8Interframe;
     int size = (flags & kWebMFlagKeyframe) != 0 ? sizeof(kVP8Keyframe) :
         sizeof(kVP8Interframe);
     cb->AddBlockGroup(track_num, timecode, duration, flags, data, size);
   }
 
-  scoped_ptr<Cluster> GenerateCluster(int first_audio_timecode,
-                                      int first_video_timecode,
-                                      int block_count) {
+  std::unique_ptr<Cluster> GenerateCluster(int first_audio_timecode,
+                                           int first_video_timecode,
+                                           int block_count) {
     return GenerateCluster(first_audio_timecode, first_video_timecode,
                            block_count, false);
   }
-  scoped_ptr<Cluster> GenerateCluster(int first_audio_timecode,
-                                      int first_video_timecode,
-                                      int block_count,
-                                      bool unknown_size) {
+  std::unique_ptr<Cluster> GenerateCluster(int first_audio_timecode,
+                                           int first_video_timecode,
+                                           int block_count,
+                                           bool unknown_size) {
     CHECK_GT(block_count, 0);
 
     std::priority_queue<BlockInfo> block_queue;
 
     if (block_count == 1) {
       block_queue.push(BlockInfo(kAudioTrackNum,
                                  first_audio_timecode,
                                  kWebMFlagKeyframe,
                                  kAudioBlockDuration));
       return GenerateCluster(block_queue, unknown_size);
@@ skipping 30 matching lines @@
                                kWebMFlagKeyframe,
                                kAudioBlockDuration));
     block_queue.push(BlockInfo(kVideoTrackNum,
                                video_timecode,
                                video_flag,
                                kVideoBlockDuration));
 
     return GenerateCluster(block_queue, unknown_size);
   }
 
-  scoped_ptr<Cluster> GenerateSingleStreamCluster(int timecode,
-                                                  int end_timecode,
-                                                  int track_number,
-                                                  int block_duration) {
+  std::unique_ptr<Cluster> GenerateSingleStreamCluster(int timecode,
+                                                       int end_timecode,
+                                                       int track_number,
+                                                       int block_duration) {
     CHECK_GT(end_timecode, timecode);
 
     std::vector<uint8_t> data(kBlockSize);
 
     ClusterBuilder cb;
     cb.SetClusterTimecode(timecode);
 
     // Create simple blocks for everything except the last block.
     while (timecode < (end_timecode - block_duration)) {
       cb.AddSimpleBlock(track_number, timecode, kWebMFlagKeyframe,
@@ skipping 70 matching lines @@
   void GenerateAudioStreamExpectedReads(int timecode, int block_count) {
     GenerateSingleStreamExpectedReads(
         timecode, block_count, DemuxerStream::AUDIO, kAudioBlockDuration);
   }
 
   void GenerateVideoStreamExpectedReads(int timecode, int block_count) {
     GenerateSingleStreamExpectedReads(
         timecode, block_count, DemuxerStream::VIDEO, kVideoBlockDuration);
   }
 
-  scoped_ptr<Cluster> GenerateEmptyCluster(int timecode) {
+  std::unique_ptr<Cluster> GenerateEmptyCluster(int timecode) {
     ClusterBuilder cb;
     cb.SetClusterTimecode(timecode);
     return cb.Finish();
   }
 
   void CheckExpectedRangesForMediaSource(const std::string& expected) {
     CheckExpectedRanges(demuxer_->GetBufferedRanges(), expected);
   }
 
   void CheckExpectedRanges(const std::string& expected) {
@@ skipping 171 matching lines @@
     }
 
     return true;
   }
 
   MOCK_METHOD0(DemuxerOpened, void());
   MOCK_METHOD2(OnEncryptedMediaInitData,
                void(EmeInitDataType init_data_type,
                     const std::vector<uint8_t>& init_data));
 
-  MOCK_METHOD1(InitSegmentReceivedMock, void(scoped_ptr<MediaTracks>&));
+  MOCK_METHOD1(InitSegmentReceivedMock, void(std::unique_ptr<MediaTracks>&));
 
   void Seek(base::TimeDelta seek_time) {
     demuxer_->StartWaitingForSeek(seek_time);
     demuxer_->Seek(seek_time, NewExpectedStatusCB(PIPELINE_OK));
     message_loop_.RunUntilIdle();
   }
 
   void MarkEndOfStream(PipelineStatus status) {
     demuxer_->MarkEndOfStream(status);
     message_loop_.RunUntilIdle();
   }
 
   bool SetTimestampOffset(const std::string& id,
                           base::TimeDelta timestamp_offset) {
     if (demuxer_->IsParsingMediaSegment(id))
       return false;
 
     timestamp_offset_map_[id] = timestamp_offset;
     return true;
   }
 
   base::MessageLoop message_loop_;
   MockDemuxerHost host_;
 
   scoped_refptr<StrictMock<MockMediaLog>> media_log_;
 
-  scoped_ptr<ChunkDemuxer> demuxer_;
+  std::unique_ptr<ChunkDemuxer> demuxer_;
   Demuxer::MediaTracksUpdatedCB init_segment_received_cb_;
 
   base::TimeDelta append_window_start_for_next_append_;
   base::TimeDelta append_window_end_for_next_append_;
 
   // Map of source id to timestamp offset to use for the next AppendData()
   // operation for that source id.
   std::map<std::string, base::TimeDelta> timestamp_offset_map_;
 
  public:
-  void InitSegmentReceived(scoped_ptr<MediaTracks> tracks) {
+  void InitSegmentReceived(std::unique_ptr<MediaTracks> tracks) {
     DCHECK(tracks.get());
     DCHECK_GT(tracks->tracks().size(), 0u);
 
     InitSegmentReceivedMock(tracks);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChunkDemuxerTest);
 };
 
@@ skipping 146 matching lines @@
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
   ASSERT_TRUE(audio_stream);
   ASSERT_TRUE(video_stream);
   ASSERT_TRUE(text_stream);
 
   AppendMuxedCluster(MuxedStreamInfo(kAudioTrackNum, "0K 23K", 23),
                      MuxedStreamInfo(kVideoTrackNum, "0K 30", 30),
                      MuxedStreamInfo(kTextTrackNum, "10K"));
   CheckExpectedRanges("{ [0,46) }");
 
-  scoped_ptr<uint8_t[]> info_tracks;
+  std::unique_ptr<uint8_t[]> info_tracks;
   int info_tracks_size = 0;
   CreateInitSegment(
       HAS_TEXT | HAS_AUDIO | HAS_VIDEO | USE_ALTERNATE_TEXT_TRACK_ID, false,
       false, &info_tracks, &info_tracks_size);
   EXPECT_CALL(*this, InitSegmentReceivedMock(_));
   demuxer_->AppendData(kSourceId, info_tracks.get(), info_tracks_size,
                        append_window_start_for_next_append_,
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId]);
 
@@ skipping 176 matching lines @@
 }
 
 // Test the case where a Seek() is requested while the parser
 // is in the middle of cluster. This is to verify that the parser
 // does not reset itself on a seek.
 TEST_F(ChunkDemuxerTest, SeekWhileParsingCluster) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   InSequence s;
 
-  scoped_ptr<Cluster> cluster_a(GenerateCluster(0, 6));
+  std::unique_ptr<Cluster> cluster_a(GenerateCluster(0, 6));
 
   // Split the cluster into two appends at an arbitrary point near the end.
   int first_append_size = cluster_a->size() - 11;
   int second_append_size = cluster_a->size() - first_append_size;
 
   // Append the first part of the cluster.
   AppendData(cluster_a->data(), first_append_size);
 
   ExpectRead(DemuxerStream::AUDIO, 0);
   ExpectRead(DemuxerStream::VIDEO, 0);
   ExpectRead(DemuxerStream::AUDIO, kAudioBlockDuration);
 
   Seek(base::TimeDelta::FromSeconds(5));
 
   // Append the rest of the cluster.
   AppendData(cluster_a->data() + first_append_size, second_append_size);
 
   // Append the new cluster and verify that only the blocks
   // in the new cluster are returned.
   AppendCluster(GenerateCluster(5000, 6));
   GenerateExpectedReads(5000, 6);
 }
 
 // Test the case where AppendData() is called before Init().
 TEST_F(ChunkDemuxerTest, AppendDataBeforeInit) {
-  scoped_ptr<uint8_t[]> info_tracks;
+  std::unique_ptr<uint8_t[]> info_tracks;
   int info_tracks_size = 0;
   CreateInitSegment(HAS_AUDIO | HAS_VIDEO,
                     false, false, &info_tracks, &info_tracks_size);
   demuxer_->AppendData(kSourceId, info_tracks.get(), info_tracks_size,
                        append_window_start_for_next_append_,
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId]);
 }
 
 // Make sure Read() callbacks are dispatched with the proper data.
@@ skipping 20 matching lines @@
   AppendCluster(kDefaultFirstCluster());
   EXPECT_MEDIA_LOG(GeneratedSplice(13000, 10000));
   AppendCluster(GenerateCluster(10, 4));
 
   // Make sure that AppendCluster() does not fail with a cluster that has
   // overlaps with the previously appended cluster.
   EXPECT_MEDIA_LOG(SkippingSpliceAlreadySpliced(0));
   AppendCluster(GenerateCluster(5, 4));
 
   // Verify that AppendData() can still accept more data.
-  scoped_ptr<Cluster> cluster_c(GenerateCluster(45, 2));
+  std::unique_ptr<Cluster> cluster_c(GenerateCluster(45, 2));
   EXPECT_MEDIA_LOG(GeneratedSplice(6000, 45000));
   demuxer_->AppendData(kSourceId, cluster_c->data(), cluster_c->size(),
                        append_window_start_for_next_append_,
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId]);
 }
 
 TEST_F(ChunkDemuxerTest, NonMonotonicButAboveClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   AppendCluster(kDefaultFirstCluster());
 
   ClusterBuilder cb;
 
   // Test the case where block timecodes are not monotonically
   // increasing but stay above the cluster timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 10);
   AddSimpleBlock(&cb, kAudioTrackNum, 7);
   AddSimpleBlock(&cb, kVideoTrackNum, 15);
 
   EXPECT_MEDIA_LOG(WebMOutOfOrderTimecode());
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   EXPECT_CALL(host_, OnDemuxerError(CHUNK_DEMUXER_ERROR_APPEND_FAILED));
   AppendCluster(cb.Finish());
 
   // Verify that AppendData() ignores data after the error.
-  scoped_ptr<Cluster> cluster_b(GenerateCluster(20, 2));
+  std::unique_ptr<Cluster> cluster_b(GenerateCluster(20, 2));
   demuxer_->AppendData(kSourceId, cluster_b->data(), cluster_b->size(),
                        append_window_start_for_next_append_,
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId]);
 }
 
 TEST_F(ChunkDemuxerTest, BackwardsAndBeforeClusterTimecode) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   AppendCluster(kDefaultFirstCluster());
 
   ClusterBuilder cb;
 
   // Test timecodes going backwards and including values less than the cluster
   // timecode.
   cb.SetClusterTimecode(5);
   AddSimpleBlock(&cb, kAudioTrackNum, 5);
   AddSimpleBlock(&cb, kVideoTrackNum, 5);
   AddSimpleBlock(&cb, kAudioTrackNum, 3);
   AddSimpleBlock(&cb, kVideoTrackNum, 3);
 
   EXPECT_MEDIA_LOG(WebMNegativeTimecodeOffset("-2"));
   EXPECT_MEDIA_LOG(StreamParsingFailed());
   EXPECT_CALL(host_, OnDemuxerError(CHUNK_DEMUXER_ERROR_APPEND_FAILED));
   AppendCluster(cb.Finish());
 
   // Verify that AppendData() ignores data after the error.
-  scoped_ptr<Cluster> cluster_b(GenerateCluster(6, 2));
+  std::unique_ptr<Cluster> cluster_b(GenerateCluster(6, 2));
   demuxer_->AppendData(kSourceId, cluster_b->data(), cluster_b->size(),
                        append_window_start_for_next_append_,
                        append_window_end_for_next_append_,
                        &timestamp_offset_map_[kSourceId]);
 }
 
 
 TEST_F(ChunkDemuxerTest, PerStreamMonotonicallyIncreasingTimestamps) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   AppendCluster(kDefaultFirstCluster());
@@ skipping 279 matching lines @@
 }
 
 // Make sure AppendData() will accept elements that span multiple calls.
 TEST_F(ChunkDemuxerTest, AppendingInPieces) {
   EXPECT_CALL(*this, DemuxerOpened());
   demuxer_->Initialize(
       &host_, CreateInitDoneCB(kDefaultDuration(), PIPELINE_OK), true);
 
   ASSERT_EQ(AddId(), ChunkDemuxer::kOk);
 
-  scoped_ptr<uint8_t[]> info_tracks;
+  std::unique_ptr<uint8_t[]> info_tracks;
   int info_tracks_size = 0;
   CreateInitSegment(HAS_AUDIO | HAS_VIDEO,
                     false, false, &info_tracks, &info_tracks_size);
 
-  scoped_ptr<Cluster> cluster_a(kDefaultFirstCluster());
-  scoped_ptr<Cluster> cluster_b(kDefaultSecondCluster());
+  std::unique_ptr<Cluster> cluster_a(kDefaultFirstCluster());
+  std::unique_ptr<Cluster> cluster_b(kDefaultSecondCluster());
 
   size_t buffer_size = info_tracks_size + cluster_a->size() + cluster_b->size();
-  scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
+  std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);
   uint8_t* dst = buffer.get();
   memcpy(dst, info_tracks.get(), info_tracks_size);
   dst += info_tracks_size;
 
   memcpy(dst, cluster_a->data(), cluster_a->size());
   dst += cluster_a->size();
 
   memcpy(dst, cluster_b->data(), cluster_b->size());
   dst += cluster_b->size();
 
@@ skipping 106 matching lines @@
   ExpectInitMediaLogs(HAS_AUDIO | HAS_VIDEO);
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(2));
   ASSERT_TRUE(ParseWebMFile("bear-320x240-altref.webm", buffer_timestamps,
                             base::TimeDelta::FromMilliseconds(2767)));
 }
 
 // Verify that we output buffers before the entire cluster has been parsed.
 TEST_F(ChunkDemuxerTest, IncrementalClusterParsing) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  scoped_ptr<Cluster> cluster(GenerateCluster(0, 6));
+  std::unique_ptr<Cluster> cluster(GenerateCluster(0, 6));
 
   bool audio_read_done = false;
   bool video_read_done = false;
   ReadAudio(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &audio_read_done));
   ReadVideo(base::Bind(&OnReadDone,
                        base::TimeDelta::FromMilliseconds(0),
                        &video_read_done));
 
@@ skipping 1091 matching lines @@
       0, kAudioBlockDuration * 4, kAudioTrackNum, kAudioBlockDuration));
   AppendCluster(video_id, GenerateSingleStreamCluster(
       0, kVideoBlockDuration * 4, kVideoTrackNum, kVideoBlockDuration));
   GenerateVideoStreamExpectedReads(27300, 4);
   GenerateAudioStreamExpectedReads(27300, 4);
 }
 
 TEST_F(ChunkDemuxerTest, IsParsingMediaSegmentMidMediaSegment) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
-  scoped_ptr<Cluster> cluster = GenerateCluster(0, 2);
+  std::unique_ptr<Cluster> cluster = GenerateCluster(0, 2);
   // Append only part of the cluster data.
   AppendData(cluster->data(), cluster->size() - 13);
 
   // Confirm we're in the middle of parsing a media segment.
   ASSERT_TRUE(demuxer_->IsParsingMediaSegment(kSourceId));
 
   demuxer_->ResetParserState(kSourceId,
                              append_window_start_for_next_append_,
                              append_window_end_for_next_append_,
                              &timestamp_offset_map_[kSourceId]);
@@ skipping 923 matching lines @@
 
   // A new cluster indicates end of the previous cluster with unknown size.
   AppendCluster(GenerateCluster(46, 66, 5, true));
   CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, CuesBetweenClustersWithUnknownSize) {
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
 
   // Add two clusters separated by Cues in a single Append() call.
-  scoped_ptr<Cluster> cluster = GenerateCluster(0, 0, 4, true);
+  std::unique_ptr<Cluster> cluster = GenerateCluster(0, 0, 4, true);
   std::vector<uint8_t> data(cluster->data(), cluster->data() + cluster->size());
   data.insert(data.end(), kCuesHeader, kCuesHeader + sizeof(kCuesHeader));
   cluster = GenerateCluster(46, 66, 5, true);
   data.insert(data.end(), cluster->data(), cluster->data() + cluster->size());
   AppendData(&*data.begin(), data.size());
 
   CheckExpectedRanges("{ [0,115) }");
 }
 
 TEST_F(ChunkDemuxerTest, CuesBetweenClusters) {
@@ skipping 244 matching lines @@
   //        A:      [K K K K K K]
   //        V [..............K n]
   ASSERT_TRUE(InitDemuxer(HAS_AUDIO | HAS_VIDEO));
   DemuxerStream* audio_stream = demuxer_->GetStream(DemuxerStream::AUDIO);
   DemuxerStream* video_stream = demuxer_->GetStream(DemuxerStream::VIDEO);
 
   std::vector<MuxedStreamInfo> msi(2);
   msi[0] =
       MuxedStreamInfo(kAudioTrackNum, "0K 10K 20K 30K 40K 50K 60K 70K 80D10K");
   msi[1] = MuxedStreamInfo(kVideoTrackNum, "31 41 51 61 71K 81", 10);
-  scoped_ptr<Cluster> cluster = GenerateMuxedCluster(msi);
+  std::unique_ptr<Cluster> cluster = GenerateMuxedCluster(msi);
 
   // Append the first part of the cluster, up to the beginning of the first
   // video simpleblock. The result should be just 4 audio blocks and no video
   // blocks are appended. Since the stream parser does not yet have a duration
   // for the 4th audio block in this partial cluster append, it is not yet
   // emitted from the parser, and only the first 3 audio blocks are expected to
   // be buffered by and available from the demuxer.
   ASSERT_EQ(kVideoTrackNum, 1);
   int video_start = 0;
   bool found = false;
@@ skipping 22 matching lines @@
              cluster->size() - video_start);
 
   CheckExpectedRanges(DemuxerStream::AUDIO, "{ [30,90) }");
   CheckExpectedRanges(DemuxerStream::VIDEO, "{ [0,91) }");
   CheckExpectedRanges("{ [30,90) }");
   CheckExpectedBuffers(audio_stream, "30K 40K 50K 60K 70K 80K");
   CheckExpectedBuffers(video_stream, "71K 81");
 }
 
 }  // namespace media