Convert media/formats to std::unique_ptr

media/formats/webm/webm_cluster_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/webm/webm_cluster_parser.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <cstdlib>
+#include <memory>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/mock_media_log.h"
 #include "media/base/timestamp_constants.h"
 #include "media/formats/webm/cluster_builder.h"
 #include "media/formats/webm/opus_packet_builder.h"
-#include "media/formats/webm/webm_cluster_parser.h"
 #include "media/formats/webm/webm_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::HasSubstr;
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::StrictMock;
 using ::testing::Mock;
 using ::testing::_;
@@ skipping 80 matching lines @@
     {kVideoTrackNum, 100, 33, false, NULL, 0},
 };
 
 const uint8_t kEncryptedFrame[] = {
     // Block is encrypted
     0x01,
 
     // IV
     0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
 
-scoped_ptr<Cluster> CreateCluster(int timecode,
-                                  const BlockInfo* block_info,
-                                  int block_count) {
+std::unique_ptr<Cluster> CreateCluster(int timecode,
+                                       const BlockInfo* block_info,
+                                       int block_count) {
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
 
   uint8_t kDefaultBlockData[] = { 0x00 };
 
   for (int i = 0; i < block_count; i++) {
     const uint8_t* data;
     int data_length;
     if (block_info[i].data != NULL) {
       data = block_info[i].data;
@@ skipping 19 matching lines @@
 
     cb.AddBlockGroup(block_info[i].track_num, block_info[i].timestamp,
                      block_info[i].duration, 0, data, data_length);
   }
 
   return cb.Finish();
 }
 
 // Creates a Cluster with one encrypted Block. |bytes_to_write| is number of
 // bytes of the encrypted frame to write.
-scoped_ptr<Cluster> CreateEncryptedCluster(int bytes_to_write) {
+std::unique_ptr<Cluster> CreateEncryptedCluster(int bytes_to_write) {
   CHECK_GT(bytes_to_write, 0);
   CHECK_LE(bytes_to_write, static_cast<int>(sizeof(kEncryptedFrame)));
 
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
   cb.AddSimpleBlock(kVideoTrackNum, 0, 0, kEncryptedFrame, bytes_to_write);
   return cb.Finish();
 }
 
 bool VerifyBuffers(const WebMClusterParser::BufferQueue& audio_buffers,
@@ skipping 46 matching lines @@
     EXPECT_EQ(block_info[i].timestamp, buffer->timestamp().InMilliseconds());
     EXPECT_EQ(std::abs(block_info[i].duration),
               buffer->duration().InMillisecondsF());
     EXPECT_EQ(expected_type, buffer->type());
     EXPECT_EQ(block_info[i].track_num, buffer->track_id());
   }
 
   return true;
 }
 
-bool VerifyBuffers(const scoped_ptr<WebMClusterParser>& parser,
+bool VerifyBuffers(const std::unique_ptr<WebMClusterParser>& parser,
                    const BlockInfo* block_info,
                    int block_count) {
   const WebMClusterParser::TextBufferQueueMap& text_map =
       parser->GetTextBuffers();
   const WebMClusterParser::BufferQueue* text_buffers;
   const WebMClusterParser::BufferQueue no_text_buffers;
   if (!text_map.empty())
     text_buffers = &(text_map.rbegin()->second);
   else
     text_buffers = &no_text_buffers;
 
   return VerifyBuffers(parser->GetAudioBuffers(),
                        parser->GetVideoBuffers(),
                        *text_buffers,
                        block_info,
                        block_count);
 }
 
-bool VerifyTextBuffers(const scoped_ptr<WebMClusterParser>& parser,
+bool VerifyTextBuffers(const std::unique_ptr<WebMClusterParser>& parser,
                        const BlockInfo* block_info_ptr,
                        int block_count,
                        int text_track_num,
                        const WebMClusterParser::BufferQueue& text_buffers) {
   const BlockInfo* const block_info_end = block_info_ptr + block_count;
 
   typedef WebMClusterParser::BufferQueue::const_iterator TextBufferIter;
   TextBufferIter buffer_iter = text_buffers.begin();
   const TextBufferIter buffer_end = text_buffers.end();
 
@@ skipping 101 matching lines @@
   WebMClusterParser* CreateParserWithKeyIdsAndAudioCodec(
       const std::string& audio_encryption_key_id,
       const std::string& video_encryption_key_id,
       const AudioCodec audio_codec) {
     return CreateParserHelper(kNoTimestamp(), kNoTimestamp(), TextTracks(),
                               std::set<int64_t>(), audio_encryption_key_id,
                               video_encryption_key_id, audio_codec);
   }
 
   scoped_refptr<StrictMock<MockMediaLog>> media_log_;
-  scoped_ptr<WebMClusterParser> parser_;
+  std::unique_ptr<WebMClusterParser> parser_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebMClusterParserTest);
 };
 
 TEST_F(WebMClusterParserTest, HeldBackBufferHoldsBackAllTracks) {
   // If a buffer is missing duration and is being held back, then all other
   // tracks' buffers that have same or higher (decode) timestamp should be held
   // back too to keep the timestamps emitted for a cluster monotonically
   // non-decreasing and in same order as parsed.
@@ skipping 47 matching lines @@
   // |kExpectedBuffersOnPartialCluster| identifies the exact subset of
   // |kBlockInfo| returned by the parser.
   for (int i = 0; i < block_count; ++i) {
     if (i > 0)
       parser_->Reset();
     // Since we don't know exactly the offsets of each block in the full
     // cluster, build a cluster with exactly one additional block so that
     // parse of all but one byte should deterministically parse all but the
     // last full block. Don't |exceed block_count| blocks though.
     int blocks_in_cluster = std::min(i + 2, block_count);
-    scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo,
-                                              blocks_in_cluster));
+    std::unique_ptr<Cluster> cluster(
+        CreateCluster(0, kBlockInfo, blocks_in_cluster));
     // Parse all but the last byte unless we need to parse the full cluster.
     bool parse_full_cluster = i == (block_count - 1);
 
     if (parse_full_cluster) {
       EXPECT_MEDIA_LOG(
           WebMSimpleBlockDurationEstimated(kExpectedVideoEstimationInMs));
     }
 
     int result = parser_->Parse(cluster->data(), parse_full_cluster ?
                                 cluster->size() : cluster->size() - 1);
@@ skipping 10 matching lines @@
 
     EXPECT_TRUE(VerifyBuffers(parser_, kBlockInfo,
                               kExpectedBuffersOnPartialCluster[i]));
   }
 }
 
 TEST_F(WebMClusterParserTest, Reset) {
   InSequence s;
 
   int block_count = arraysize(kDefaultBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kDefaultBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(
+      CreateCluster(0, kDefaultBlockInfo, block_count));
 
   // Send slightly less than the full cluster so all but the last block is
   // parsed.
   int result = parser_->Parse(cluster->data(), cluster->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster->size());
 
   ASSERT_TRUE(VerifyBuffers(parser_, kDefaultBlockInfo, block_count - 1));
   parser_->Reset();
 
   // Now parse a whole cluster to verify that all the blocks will get parsed.
   result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kDefaultBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseClusterWithSingleCall) {
   int block_count = arraysize(kDefaultBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kDefaultBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(
+      CreateCluster(0, kDefaultBlockInfo, block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kDefaultBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseClusterWithMultipleCalls) {
   int block_count = arraysize(kDefaultBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kDefaultBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(
+      CreateCluster(0, kDefaultBlockInfo, block_count));
 
   WebMClusterParser::BufferQueue audio_buffers;
   WebMClusterParser::BufferQueue video_buffers;
   const WebMClusterParser::BufferQueue no_text_buffers;
 
   const uint8_t* data = cluster->data();
   int size = cluster->size();
   int default_parse_size = 3;
   int parse_size = std::min(default_parse_size, size);
 
@@ skipping 55 matching lines @@
 
 TEST_F(WebMClusterParserTest, ParseSimpleBlockAndBlockGroupMixture) {
   const BlockInfo kBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 23, false, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kAudioTrackNum, 46, 23, false, NULL, 0},
       {kVideoTrackNum, 67, 33, false, NULL, 0},
   };
   int block_count = arraysize(kBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, IgnoredTracks) {
   std::set<int64_t> ignored_tracks;
   ignored_tracks.insert(kTextTrackNum);
 
@@ skipping 11 matching lines @@
 
   const BlockInfo kOutputBlockInfo[] = {
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 23, true, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kAudioTrackNum, 46, 23, true, NULL, 0},
       {kVideoTrackNum, 67, 34, true, NULL, 0},
   };
   int output_block_count = arraysize(kOutputBlockInfo);
 
-  scoped_ptr<Cluster> cluster(
+  std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(34));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kOutputBlockInfo, output_block_count));
 }
 
 TEST_F(WebMClusterParserTest, ParseTextTracks) {
@@ skipping 10 matching lines @@
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 23, true, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kTextTrackNum, 33, 42, false, NULL, 0},
       {kAudioTrackNum, 46, 23, true, NULL, 0},
       {kTextTrackNum, 55, 44, false, NULL, 0},
       {kVideoTrackNum, 67, 34, true, NULL, 0},
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
-  scoped_ptr<Cluster> cluster(
+  std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(34));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kInputBlockInfo, input_block_count));
 }
 
 TEST_F(WebMClusterParserTest, TextTracksSimpleBlock) {
   TextTracks text_tracks;
 
   text_tracks.insert(std::make_pair(TextTracks::key_type(kTextTrackNum),
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
   parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
       kNoTimestamp(), kNoTimestamp(), text_tracks));
 
   const BlockInfo kInputBlockInfo[] = {
     { kTextTrackNum,  33, 42, true },
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
-  scoped_ptr<Cluster> cluster(
+  std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_LT(result, 0);
 }
 
 TEST_F(WebMClusterParserTest, ParseMultipleTextTracks) {
   TextTracks text_tracks;
 
   const int kSubtitleTextTrackNum = kTextTrackNum;
@@ skipping 15 matching lines @@
       {kAudioTrackNum, 23, 23, true, NULL, 0},
       {kVideoTrackNum, 33, 34, true, NULL, 0},
       {kSubtitleTextTrackNum, 33, 42, false, NULL, 0},
       {kAudioTrackNum, 46, 23, true, NULL, 0},
       {kCaptionTextTrackNum, 55, 44, false, NULL, 0},
       {kVideoTrackNum, 67, 34, true, NULL, 0},
       {kSubtitleTextTrackNum, 67, 33, false, NULL, 0},
   };
   int input_block_count = arraysize(kInputBlockInfo);
 
-  scoped_ptr<Cluster> cluster(
+  std::unique_ptr<Cluster> cluster(
       CreateCluster(0, kInputBlockInfo, input_block_count));
 
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(23));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(34));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
 
   const WebMClusterParser::TextBufferQueueMap& text_map =
       parser_->GetTextBuffers();
   for (WebMClusterParser::TextBufferQueueMap::const_iterator itr =
            text_map.begin();
        itr != text_map.end();
        ++itr) {
     const TextTracks::const_iterator find_result =
         text_tracks.find(itr->first);
     ASSERT_TRUE(find_result != text_tracks.end());
     ASSERT_TRUE(VerifyTextBuffers(parser_, kInputBlockInfo, input_block_count,
                                   itr->first, itr->second));
   }
 }
 
 TEST_F(WebMClusterParserTest, ParseEncryptedBlock) {
-  scoped_ptr<Cluster> cluster(CreateEncryptedCluster(sizeof(kEncryptedFrame)));
+  std::unique_ptr<Cluster> cluster(
+      CreateEncryptedCluster(sizeof(kEncryptedFrame)));
 
   parser_.reset(CreateParserWithKeyIdsAndAudioCodec(
       std::string(), "video_key_id", kUnknownAudioCodec));
 
   // The encrypted cluster contains just one block, video.
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(
       WebMClusterParser::kDefaultVideoBufferDurationInMs));
 
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_EQ(1UL, parser_->GetVideoBuffers().size());
   scoped_refptr<StreamParserBuffer> buffer = parser_->GetVideoBuffers()[0];
   VerifyEncryptedBuffer(buffer);
 }
 
 TEST_F(WebMClusterParserTest, ParseBadEncryptedBlock) {
-  scoped_ptr<Cluster> cluster(
+  std::unique_ptr<Cluster> cluster(
       CreateEncryptedCluster(sizeof(kEncryptedFrame) - 1));
 
   parser_.reset(CreateParserWithKeyIdsAndAudioCodec(
       std::string(), "video_key_id", kUnknownAudioCodec));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(-1, result);
 }
 
 TEST_F(WebMClusterParserTest, ParseInvalidZeroSizedCluster) {
   const uint8_t kBuffer[] = {
@@ skipping 20 matching lines @@
                                     TextTrackConfig(kTextSubtitles, "", "",
                                                     "")));
 
   parser_.reset(CreateParserWithDefaultDurationsAndOptionalTextTracks(
       kNoTimestamp(), kNoTimestamp(), text_tracks));
 
   const BlockInfo kBlockInfo[] = {
     { kTextTrackNum,  33, -42, false },
   };
   int block_count = arraysize(kBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_LT(result, 0);
 }
 
 TEST_F(WebMClusterParserTest, ParseWithDefaultDurationsSimpleBlocks) {
   InSequence s;
   ResetParserToHaveDefaultDurations();
 
   EXPECT_LT(kTestAudioFrameDefaultDurationInMs, 23);
   EXPECT_LT(kTestVideoFrameDefaultDurationInMs, 33);
 
   const BlockInfo kBlockInfo[] = {
       {kAudioTrackNum, 0, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
       {kAudioTrackNum, 23, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
       {kVideoTrackNum, 33, kTestVideoFrameDefaultDurationInMs, true, NULL, 0},
       {kAudioTrackNum, 46, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
       {kVideoTrackNum, 67, kTestVideoFrameDefaultDurationInMs, true, NULL, 0},
       {kAudioTrackNum, 69, kTestAudioFrameDefaultDurationInMs, true, NULL, 0},
       {kVideoTrackNum, 100, kTestVideoFrameDefaultDurationInMs, true, NULL, 0},
   };
 
   int block_count = arraysize(kBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   // Send slightly less than the full cluster so all but the last block is
   // parsed. Though all the blocks are simple blocks, none should be held aside
   // for duration estimation prior to end of cluster detection because all the
   // tracks have DefaultDurations.
   int result = parser_->Parse(cluster->data(), cluster->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster->size());
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count - 1));
 
@@ skipping 21 matching lines @@
       {kAudioTrackNum, 0, 23, true, NULL, 0},
       {kAudioTrackNum, 23, 22, true, NULL, 0},
       {kVideoTrackNum, 33, 33, true, NULL, 0},
       {kAudioTrackNum, 45, 23, true, NULL, 0},
       {kVideoTrackNum, 66, 34, true, NULL, 0},
       {kAudioTrackNum, 68, kExpectedAudioEstimationInMs, true, NULL, 0},
       {kVideoTrackNum, 100, kExpectedVideoEstimationInMs, true, NULL, 0},
   };
 
   int block_count1 = arraysize(kBlockInfo1);
-  scoped_ptr<Cluster> cluster1(CreateCluster(0, kBlockInfo1, block_count1));
+  std::unique_ptr<Cluster> cluster1(
+      CreateCluster(0, kBlockInfo1, block_count1));
 
   // Send slightly less than the first full cluster so all but the last video
   // block is parsed. Verify the last fully parsed audio and video buffer are
   // both missing from the result (parser should hold them aside for duration
   // estimation prior to end of cluster detection in the absence of
   // DefaultDurations.)
   int result = parser_->Parse(cluster1->data(), cluster1->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster1->size());
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo1, block_count1 - 3));
@@ skipping 14 matching lines @@
   // Verify that the estimated frame duration is tracked across clusters for
   // each track.
   const BlockInfo kBlockInfo2[] = {
       // Estimate carries over across clusters
       {kAudioTrackNum, 200, kExpectedAudioEstimationInMs, true, NULL, 0},
       // Estimate carries over across clusters
       {kVideoTrackNum, 201, kExpectedVideoEstimationInMs, true, NULL, 0},
   };
 
   int block_count2 = arraysize(kBlockInfo2);
-  scoped_ptr<Cluster> cluster2(CreateCluster(0, kBlockInfo2, block_count2));
+  std::unique_ptr<Cluster> cluster2(
+      CreateCluster(0, kBlockInfo2, block_count2));
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedAudioEstimationInMs));
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedVideoEstimationInMs));
   result = parser_->Parse(cluster2->data(), cluster2->size());
   EXPECT_EQ(cluster2->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo2, block_count2));
 }
 
 TEST_F(WebMClusterParserTest, ParseWithoutAnyDurationsBlockGroups) {
@@ skipping 12 matching lines @@
       {kAudioTrackNum, 0, -23, false, NULL, 0},
       {kAudioTrackNum, 23, -22, false, NULL, 0},
       {kVideoTrackNum, 33, -33, false, NULL, 0},
       {kAudioTrackNum, 45, -23, false, NULL, 0},
       {kVideoTrackNum, 66, -34, false, NULL, 0},
       {kAudioTrackNum, 68, -kExpectedAudioEstimationInMs, false, NULL, 0},
       {kVideoTrackNum, 100, -kExpectedVideoEstimationInMs, false, NULL, 0},
   };
 
   int block_count1 = arraysize(kBlockInfo1);
