cc: Use SkMScalar instead of doubles everywhere in cc

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 <limits>
 
 #include "base/memory/scoped_vector.h"
 #include "cc/animation/transform_operations.h"
 #include "cc/test/geometry_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 129 matching lines @@
   ScopedVector<TransformOperations> operations;
   GetIdentityOperations(&operations);
 
   for (size_t i = 0; i < operations.size(); ++i) {
     for (size_t j = 0; j < operations.size(); ++j)
       EXPECT_TRUE(operations[i]->MatchesTypes(*operations[j]));
   }
 }
 
 TEST(TransformOperationTest, ApplyTranslate) {
-  double x = 1;
-  double y = 2;
-  double z = 3;
+  SkMScalar x = 1;
+  SkMScalar y = 2;
+  SkMScalar z = 3;
   TransformOperations operations;
   operations.AppendTranslate(x, y, z);
   gfx::Transform expected;
   expected.Translate3d(x, y, z);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 }
 
 TEST(TransformOperationTest, ApplyRotate) {
-  double x = 1;
-  double y = 2;
-  double z = 3;
-  double degrees = 80;
+  SkMScalar x = 1;
+  SkMScalar y = 2;
+  SkMScalar z = 3;
+  SkMScalar degrees = 80;
   TransformOperations operations;
   operations.AppendRotate(x, y, z, degrees);
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(x, y, z), degrees);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 }
 
 TEST(TransformOperationTest, ApplyScale) {
-  double x = 1;
-  double y = 2;
-  double z = 3;
+  SkMScalar x = 1;
+  SkMScalar y = 2;
+  SkMScalar z = 3;
   TransformOperations operations;
   operations.AppendScale(x, y, z);
   gfx::Transform expected;
   expected.Scale3d(x, y, z);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 }
 
 TEST(TransformOperationTest, ApplySkew) {
-  double x = 1;
-  double y = 2;
+  SkMScalar x = 1;
+  SkMScalar y = 2;
   TransformOperations operations;
   operations.AppendSkew(x, y);
   gfx::Transform expected;
   expected.SkewX(x);
   expected.SkewY(y);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 }
 
 TEST(TransformOperationTest, ApplyPerspective) {
-  double depth = 800;
+  SkMScalar depth = 800;
   TransformOperations operations;
   operations.AppendPerspective(depth);
   gfx::Transform expected;
   expected.ApplyPerspectiveDepth(depth);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
 }
 
 TEST(TransformOperationTest, ApplyMatrix) {
-  double dx = 1;
-  double dy = 2;
-  double dz = 3;
+  SkMScalar dx = 1;
+  SkMScalar dy = 2;
+  SkMScalar dz = 3;
   gfx::Transform expected_matrix;
   expected_matrix.Translate3d(dx, dy, dz);
   TransformOperations matrix_transform;
   matrix_transform.AppendMatrix(expected_matrix);
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_matrix, matrix_transform.Apply());
 }
 
 TEST(TransformOperationTest, ApplyOrder) {
-  double sx = 2;
-  double sy = 4;
-  double sz = 8;
+  SkMScalar sx = 2;
+  SkMScalar sy = 4;
+  SkMScalar sz = 8;
 
-  double dx = 1;
-  double dy = 2;
-  double dz = 3;
+  SkMScalar dx = 1;
+  SkMScalar dy = 2;
+  SkMScalar dz = 3;
 
   TransformOperations operations;
   operations.AppendScale(sx, sy, sz);
   operations.AppendTranslate(dx, dy, dz);
 
   gfx::Transform expected_scale_matrix;
   expected_scale_matrix.Scale3d(sx, sy, sz);
 
   gfx::Transform expected_translate_matrix;
   expected_translate_matrix.Translate3d(dx, dy, dz);
 
   gfx::Transform expected_combined_matrix = expected_scale_matrix;
   expected_combined_matrix.PreconcatTransform(expected_translate_matrix);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_combined_matrix, operations.Apply());
 }
 
 TEST(TransformOperationTest, BlendOrder) {
-  double sx1 = 2;
-  double sy1 = 4;
-  double sz1 = 8;
+  SkMScalar sx1 = 2;
+  SkMScalar sy1 = 4;
+  SkMScalar sz1 = 8;
 
-  double dx1 = 1;
-  double dy1 = 2;
-  double dz1 = 3;
+  SkMScalar dx1 = 1;
+  SkMScalar dy1 = 2;
+  SkMScalar dz1 = 3;
 
-  double sx2 = 4;
-  double sy2 = 8;
-  double sz2 = 16;
+  SkMScalar sx2 = 4;
+  SkMScalar sy2 = 8;
+  SkMScalar sz2 = 16;
 
-  double dx2 = 10;
-  double dy2 = 20;
-  double dz2 = 30;
+  SkMScalar dx2 = 10;
+  SkMScalar dy2 = 20;
+  SkMScalar dz2 = 30;
 
   TransformOperations operations_from;
   operations_from.AppendScale(sx1, sy1, sz1);
   operations_from.AppendTranslate(dx1, dy1, dz1);
 
   TransformOperations operations_to;
   operations_to.AppendScale(sx2, sy2, sz2);
   operations_to.AppendTranslate(dx2, dy2, dz2);
 
   gfx::Transform scale_from;
   scale_from.Scale3d(sx1, sy1, sz1);
   gfx::Transform translate_from;
   translate_from.Translate3d(dx1, dy1, dz1);
 
   gfx::Transform scale_to;
   scale_to.Scale3d(sx2, sy2, sz2);
   gfx::Transform translate_to;
   translate_to.Translate3d(dx2, dy2, dz2);
 
-  double progress = 0.25;
+  SkMScalar progress = 0.25;

[danakj, 2013/09/09 17:57:45]

double?

 
   gfx::Transform blended_scale = scale_to;
   blended_scale.Blend(scale_from, progress);
 
   gfx::Transform blended_translate = translate_to;
   blended_translate.Blend(translate_from, progress);
 
   gfx::Transform expected = blended_scale;
   expected.PreconcatTransform(blended_translate);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, operations_to.Blend(operations_from, progress));
 }
 
