| Index: media/filters/chunk_demuxer_unittest.cc | 
| diff --git a/media/filters/chunk_demuxer_unittest.cc b/media/filters/chunk_demuxer_unittest.cc | 
| index a6828da96bde0350c6494e4caaac0b66fa84fcf3..11bb7a2b4f712c28e38c4a847e1c3235ef76a97e 100644 | 
| --- a/media/filters/chunk_demuxer_unittest.cc | 
| +++ b/media/filters/chunk_demuxer_unittest.cc | 
| @@ -250,7 +250,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| }; | 
|  | 
| // Default cluster to append first for simple tests. | 
| -  scoped_ptr<Cluster> kDefaultFirstCluster() { | 
| +  std::unique_ptr<Cluster> kDefaultFirstCluster() { | 
| return GenerateCluster(0, 4); | 
| } | 
|  | 
| @@ -259,7 +259,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| // 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); | 
| } | 
|  | 
| @@ -285,10 +285,10 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| } | 
|  | 
| 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; | 
| @@ -477,11 +477,11 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| } | 
|  | 
| 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)); | 
| } | 
|  | 
| @@ -598,8 +598,8 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| } | 
| } | 
|  | 
| -  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; | 
|  | 
| @@ -629,7 +629,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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()); | 
| @@ -698,7 +698,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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) { | 
| @@ -762,7 +762,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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, | 
| @@ -773,7 +773,8 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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); | 
| @@ -996,7 +997,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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); | 
| } | 
|  | 
| @@ -1012,16 +1013,16 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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; | 
| @@ -1072,10 +1073,10 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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); | 
| @@ -1166,7 +1167,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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(); | 
| @@ -1358,7 +1359,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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); | 
| @@ -1385,7 +1386,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
|  | 
| 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_; | 
| @@ -1396,7 +1397,7 @@ class ChunkDemuxerTest : public ::testing::Test { | 
| 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); | 
|  | 
| @@ -1563,7 +1564,7 @@ TEST_F(ChunkDemuxerTest, SingleTextTrackIdChange) { | 
| 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, | 
| @@ -1760,7 +1761,7 @@ TEST_F(ChunkDemuxerTest, SeekWhileParsingCluster) { | 
|  | 
| 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; | 
| @@ -1786,7 +1787,7 @@ TEST_F(ChunkDemuxerTest, SeekWhileParsingCluster) { | 
|  | 
| // 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); | 
| @@ -1827,7 +1828,7 @@ TEST_F(ChunkDemuxerTest, OutOfOrderClusters) { | 
| 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_, | 
| @@ -1855,7 +1856,7 @@ TEST_F(ChunkDemuxerTest, NonMonotonicButAboveClusterTimecode) { | 
| 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_, | 
| @@ -1882,7 +1883,7 @@ TEST_F(ChunkDemuxerTest, BackwardsAndBeforeClusterTimecode) { | 
| 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_, | 
| @@ -2182,16 +2183,16 @@ TEST_F(ChunkDemuxerTest, AppendingInPieces) { | 
|  | 
| 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; | 
| @@ -2318,7 +2319,7 @@ TEST_F(ChunkDemuxerTest, WebMFile_AltRefFrames) { | 
| 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; | 
| @@ -3430,7 +3431,7 @@ TEST_F(ChunkDemuxerTest, TimestampOffsetSeparateStreams) { | 
| 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); | 
|  | 
| @@ -4374,7 +4375,7 @@ 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); | 
| @@ -4639,7 +4640,7 @@ TEST_F(ChunkDemuxerTest, | 
| 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 | 
|  |