-  scoped_ptr<Cluster> cluster1(CreateCluster(0, kBlockInfo1, block_count1));
+  std::unique_ptr<Cluster> cluster1(
+      CreateCluster(0, kBlockInfo1, block_count1));
 
   // Send slightly less than the first full cluster so all but the last video
   // block is parsed. Verify the last fully parsed audio and video buffer are
   // both missing from the result (parser should hold them aside for duration
   // estimation prior to end of cluster detection in the absence of
   // DefaultDurations.)
   int result = parser_->Parse(cluster1->data(), cluster1->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster1->size());
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo1, block_count1 - 3));
@@ skipping 12 matching lines @@
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo1, block_count1));
 
   // Verify that the estimated frame duration is tracked across clusters for
   // each track.
   const BlockInfo kBlockInfo2[] = {
       {kAudioTrackNum, 200, -kExpectedAudioEstimationInMs, false, NULL, 0},
       {kVideoTrackNum, 201, -kExpectedVideoEstimationInMs, false, NULL, 0},
   };
 
   int block_count2 = arraysize(kBlockInfo2);
-  scoped_ptr<Cluster> cluster2(CreateCluster(0, kBlockInfo2, block_count2));
+  std::unique_ptr<Cluster> cluster2(
+      CreateCluster(0, kBlockInfo2, block_count2));
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedAudioEstimationInMs));
   EXPECT_MEDIA_LOG(
       WebMSimpleBlockDurationEstimated(kExpectedVideoEstimationInMs));
   result = parser_->Parse(cluster2->data(), cluster2->size());
   EXPECT_EQ(cluster2->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo2, block_count2));
 }
 
 // TODO(wolenetz): Is parser behavior correct? See http://crbug.com/363433.