-static void CheckProgress(double progress,
-              const gfx::Transform& from_matrix,
-              const gfx::Transform& to_matrix,
-              const TransformOperations& from_transform,
-              const TransformOperations& to_transform) {
+static void CheckProgress(SkMScalar progress,

[danakj, 2013/09/09 17:57:45]

double?

+                          const gfx::Transform& from_matrix,
+                          const gfx::Transform& to_matrix,
+                          const TransformOperations& from_transform,
+                          const TransformOperations& to_transform) {
   gfx::Transform expected_matrix = to_matrix;
   expected_matrix.Blend(from_matrix, progress);
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected_matrix, to_transform.Blend(from_transform, progress));
 }
 
 TEST(TransformOperationTest, BlendProgress) {
-  double sx = 2;
-  double sy = 4;
-  double sz = 8;
+  SkMScalar sx = 2;
+  SkMScalar sy = 4;
+  SkMScalar sz = 8;
   TransformOperations operations_from;
   operations_from.AppendScale(sx, sy, sz);
 
   gfx::Transform matrix_from;
   matrix_from.Scale3d(sx, sy, sz);
 
   sx = 4;
   sy = 8;
   sz = 16;
   TransformOperations operations_to;
   operations_to.AppendScale(sx, sy, sz);
 
   gfx::Transform matrix_to;
   matrix_to.Scale3d(sx, sy, sz);
 
   CheckProgress(-1, matrix_from, matrix_to, operations_from, operations_to);
   CheckProgress(0, matrix_from, matrix_to, operations_from, operations_to);
   CheckProgress(0.25, matrix_from, matrix_to, operations_from, operations_to);
   CheckProgress(0.5, matrix_from, matrix_to, operations_from, operations_to);
   CheckProgress(1, matrix_from, matrix_to, operations_from, operations_to);
   CheckProgress(2, matrix_from, matrix_to, operations_from, operations_to);
 }
 
 TEST(TransformOperationTest, BlendWhenTypesDoNotMatch) {
-  double sx1 = 2;
-  double sy1 = 4;
-  double sz1 = 8;
+  SkMScalar sx1 = 2;
+  SkMScalar sy1 = 4;
+  SkMScalar sz1 = 8;
 
-  double dx1 = 1;
-  double dy1 = 2;
-  double dz1 = 3;
+  SkMScalar dx1 = 1;
+  SkMScalar dy1 = 2;
+  SkMScalar dz1 = 3;
 
-  double sx2 = 4;
-  double sy2 = 8;
-  double sz2 = 16;
+  SkMScalar sx2 = 4;
+  SkMScalar sy2 = 8;
+  SkMScalar sz2 = 16;
 
-  double dx2 = 10;
-  double dy2 = 20;
-  double dz2 = 30;
+  SkMScalar dx2 = 10;
+  SkMScalar dy2 = 20;
+  SkMScalar dz2 = 30;
 
   TransformOperations operations_from;
   operations_from.AppendScale(sx1, sy1, sz1);
   operations_from.AppendTranslate(dx1, dy1, dz1);
 
   TransformOperations operations_to;
   operations_to.AppendTranslate(dx2, dy2, dz2);
   operations_to.AppendScale(sx2, sy2, sz2);
 
   gfx::Transform from;
   from.Scale3d(sx1, sy1, sz1);
   from.Translate3d(dx1, dy1, dz1);
 
   gfx::Transform to;
   to.Translate3d(dx2, dy2, dz2);
   to.Scale3d(sx2, sy2, sz2);
 
-  double progress = 0.25;
+  SkMScalar progress = 0.25;

[danakj, 2013/09/09 17:57:45]

double for all these?

 
   gfx::Transform expected = to;
   expected.Blend(from, progress);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, operations_to.Blend(operations_from, progress));
 }
 
 TEST(TransformOperationTest, LargeRotationsWithSameAxis) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 0);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 0, 2, 360);
 
