Convert //cc from scoped_ptr to std::unique_ptr.

cc/animation/transform_operations_unittest.cc

 // Copyright 2013 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 "cc/animation/transform_operations.h"
+
 #include <stddef.h>
 
 #include <limits>
 #include <vector>
 
-#include "cc/animation/transform_operations.h"
+#include "base/memory/ptr_util.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/geometry/box_f.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/vector3d_f.h"
 
 namespace cc {
 namespace {
 
 TEST(TransformOperationTest, TransformTypesAreUnique) {
-  std::vector<scoped_ptr<TransformOperations>> transforms;
+  std::vector<std::unique_ptr<TransformOperations>> transforms;
 
-  scoped_ptr<TransformOperations> to_add(
-      make_scoped_ptr(new TransformOperations()));
+  std::unique_ptr<TransformOperations> to_add(
+      base::WrapUnique(new TransformOperations()));
   to_add->AppendTranslate(1, 0, 0);
   transforms.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendRotate(0, 0, 1, 2);
   transforms.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendScale(2, 2, 2);
   transforms.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendSkew(1, 0);
   transforms.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendPerspective(800);
   transforms.push_back(std::move(to_add));
 
   for (size_t i = 0; i < transforms.size(); ++i) {
     for (size_t j = 0; j < transforms.size(); ++j) {
       bool matches_type = transforms[i]->MatchesTypes(*transforms[j]);
       EXPECT_TRUE((i == j && matches_type) || !matches_type);
     }
   }
 }
@@ skipping 32 matching lines @@
   skews.AppendSkew(2, 0);
 
   TransformOperations translates2;
   translates2.AppendTranslate(0, 2, 0);
   translates2.AppendTranslate(0, 2, 0);
 
   EXPECT_FALSE(translates.MatchesTypes(skews));
   EXPECT_FALSE(translates.MatchesTypes(translates2));
 }
 
-std::vector<scoped_ptr<TransformOperations>> GetIdentityOperations() {
-  std::vector<scoped_ptr<TransformOperations>> operations;
-  scoped_ptr<TransformOperations> to_add(
-      make_scoped_ptr(new TransformOperations()));
+std::vector<std::unique_ptr<TransformOperations>> GetIdentityOperations() {
+  std::vector<std::unique_ptr<TransformOperations>> operations;
+  std::unique_ptr<TransformOperations> to_add(
+      base::WrapUnique(new TransformOperations()));
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendTranslate(0, 0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendTranslate(0, 0, 0);
   to_add->AppendTranslate(0, 0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendScale(1, 1, 1);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendScale(1, 1, 1);
   to_add->AppendScale(1, 1, 1);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendSkew(0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendSkew(0, 0);
   to_add->AppendSkew(0, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendRotate(0, 0, 1, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendRotate(0, 0, 1, 0);
   to_add->AppendRotate(0, 0, 1, 0);
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendMatrix(gfx::Transform());
   operations.push_back(std::move(to_add));
 
-  to_add = make_scoped_ptr(new TransformOperations());
+  to_add = base::WrapUnique(new TransformOperations());
   to_add->AppendMatrix(gfx::Transform());
   to_add->AppendMatrix(gfx::Transform());
   operations.push_back(std::move(to_add));
 
   return operations;
 }
 
 TEST(TransformOperationTest, MatchTypesOrder) {
   TransformOperations mix_order_identity;
   mix_order_identity.AppendTranslate(0, 0, 0);
   mix_order_identity.AppendScale(1, 1, 1);
   mix_order_identity.AppendTranslate(0, 0, 0);
 
   TransformOperations mix_order_one;
   mix_order_one.AppendTranslate(0, 1, 0);
   mix_order_one.AppendScale(2, 1, 3);
   mix_order_one.AppendTranslate(1, 0, 0);
 
   TransformOperations mix_order_two;
   mix_order_two.AppendTranslate(0, 1, 0);
   mix_order_two.AppendTranslate(1, 0, 0);
   mix_order_two.AppendScale(2, 1, 3);
 
   EXPECT_TRUE(mix_order_identity.MatchesTypes(mix_order_one));
   EXPECT_FALSE(mix_order_identity.MatchesTypes(mix_order_two));
   EXPECT_FALSE(mix_order_one.MatchesTypes(mix_order_two));
 }
 
 TEST(TransformOperationTest, NoneAlwaysMatches) {
-  std::vector<scoped_ptr<TransformOperations>> operations =
+  std::vector<std::unique_ptr<TransformOperations>> operations =
       GetIdentityOperations();
 
   TransformOperations none_operation;
   for (size_t i = 0; i < operations.size(); ++i)
     EXPECT_TRUE(operations[i]->MatchesTypes(none_operation));
 }
 
 TEST(TransformOperationTest, ApplyTranslate) {
   SkMScalar x = 1;
   SkMScalar y = 2;
@@ skipping 315 matching lines @@
   operations_to.AppendRotate(0, 0, 1, 0);
 
   SkMScalar progress = 0.5f;
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 225);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, operations_to.Blend(operations_from, progress));
 }
 
 TEST(TransformOperationTest, BlendRotationFromIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendRotate(0, 0, 1, 90);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
@@ skipping 13 matching lines @@
 
     expected.MakeIdentity();
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 135);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendTranslate(2, 2, 2);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Translate3d(1, 1, 1);
@@ skipping 13 matching lines @@
 
     expected.MakeIdentity();
     expected.Translate3d(3, 3, 3);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendScaleFromIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendScale(3, 3, 3);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
@@ skipping 44 matching lines @@
   progress = 1.5f;
 
   expected.MakeIdentity();
   expected.Skew(3, 3);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
                                   operations.Blend(empty_operation, progress));
 }
 
 TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.ApplyPerspectiveDepth(2000);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendRotationToIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendRotate(0, 0, 1, 90);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 45);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationToIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendTranslate(2, 2, 2);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Translate3d(1, 1, 1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, BlendScaleToIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendScale(3, 3, 3);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
@@ skipping 12 matching lines @@
   SkMScalar progress = 0.5f;
 
   gfx::Transform expected;
   expected.Skew(1, 1);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected,
                                   empty_operation.Blend(operations, progress));
 }
 
 TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
-  std::vector<scoped_ptr<TransformOperations>> identity_operations =
+  std::vector<std::unique_ptr<TransformOperations>> identity_operations =
       GetIdentityOperations();
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
 
     SkMScalar progress = 0.5f;
 
     gfx::Transform expected;
     expected.ApplyPerspectiveDepth(2000);
@@ skipping 788 matching lines @@
 
   // Scale + Perspective can't.
   TransformOperations operations11;
   operations11.AppendScale(2.f, 2.f, 2.f);
   operations11.AppendPerspective(1.f);
   EXPECT_FALSE(operations11.ScaleComponent(&scale));
 }
 
 }  // namespace
 }  // namespace cc