@@ skipping 14 matching lines @@
       {kAudioTrackNum, 69, -kTestAudioFrameDefaultDurationInMs, false, NULL, 0},
       {kVideoTrackNum,
        100,
        -kTestVideoFrameDefaultDurationInMs,
        false,
        NULL,
        0},
   };
 
   int block_count = arraysize(kBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
 
   // Send slightly less than the full cluster so all but the last block is
   // parsed. None should be held aside for duration estimation prior to end of
   // cluster detection because all the tracks have DefaultDurations.
   int result = parser_->Parse(cluster->data(), cluster->size() - 1);
   EXPECT_GT(result, 0);
   EXPECT_LT(result, cluster->size());
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count - 1));
 
   parser_->Reset();
@@ skipping 14 matching lines @@
       true
     }, {
       kVideoTrackNum,
       0,
       WebMClusterParser::kDefaultVideoBufferDurationInMs,
       true
     },
   };
 
   int block_count = arraysize(kBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(
       WebMClusterParser::kDefaultAudioBufferDurationInMs));
   EXPECT_MEDIA_LOG(WebMSimpleBlockDurationEstimated(
       WebMClusterParser::kDefaultVideoBufferDurationInMs));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest,
        ParseDegenerateClusterWithDefaultDurationsYieldsDefaultDurations) {
   ResetParserToHaveDefaultDurations();
 
   const BlockInfo kBlockInfo[] = {
     { kAudioTrackNum, 0, kTestAudioFrameDefaultDurationInMs, true },
     { kVideoTrackNum, 0, kTestVideoFrameDefaultDurationInMs, true },
   };
 
   int block_count = arraysize(kBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 TEST_F(WebMClusterParserTest, ReadOpusDurationsSimpleBlockAtEndOfCluster) {
   int loop_count = 0;
   for (const auto* packet_ptr : BuildAllOpusPackets()) {
     InSequence s;
 
     // Get a new parser each iteration to prevent exceeding the media log cap.
     parser_.reset(CreateParserWithKeyIdsAndAudioCodec(
         std::string(), std::string(), kCodecOpus));
 
     const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
                                      0,
                                      packet_ptr->duration_ms(),
                                      true,  // Make it a SimpleBlock.
                                      packet_ptr->data(),
                                      packet_ptr->size()}};
 
     int block_count = arraysize(kBlockInfo);
-    scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+    std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
     int duration_ms = packet_ptr->duration_ms();  // Casts from double.
     if (duration_ms > 120) {
       EXPECT_MEDIA_LOG(OpusPacketDurationTooHigh(duration_ms));
     }
 
     int result = parser_->Parse(cluster->data(), cluster->size());
     EXPECT_EQ(cluster->size(), result);
     ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 
     // Fail early if any iteration fails to meet the logging expectations.
@@ skipping 25 matching lines @@
         block_duration_ms, packet_ptr->duration_ms()));
 
     BlockInfo block_infos[] = {{kAudioTrackNum,
                                 0,
                                 block_duration_ms,
                                 false,  // Not a SimpleBlock.
                                 packet_ptr->data(),
                                 packet_ptr->size()}};
 
     int block_count = arraysize(block_infos);