-  double progress = 0.5;
+  SkMScalar progress = 0.5;
 
   gfx::Transform expected;
   expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, operations_to.Blend(operations_from, progress));
 }
 
 TEST(TransformOperationTest, LargeRotationsWithSameAxisInDifferentDirection) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 180);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 0, -1, 180);
 
-  double progress = 0.5;
+  SkMScalar progress = 0.5;
 
   gfx::Transform expected;
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, operations_to.Blend(operations_from, progress));
 }
 
 TEST(TransformOperationTest, LargeRotationsWithDifferentAxes) {
   TransformOperations operations_from;
   operations_from.AppendRotate(0, 0, 1, 175);
 
   TransformOperations operations_to;
   operations_to.AppendRotate(0, 1, 0, 175);
 
-  double progress = 0.5;
+  SkMScalar progress = 0.5;
   gfx::Transform matrix_from;
   matrix_from.RotateAbout(gfx::Vector3dF(0, 0, 1), 175);
 
   gfx::Transform matrix_to;
   matrix_to.RotateAbout(gfx::Vector3dF(0, 1, 0), 175);
 
   gfx::Transform expected = matrix_to;
   expected.Blend(matrix_from, progress);
 
   EXPECT_TRANSFORMATION_MATRIX_EQ(
       expected, operations_to.Blend(operations_from, progress));
 }
 
 TEST(TransformOperationTest, BlendRotationFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendRotate(0, 0, 1, 360);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
 
     progress = -0.5;
 
     expected.MakeIdentity();
@@ skipping 13 matching lines @@
 }
 
 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendTranslate(2, 2, 2);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
     expected.Translate3d(1, 1, 1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
 
     progress = -0.5;
 
     expected.MakeIdentity();
@@ skipping 13 matching lines @@
 }
 
 TEST(TransformOperationTest, BlendScaleFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendScale(3, 3, 3);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
 
     progress = -0.5;
 
     expected.MakeIdentity();
@@ skipping 13 matching lines @@
 }
 
 TEST(TransformOperationTest, BlendSkewFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendSkew(2, 2);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
     expected.SkewX(1);
     expected.SkewY(1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
 
     progress = -0.5;
 
@@ skipping 16 matching lines @@
 }
 
 TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
-    expected.ApplyPerspectiveDepth(
-        500 + 0.5 * std::numeric_limits<double>::max());
+    expected.ApplyPerspectiveDepth(500 +
+                                   0.5 * std::numeric_limits<SkMScalar>::max());
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, operations.Blend(*identity_operations[i], progress));
   }
 }
 
 TEST(TransformOperationTest, BlendRotationToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendRotate(0, 0, 1, 360);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, BlendTranslationToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendTranslate(2, 2, 2);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;

[danakj, 2013/09/09 17:57:45]

It's a bit off that these are 0.5 and not 0.5f or whatever, but Idk what to
really suggest, so this is fine.

[enne (OOO), 2013/09/10 22:32:32]

Changed all progress to float literals to avoid narrowing conversions later.

 
     gfx::Transform expected;
     expected.Translate3d(1, 1, 1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, BlendScaleToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendScale(3, 3, 3);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
     expected.Scale3d(2, 2, 2);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, BlendSkewToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendSkew(2, 2);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
     expected.SkewX(1);
     expected.SkewY(1);
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
   ScopedVector<TransformOperations> identity_operations;
   GetIdentityOperations(&identity_operations);
 
   for (size_t i = 0; i < identity_operations.size(); ++i) {
     TransformOperations operations;
     operations.AppendPerspective(1000);
 
-    double progress = 0.5;
+    SkMScalar progress = 0.5;
 
     gfx::Transform expected;
-    expected.ApplyPerspectiveDepth(
-        500 + 0.5 * std::numeric_limits<double>::max());
+    expected.ApplyPerspectiveDepth(500 +
+                                   0.5 * std::numeric_limits<SkMScalar>::max());
 
     EXPECT_TRANSFORMATION_MATRIX_EQ(
         expected, identity_operations[i]->Blend(operations, progress));
   }
 }
 
 TEST(TransformOperationTest, ExtrapolatePerspectiveBlending) {
   TransformOperations operations1;
   operations1.AppendPerspective(1000);
 
@@ skipping 38 matching lines @@
   operations_from.AppendScale(2.0, 4.0, 8.0);
   operations_from.AppendTranslate(1.0, 2.0, 3.0);
 
   TransformOperations operations_to;
   operations_to.AppendTranslate(10.0, 20.0, 30.0);
   operations_to.AppendScale(4.0, 8.0, 16.0);
 
   gfx::BoxF box(1.f, 1.f, 1.f);
   gfx::BoxF bounds;
 
-  double min_progress = 0.0;
-  double max_progress = 1.0;
+  SkMScalar min_progress = 0.0;

[danakj, 2013/09/09 17:57:45]

more doubles?

+  SkMScalar max_progress = 1.0;
 
   EXPECT_FALSE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
 }
 
 TEST(TransformOperationTest, BlendedBoundsForIdentity) {
   TransformOperations operations_from;
   operations_from.AppendIdentity();
   TransformOperations operations_to;
   operations_to.AppendIdentity();
 
   gfx::BoxF box(1.f, 2.f, 3.f);
   gfx::BoxF bounds;
 
-  double min_progress = 0.0;
-  double max_progress = 1.0;
+  SkMScalar min_progress = 0.0;
+  SkMScalar max_progress = 1.0;
 
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(box.ToString(), bounds.ToString());
 }
 
 TEST(TransformOperationTest, BlendedBoundsForTranslate) {
   TransformOperations operations_from;
   operations_from.AppendTranslate(3.0, -4.0, 2.0);
   TransformOperations operations_to;
   operations_to.AppendTranslate(7.0, 4.0, -2.0);
 
   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
   gfx::BoxF bounds;
 
-  double min_progress = -0.5;
-  double max_progress = 1.5;
+  SkMScalar min_progress = -0.5;
+  SkMScalar max_progress = 1.5;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(2.f, -6.f, -1.f, 12.f, 20.f, 12.f).ToString(),
             bounds.ToString());
 
   min_progress = 0.0;
   max_progress = 1.0;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(4.f, -2.f, 1.f, 8.f, 12.f, 8.f).ToString(),
@@ skipping 13 matching lines @@
 
 TEST(TransformOperationTest, BlendedBoundsForScale) {
   TransformOperations operations_from;
   operations_from.AppendScale(3.0, 0.5, 2.0);
   TransformOperations operations_to;
   operations_to.AppendScale(7.0, 4.0, -2.0);
 
   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
   gfx::BoxF bounds;
 
-  double min_progress = -0.5;
-  double max_progress = 1.5;
+  SkMScalar min_progress = -0.5;
+  SkMScalar max_progress = 1.5;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(1.f, -7.5f, -28.f, 44.f, 42.f, 56.f).ToString(),
             bounds.ToString());
 
   min_progress = 0.0;
   max_progress = 1.0;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(3.f, 1.f, -14.f, 32.f, 23.f, 28.f).ToString(),
@@ skipping 13 matching lines @@
 
 TEST(TransformOperationTest, BlendedBoundsWithZeroScale) {
   TransformOperations zero_scale;
   zero_scale.AppendScale(0.0, 0.0, 0.0);
   TransformOperations non_zero_scale;
   non_zero_scale.AppendScale(2.0, -4.0, 5.0);
 
   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
   gfx::BoxF bounds;
 
-  double min_progress = 0.0;
-  double max_progress = 1.0;
+  SkMScalar min_progress = 0.0;
+  SkMScalar max_progress = 1.0;
   EXPECT_TRUE(zero_scale.BlendedBoundsForBox(
       box, non_zero_scale, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
             bounds.ToString());
 
   EXPECT_TRUE(non_zero_scale.BlendedBoundsForBox(
       box, zero_scale, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
             bounds.ToString());
 
   EXPECT_TRUE(zero_scale.BlendedBoundsForBox(
       box, zero_scale, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF().ToString(), bounds.ToString());
 }
 
 TEST(TransformOperationTest, BlendedBoundsForSequence) {
   TransformOperations operations_from;
   operations_from.AppendTranslate(2.0, 4.0, -1.0);
   operations_from.AppendScale(-1.0, 2.0, 3.0);
   operations_from.AppendTranslate(1.0, -5.0, 1.0);
   TransformOperations operations_to;
   operations_to.AppendTranslate(6.0, -2.0, 3.0);
   operations_to.AppendScale(-3.0, -2.0, 5.0);
   operations_to.AppendTranslate(13.0, -1.0, 5.0);
 
   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
   gfx::BoxF bounds;
 
-  double min_progress = -0.5;
-  double max_progress = 1.5;
+  SkMScalar min_progress = -0.5;
+  SkMScalar max_progress = 1.5;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(-57.f, -59.f, -1.f, 76.f, 112.f, 80.f).ToString(),
             bounds.ToString());
 
   min_progress = 0.0;
   max_progress = 1.0;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
       box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(-32.f, -25.f, 7.f, 42.f, 44.f, 48.f).ToString(),
             bounds.ToString());
 
   TransformOperations identity;
   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
         box, identity, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(-33.f, -13.f, 3.f, 57.f, 19.f, 52.f).ToString(),
             bounds.ToString());
 
   EXPECT_TRUE(identity.BlendedBoundsForBox(
         box, operations_from, min_progress, max_progress, &bounds));
   EXPECT_EQ(gfx::BoxF(-7.f, -3.f, 2.f, 15.f, 23.f, 20.f).ToString(),
             bounds.ToString());
 }
 
 }  // namespace
 }  // namespace cc