Convert media/formats to std::unique_ptr

media/formats/webm/webm_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_parser.h"
+
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
+
 #include "base/macros.h"
 #include "media/formats/webm/cluster_builder.h"
 #include "media/formats/webm/webm_constants.h"
-#include "media/formats/webm/webm_parser.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::InSequence;
 using ::testing::Return;
 using ::testing::ReturnNull;
 using ::testing::StrictMock;
 using ::testing::_;
 
 namespace media {
@@ skipping 11 matching lines @@
   MOCK_METHOD2(OnFloat, bool(int, double));
   MOCK_METHOD3(OnBinary, bool(int, const uint8_t*, int));
   MOCK_METHOD2(OnString, bool(int, const std::string&));
 };
 
 class WebMParserTest : public testing::Test {
  protected:
   StrictMock<MockWebMParserClient> client_;
 };
 
-static scoped_ptr<Cluster> CreateCluster(int block_count) {
+static std::unique_ptr<Cluster> CreateCluster(int block_count) {
   ClusterBuilder cb;
   cb.SetClusterTimecode(0);
 
   for (int i = 0; i < block_count; i++) {
     uint8_t data[] = {0x00};
     cb.AddSimpleBlock(0, i, 0, data, sizeof(data));
   }
 
   return cb.Finish();
 }
@@ skipping 160 matching lines @@
   EXPECT_CALL(client_, OnListEnd(kWebMIdCluster)).WillOnce(Return(true));
   EXPECT_CALL(client_, OnListEnd(kWebMIdSegment)).WillOnce(Return(true));
 
   WebMListParser parser(kWebMIdSegment, &client_);
   EXPECT_EQ(size, parser.Parse(kBuffer, size));
   EXPECT_TRUE(parser.IsParsingComplete());
 }
 
 
 TEST_F(WebMParserTest, ParseListElementWithSingleCall) {
-  scoped_ptr<Cluster> cluster(CreateCluster(kBlockCount));
+  std::unique_ptr<Cluster> cluster(CreateCluster(kBlockCount));
   CreateClusterExpectations(kBlockCount, true, &client_);
 
   WebMListParser parser(kWebMIdCluster, &client_);
   EXPECT_EQ(cluster->size(), parser.Parse(cluster->data(), cluster->size()));
   EXPECT_TRUE(parser.IsParsingComplete());
 }
 
 TEST_F(WebMParserTest, ParseListElementWithMultipleCalls) {
-  scoped_ptr<Cluster> cluster(CreateCluster(kBlockCount));
+  std::unique_ptr<Cluster> cluster(CreateCluster(kBlockCount));
   CreateClusterExpectations(kBlockCount, true, &client_);
 
   const uint8_t* data = cluster->data();
   int size = cluster->size();
   int default_parse_size = 3;
   WebMListParser parser(kWebMIdCluster, &client_);
   int parse_size = std::min(default_parse_size, size);
 
   while (size > 0) {
     int result = parser.Parse(data, parse_size);
@@ skipping 13 matching lines @@
     data += result;
     size -= result;
 
     EXPECT_EQ((size == 0), parser.IsParsingComplete());
   }
   EXPECT_TRUE(parser.IsParsingComplete());
 }
 
 TEST_F(WebMParserTest, Reset) {
   InSequence s;
-  scoped_ptr<Cluster> cluster(CreateCluster(kBlockCount));
+  std::unique_ptr<Cluster> cluster(CreateCluster(kBlockCount));
 
   // First expect all but the last block.
   CreateClusterExpectations(kBlockCount - 1, false, &client_);
 
   // Now expect all blocks.
   CreateClusterExpectations(kBlockCount, true, &client_);
 
   WebMListParser parser(kWebMIdCluster, &client_);
 
   // Send slightly less than the full cluster so all but the last block is
@@ skipping 123 matching lines @@
   EXPECT_CALL(client_, OnString(kWebMIdDocType, "a")).WillOnce(Return(true));
   EXPECT_CALL(client_, OnString(kWebMIdDocType, "a")).WillOnce(Return(true));
   EXPECT_CALL(client_, OnListEnd(kWebMIdEBMLHeader)).WillOnce(Return(true));
 
   WebMListParser parser(kWebMIdEBMLHeader, &client_);
   EXPECT_EQ(size, parser.Parse(kBuffer, size));
   EXPECT_TRUE(parser.IsParsingComplete());
 }
 
 }  // namespace media