-    scoped_ptr<Cluster> cluster(CreateCluster(0, block_infos, block_count));
+    std::unique_ptr<Cluster> cluster(
+        CreateCluster(0, block_infos, block_count));
     int result = parser_->Parse(cluster->data(), cluster->size());
     EXPECT_EQ(cluster->size(), result);
 
     // BlockInfo duration will be used to verify buffer duration, so changing
     // duration to be that of the Opus packet to verify it was preferred.
     block_infos[0].duration = packet_ptr->duration_ms();
 
     ASSERT_TRUE(VerifyBuffers(parser_, block_infos, block_count));
 
     // Fail early if any iteration fails to meet the logging expectations.
@@ skipping 19 matching lines @@
 
   // Single Block with BlockDuration and encrypted data.
   const BlockInfo kBlockInfo[] = {{kAudioTrackNum,
                                    0,
                                    kTestAudioFrameDefaultDurationInMs,
                                    false,            // Not a SimpleBlock
                                    kEncryptedFrame,  // Encrypted frame data
                                    arraysize(kEncryptedFrame)}};
 
   int block_count = arraysize(kBlockInfo);
-  scoped_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
+  std::unique_ptr<Cluster> cluster(CreateCluster(0, kBlockInfo, block_count));
   int result = parser_->Parse(cluster->data(), cluster->size());
   EXPECT_EQ(cluster->size(), result);
 
   // Will verify that duration of buffer matches that of BlockDuration.
   ASSERT_TRUE(VerifyBuffers(parser_, kBlockInfo, block_count));
 }
 
 }  // namespace media