Home | History | Annotate | Download | only in animation 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include <limits>
      6 
      7 #include "base/basictypes.h"
      8 #include "base/memory/scoped_vector.h"
      9 #include "cc/animation/transform_operations.h"
     10 #include "cc/test/geometry_test_utils.h"
     11 #include "testing/gtest/include/gtest/gtest.h"
     12 #include "ui/gfx/animation/tween.h"
     13 #include "ui/gfx/box_f.h"
     14 #include "ui/gfx/rect_conversions.h"
     15 #include "ui/gfx/vector3d_f.h"
     16 
     17 namespace cc {
     18 namespace {
     19 
     20 TEST(TransformOperationTest, TransformTypesAreUnique) {
     21   ScopedVector<TransformOperations> transforms;
     22 
     23   TransformOperations* to_add = new TransformOperations();
     24   to_add->AppendTranslate(1, 0, 0);
     25   transforms.push_back(to_add);
     26 
     27   to_add = new TransformOperations();
     28   to_add->AppendRotate(0, 0, 1, 2);
     29   transforms.push_back(to_add);
     30 
     31   to_add = new TransformOperations();
     32   to_add->AppendScale(2, 2, 2);
     33   transforms.push_back(to_add);
     34 
     35   to_add = new TransformOperations();
     36   to_add->AppendSkew(1, 0);
     37   transforms.push_back(to_add);
     38 
     39   to_add = new TransformOperations();
     40   to_add->AppendPerspective(800);
     41   transforms.push_back(to_add);
     42 
     43   for (size_t i = 0; i < transforms.size(); ++i) {
     44     for (size_t j = 0; j < transforms.size(); ++j) {
     45       bool matches_type = transforms[i]->MatchesTypes(*transforms[j]);
     46       EXPECT_TRUE((i == j && matches_type) || !matches_type);
     47     }
     48   }
     49 }
     50 
     51 TEST(TransformOperationTest, MatchTypesSameLength) {
     52   TransformOperations translates;
     53   translates.AppendTranslate(1, 0, 0);
     54   translates.AppendTranslate(1, 0, 0);
     55   translates.AppendTranslate(1, 0, 0);
     56 
     57   TransformOperations skews;
     58   skews.AppendSkew(0, 2);
     59   skews.AppendSkew(0, 2);
     60   skews.AppendSkew(0, 2);
     61 
     62   TransformOperations translates2;
     63   translates2.AppendTranslate(0, 2, 0);
     64   translates2.AppendTranslate(0, 2, 0);
     65   translates2.AppendTranslate(0, 2, 0);
     66 
     67   TransformOperations translates3 = translates2;
     68 
     69   EXPECT_FALSE(translates.MatchesTypes(skews));
     70   EXPECT_TRUE(translates.MatchesTypes(translates2));
     71   EXPECT_TRUE(translates.MatchesTypes(translates3));
     72 }
     73 
     74 TEST(TransformOperationTest, MatchTypesDifferentLength) {
     75   TransformOperations translates;
     76   translates.AppendTranslate(1, 0, 0);
     77   translates.AppendTranslate(1, 0, 0);
     78   translates.AppendTranslate(1, 0, 0);
     79 
     80   TransformOperations skews;
     81   skews.AppendSkew(2, 0);
     82   skews.AppendSkew(2, 0);
     83 
     84   TransformOperations translates2;
     85   translates2.AppendTranslate(0, 2, 0);
     86   translates2.AppendTranslate(0, 2, 0);
     87 
     88   EXPECT_FALSE(translates.MatchesTypes(skews));
     89   EXPECT_FALSE(translates.MatchesTypes(translates2));
     90 }
     91 
     92 void GetIdentityOperations(ScopedVector<TransformOperations>* operations) {
     93   TransformOperations* to_add = new TransformOperations();
     94   operations->push_back(to_add);
     95 
     96   to_add = new TransformOperations();
     97   to_add->AppendTranslate(0, 0, 0);
     98   operations->push_back(to_add);
     99 
    100   to_add = new TransformOperations();
    101   to_add->AppendTranslate(0, 0, 0);
    102   to_add->AppendTranslate(0, 0, 0);
    103   operations->push_back(to_add);
    104 
    105   to_add = new TransformOperations();
    106   to_add->AppendScale(1, 1, 1);
    107   operations->push_back(to_add);
    108 
    109   to_add = new TransformOperations();
    110   to_add->AppendScale(1, 1, 1);
    111   to_add->AppendScale(1, 1, 1);
    112   operations->push_back(to_add);
    113 
    114   to_add = new TransformOperations();
    115   to_add->AppendSkew(0, 0);
    116   operations->push_back(to_add);
    117 
    118   to_add = new TransformOperations();
    119   to_add->AppendSkew(0, 0);
    120   to_add->AppendSkew(0, 0);
    121   operations->push_back(to_add);
    122 
    123   to_add = new TransformOperations();
    124   to_add->AppendRotate(0, 0, 1, 0);
    125   operations->push_back(to_add);
    126 
    127   to_add = new TransformOperations();
    128   to_add->AppendRotate(0, 0, 1, 0);
    129   to_add->AppendRotate(0, 0, 1, 0);
    130   operations->push_back(to_add);
    131 
    132   to_add = new TransformOperations();
    133   to_add->AppendMatrix(gfx::Transform());
    134   operations->push_back(to_add);
    135 
    136   to_add = new TransformOperations();
    137   to_add->AppendMatrix(gfx::Transform());
    138   to_add->AppendMatrix(gfx::Transform());
    139   operations->push_back(to_add);
    140 }
    141 
    142 TEST(TransformOperationTest, IdentityAlwaysMatches) {
    143   ScopedVector<TransformOperations> operations;
    144   GetIdentityOperations(&operations);
    145 
    146   for (size_t i = 0; i < operations.size(); ++i) {
    147     for (size_t j = 0; j < operations.size(); ++j)
    148       EXPECT_TRUE(operations[i]->MatchesTypes(*operations[j]));
    149   }
    150 }
    151 
    152 TEST(TransformOperationTest, ApplyTranslate) {
    153   SkMScalar x = 1;
    154   SkMScalar y = 2;
    155   SkMScalar z = 3;
    156   TransformOperations operations;
    157   operations.AppendTranslate(x, y, z);
    158   gfx::Transform expected;
    159   expected.Translate3d(x, y, z);
    160   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
    161 }
    162 
    163 TEST(TransformOperationTest, ApplyRotate) {
    164   SkMScalar x = 1;
    165   SkMScalar y = 2;
    166   SkMScalar z = 3;
    167   SkMScalar degrees = 80;
    168   TransformOperations operations;
    169   operations.AppendRotate(x, y, z, degrees);
    170   gfx::Transform expected;
    171   expected.RotateAbout(gfx::Vector3dF(x, y, z), degrees);
    172   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
    173 }
    174 
    175 TEST(TransformOperationTest, ApplyScale) {
    176   SkMScalar x = 1;
    177   SkMScalar y = 2;
    178   SkMScalar z = 3;
    179   TransformOperations operations;
    180   operations.AppendScale(x, y, z);
    181   gfx::Transform expected;
    182   expected.Scale3d(x, y, z);
    183   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
    184 }
    185 
    186 TEST(TransformOperationTest, ApplySkew) {
    187   SkMScalar x = 1;
    188   SkMScalar y = 2;
    189   TransformOperations operations;
    190   operations.AppendSkew(x, y);
    191   gfx::Transform expected;
    192   expected.SkewX(x);
    193   expected.SkewY(y);
    194   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
    195 }
    196 
    197 TEST(TransformOperationTest, ApplyPerspective) {
    198   SkMScalar depth = 800;
    199   TransformOperations operations;
    200   operations.AppendPerspective(depth);
    201   gfx::Transform expected;
    202   expected.ApplyPerspectiveDepth(depth);
    203   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, operations.Apply());
    204 }
    205 
    206 TEST(TransformOperationTest, ApplyMatrix) {
    207   SkMScalar dx = 1;
    208   SkMScalar dy = 2;
    209   SkMScalar dz = 3;
    210   gfx::Transform expected_matrix;
    211   expected_matrix.Translate3d(dx, dy, dz);
    212   TransformOperations matrix_transform;
    213   matrix_transform.AppendMatrix(expected_matrix);
    214   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_matrix, matrix_transform.Apply());
    215 }
    216 
    217 TEST(TransformOperationTest, ApplyOrder) {
    218   SkMScalar sx = 2;
    219   SkMScalar sy = 4;
    220   SkMScalar sz = 8;
    221 
    222   SkMScalar dx = 1;
    223   SkMScalar dy = 2;
    224   SkMScalar dz = 3;
    225 
    226   TransformOperations operations;
    227   operations.AppendScale(sx, sy, sz);
    228   operations.AppendTranslate(dx, dy, dz);
    229 
    230   gfx::Transform expected_scale_matrix;
    231   expected_scale_matrix.Scale3d(sx, sy, sz);
    232 
    233   gfx::Transform expected_translate_matrix;
    234   expected_translate_matrix.Translate3d(dx, dy, dz);
    235 
    236   gfx::Transform expected_combined_matrix = expected_scale_matrix;
    237   expected_combined_matrix.PreconcatTransform(expected_translate_matrix);
    238 
    239   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_combined_matrix, operations.Apply());
    240 }
    241 
    242 TEST(TransformOperationTest, BlendOrder) {
    243   SkMScalar sx1 = 2;
    244   SkMScalar sy1 = 4;
    245   SkMScalar sz1 = 8;
    246 
    247   SkMScalar dx1 = 1;
    248   SkMScalar dy1 = 2;
    249   SkMScalar dz1 = 3;
    250 
    251   SkMScalar sx2 = 4;
    252   SkMScalar sy2 = 8;
    253   SkMScalar sz2 = 16;
    254 
    255   SkMScalar dx2 = 10;
    256   SkMScalar dy2 = 20;
    257   SkMScalar dz2 = 30;
    258 
    259   TransformOperations operations_from;
    260   operations_from.AppendScale(sx1, sy1, sz1);
    261   operations_from.AppendTranslate(dx1, dy1, dz1);
    262 
    263   TransformOperations operations_to;
    264   operations_to.AppendScale(sx2, sy2, sz2);
    265   operations_to.AppendTranslate(dx2, dy2, dz2);
    266 
    267   gfx::Transform scale_from;
    268   scale_from.Scale3d(sx1, sy1, sz1);
    269   gfx::Transform translate_from;
    270   translate_from.Translate3d(dx1, dy1, dz1);
    271 
    272   gfx::Transform scale_to;
    273   scale_to.Scale3d(sx2, sy2, sz2);
    274   gfx::Transform translate_to;
    275   translate_to.Translate3d(dx2, dy2, dz2);
    276 
    277   SkMScalar progress = 0.25f;
    278 
    279   gfx::Transform blended_scale = scale_to;
    280   blended_scale.Blend(scale_from, progress);
    281 
    282   gfx::Transform blended_translate = translate_to;
    283   blended_translate.Blend(translate_from, progress);
    284 
    285   gfx::Transform expected = blended_scale;
    286   expected.PreconcatTransform(blended_translate);
    287 
    288   EXPECT_TRANSFORMATION_MATRIX_EQ(
    289       expected, operations_to.Blend(operations_from, progress));
    290 }
    291 
    292 static void CheckProgress(SkMScalar progress,
    293                           const gfx::Transform& from_matrix,
    294                           const gfx::Transform& to_matrix,
    295                           const TransformOperations& from_transform,
    296                           const TransformOperations& to_transform) {
    297   gfx::Transform expected_matrix = to_matrix;
    298   expected_matrix.Blend(from_matrix, progress);
    299   EXPECT_TRANSFORMATION_MATRIX_EQ(
    300       expected_matrix, to_transform.Blend(from_transform, progress));
    301 }
    302 
    303 TEST(TransformOperationTest, BlendProgress) {
    304   SkMScalar sx = 2;
    305   SkMScalar sy = 4;
    306   SkMScalar sz = 8;
    307   TransformOperations operations_from;
    308   operations_from.AppendScale(sx, sy, sz);
    309 
    310   gfx::Transform matrix_from;
    311   matrix_from.Scale3d(sx, sy, sz);
    312 
    313   sx = 4;
    314   sy = 8;
    315   sz = 16;
    316   TransformOperations operations_to;
    317   operations_to.AppendScale(sx, sy, sz);
    318 
    319   gfx::Transform matrix_to;
    320   matrix_to.Scale3d(sx, sy, sz);
    321 
    322   CheckProgress(-1, matrix_from, matrix_to, operations_from, operations_to);
    323   CheckProgress(0, matrix_from, matrix_to, operations_from, operations_to);
    324   CheckProgress(0.25f, matrix_from, matrix_to, operations_from, operations_to);
    325   CheckProgress(0.5f, matrix_from, matrix_to, operations_from, operations_to);
    326   CheckProgress(1, matrix_from, matrix_to, operations_from, operations_to);
    327   CheckProgress(2, matrix_from, matrix_to, operations_from, operations_to);
    328 }
    329 
    330 TEST(TransformOperationTest, BlendWhenTypesDoNotMatch) {
    331   SkMScalar sx1 = 2;
    332   SkMScalar sy1 = 4;
    333   SkMScalar sz1 = 8;
    334 
    335   SkMScalar dx1 = 1;
    336   SkMScalar dy1 = 2;
    337   SkMScalar dz1 = 3;
    338 
    339   SkMScalar sx2 = 4;
    340   SkMScalar sy2 = 8;
    341   SkMScalar sz2 = 16;
    342 
    343   SkMScalar dx2 = 10;
    344   SkMScalar dy2 = 20;
    345   SkMScalar dz2 = 30;
    346 
    347   TransformOperations operations_from;
    348   operations_from.AppendScale(sx1, sy1, sz1);
    349   operations_from.AppendTranslate(dx1, dy1, dz1);
    350 
    351   TransformOperations operations_to;
    352   operations_to.AppendTranslate(dx2, dy2, dz2);
    353   operations_to.AppendScale(sx2, sy2, sz2);
    354 
    355   gfx::Transform from;
    356   from.Scale3d(sx1, sy1, sz1);
    357   from.Translate3d(dx1, dy1, dz1);
    358 
    359   gfx::Transform to;
    360   to.Translate3d(dx2, dy2, dz2);
    361   to.Scale3d(sx2, sy2, sz2);
    362 
    363   SkMScalar progress = 0.25f;
    364 
    365   gfx::Transform expected = to;
    366   expected.Blend(from, progress);
    367 
    368   EXPECT_TRANSFORMATION_MATRIX_EQ(
    369       expected, operations_to.Blend(operations_from, progress));
    370 }
    371 
    372 TEST(TransformOperationTest, LargeRotationsWithSameAxis) {
    373   TransformOperations operations_from;
    374   operations_from.AppendRotate(0, 0, 1, 0);
    375 
    376   TransformOperations operations_to;
    377   operations_to.AppendRotate(0, 0, 2, 360);
    378 
    379   SkMScalar progress = 0.5f;
    380 
    381   gfx::Transform expected;
    382   expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
    383 
    384   EXPECT_TRANSFORMATION_MATRIX_EQ(
    385       expected, operations_to.Blend(operations_from, progress));
    386 }
    387 
    388 TEST(TransformOperationTest, LargeRotationsWithSameAxisInDifferentDirection) {
    389   TransformOperations operations_from;
    390   operations_from.AppendRotate(0, 0, 1, 180);
    391 
    392   TransformOperations operations_to;
    393   operations_to.AppendRotate(0, 0, -1, 180);
    394 
    395   SkMScalar progress = 0.5f;
    396 
    397   gfx::Transform expected;
    398 
    399   EXPECT_TRANSFORMATION_MATRIX_EQ(
    400       expected, operations_to.Blend(operations_from, progress));
    401 }
    402 
    403 TEST(TransformOperationTest, LargeRotationsWithDifferentAxes) {
    404   TransformOperations operations_from;
    405   operations_from.AppendRotate(0, 0, 1, 175);
    406 
    407   TransformOperations operations_to;
    408   operations_to.AppendRotate(0, 1, 0, 175);
    409 
    410   SkMScalar progress = 0.5f;
    411   gfx::Transform matrix_from;
    412   matrix_from.RotateAbout(gfx::Vector3dF(0, 0, 1), 175);
    413 
    414   gfx::Transform matrix_to;
    415   matrix_to.RotateAbout(gfx::Vector3dF(0, 1, 0), 175);
    416 
    417   gfx::Transform expected = matrix_to;
    418   expected.Blend(matrix_from, progress);
    419 
    420   EXPECT_TRANSFORMATION_MATRIX_EQ(
    421       expected, operations_to.Blend(operations_from, progress));
    422 }
    423 
    424 TEST(TransformOperationTest, BlendRotationFromIdentity) {
    425   ScopedVector<TransformOperations> identity_operations;
    426   GetIdentityOperations(&identity_operations);
    427 
    428   for (size_t i = 0; i < identity_operations.size(); ++i) {
    429     TransformOperations operations;
    430     operations.AppendRotate(0, 0, 1, 360);
    431 
    432     SkMScalar progress = 0.5f;
    433 
    434     gfx::Transform expected;
    435     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
    436 
    437     EXPECT_TRANSFORMATION_MATRIX_EQ(
    438         expected, operations.Blend(*identity_operations[i], progress));
    439 
    440     progress = -0.5f;
    441 
    442     expected.MakeIdentity();
    443     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), -180);
    444 
    445     EXPECT_TRANSFORMATION_MATRIX_EQ(
    446         expected, operations.Blend(*identity_operations[i], progress));
    447 
    448     progress = 1.5f;
    449 
    450     expected.MakeIdentity();
    451     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 540);
    452 
    453     EXPECT_TRANSFORMATION_MATRIX_EQ(
    454         expected, operations.Blend(*identity_operations[i], progress));
    455   }
    456 }
    457 
    458 TEST(TransformOperationTest, BlendTranslationFromIdentity) {
    459   ScopedVector<TransformOperations> identity_operations;
    460   GetIdentityOperations(&identity_operations);
    461 
    462   for (size_t i = 0; i < identity_operations.size(); ++i) {
    463     TransformOperations operations;
    464     operations.AppendTranslate(2, 2, 2);
    465 
    466     SkMScalar progress = 0.5f;
    467 
    468     gfx::Transform expected;
    469     expected.Translate3d(1, 1, 1);
    470 
    471     EXPECT_TRANSFORMATION_MATRIX_EQ(
    472         expected, operations.Blend(*identity_operations[i], progress));
    473 
    474     progress = -0.5f;
    475 
    476     expected.MakeIdentity();
    477     expected.Translate3d(-1, -1, -1);
    478 
    479     EXPECT_TRANSFORMATION_MATRIX_EQ(
    480         expected, operations.Blend(*identity_operations[i], progress));
    481 
    482     progress = 1.5f;
    483 
    484     expected.MakeIdentity();
    485     expected.Translate3d(3, 3, 3);
    486 
    487     EXPECT_TRANSFORMATION_MATRIX_EQ(
    488         expected, operations.Blend(*identity_operations[i], progress));
    489   }
    490 }
    491 
    492 TEST(TransformOperationTest, BlendScaleFromIdentity) {
    493   ScopedVector<TransformOperations> identity_operations;
    494   GetIdentityOperations(&identity_operations);
    495 
    496   for (size_t i = 0; i < identity_operations.size(); ++i) {
    497     TransformOperations operations;
    498     operations.AppendScale(3, 3, 3);
    499 
    500     SkMScalar progress = 0.5f;
    501 
    502     gfx::Transform expected;
    503     expected.Scale3d(2, 2, 2);
    504 
    505     EXPECT_TRANSFORMATION_MATRIX_EQ(
    506         expected, operations.Blend(*identity_operations[i], progress));
    507 
    508     progress = -0.5f;
    509 
    510     expected.MakeIdentity();
    511     expected.Scale3d(0, 0, 0);
    512 
    513     EXPECT_TRANSFORMATION_MATRIX_EQ(
    514         expected, operations.Blend(*identity_operations[i], progress));
    515 
    516     progress = 1.5f;
    517 
    518     expected.MakeIdentity();
    519     expected.Scale3d(4, 4, 4);
    520 
    521     EXPECT_TRANSFORMATION_MATRIX_EQ(
    522         expected, operations.Blend(*identity_operations[i], progress));
    523   }
    524 }
    525 
    526 TEST(TransformOperationTest, BlendSkewFromIdentity) {
    527   ScopedVector<TransformOperations> identity_operations;
    528   GetIdentityOperations(&identity_operations);
    529 
    530   for (size_t i = 0; i < identity_operations.size(); ++i) {
    531     TransformOperations operations;
    532     operations.AppendSkew(2, 2);
    533 
    534     SkMScalar progress = 0.5f;
    535 
    536     gfx::Transform expected;
    537     expected.SkewX(1);
    538     expected.SkewY(1);
    539 
    540     EXPECT_TRANSFORMATION_MATRIX_EQ(
    541         expected, operations.Blend(*identity_operations[i], progress));
    542 
    543     progress = -0.5f;
    544 
    545     expected.MakeIdentity();
    546     expected.SkewX(-1);
    547     expected.SkewY(-1);
    548 
    549     EXPECT_TRANSFORMATION_MATRIX_EQ(
    550         expected, operations.Blend(*identity_operations[i], progress));
    551 
    552     progress = 1.5f;
    553 
    554     expected.MakeIdentity();
    555     expected.SkewX(3);
    556     expected.SkewY(3);
    557 
    558     EXPECT_TRANSFORMATION_MATRIX_EQ(
    559         expected, operations.Blend(*identity_operations[i], progress));
    560   }
    561 }
    562 
    563 TEST(TransformOperationTest, BlendPerspectiveFromIdentity) {
    564   ScopedVector<TransformOperations> identity_operations;
    565   GetIdentityOperations(&identity_operations);
    566 
    567   for (size_t i = 0; i < identity_operations.size(); ++i) {
    568     TransformOperations operations;
    569     operations.AppendPerspective(1000);
    570 
    571     SkMScalar progress = 0.5f;
    572 
    573     gfx::Transform expected;
    574     expected.ApplyPerspectiveDepth(2000);
    575 
    576     EXPECT_TRANSFORMATION_MATRIX_EQ(
    577         expected, operations.Blend(*identity_operations[i], progress));
    578   }
    579 }
    580 
    581 TEST(TransformOperationTest, BlendRotationToIdentity) {
    582   ScopedVector<TransformOperations> identity_operations;
    583   GetIdentityOperations(&identity_operations);
    584 
    585   for (size_t i = 0; i < identity_operations.size(); ++i) {
    586     TransformOperations operations;
    587     operations.AppendRotate(0, 0, 1, 360);
    588 
    589     SkMScalar progress = 0.5f;
    590 
    591     gfx::Transform expected;
    592     expected.RotateAbout(gfx::Vector3dF(0, 0, 1), 180);
    593 
    594     EXPECT_TRANSFORMATION_MATRIX_EQ(
    595         expected, identity_operations[i]->Blend(operations, progress));
    596   }
    597 }
    598 
    599 TEST(TransformOperationTest, BlendTranslationToIdentity) {
    600   ScopedVector<TransformOperations> identity_operations;
    601   GetIdentityOperations(&identity_operations);
    602 
    603   for (size_t i = 0; i < identity_operations.size(); ++i) {
    604     TransformOperations operations;
    605     operations.AppendTranslate(2, 2, 2);
    606 
    607     SkMScalar progress = 0.5f;
    608 
    609     gfx::Transform expected;
    610     expected.Translate3d(1, 1, 1);
    611 
    612     EXPECT_TRANSFORMATION_MATRIX_EQ(
    613         expected, identity_operations[i]->Blend(operations, progress));
    614   }
    615 }
    616 
    617 TEST(TransformOperationTest, BlendScaleToIdentity) {
    618   ScopedVector<TransformOperations> identity_operations;
    619   GetIdentityOperations(&identity_operations);
    620 
    621   for (size_t i = 0; i < identity_operations.size(); ++i) {
    622     TransformOperations operations;
    623     operations.AppendScale(3, 3, 3);
    624 
    625     SkMScalar progress = 0.5f;
    626 
    627     gfx::Transform expected;
    628     expected.Scale3d(2, 2, 2);
    629 
    630     EXPECT_TRANSFORMATION_MATRIX_EQ(
    631         expected, identity_operations[i]->Blend(operations, progress));
    632   }
    633 }
    634 
    635 TEST(TransformOperationTest, BlendSkewToIdentity) {
    636   ScopedVector<TransformOperations> identity_operations;
    637   GetIdentityOperations(&identity_operations);
    638 
    639   for (size_t i = 0; i < identity_operations.size(); ++i) {
    640     TransformOperations operations;
    641     operations.AppendSkew(2, 2);
    642 
    643     SkMScalar progress = 0.5f;
    644 
    645     gfx::Transform expected;
    646     expected.SkewX(1);
    647     expected.SkewY(1);
    648 
    649     EXPECT_TRANSFORMATION_MATRIX_EQ(
    650         expected, identity_operations[i]->Blend(operations, progress));
    651   }
    652 }
    653 
    654 TEST(TransformOperationTest, BlendPerspectiveToIdentity) {
    655   ScopedVector<TransformOperations> identity_operations;
    656   GetIdentityOperations(&identity_operations);
    657 
    658   for (size_t i = 0; i < identity_operations.size(); ++i) {
    659     TransformOperations operations;
    660     operations.AppendPerspective(1000);
    661 
    662     SkMScalar progress = 0.5f;
    663 
    664     gfx::Transform expected;
    665     expected.ApplyPerspectiveDepth(2000);
    666 
    667     EXPECT_TRANSFORMATION_MATRIX_EQ(
    668         expected, identity_operations[i]->Blend(operations, progress));
    669   }
    670 }
    671 
    672 TEST(TransformOperationTest, ExtrapolatePerspectiveBlending) {
    673   TransformOperations operations1;
    674   operations1.AppendPerspective(1000);
    675 
    676   TransformOperations operations2;
    677   operations2.AppendPerspective(500);
    678 
    679   gfx::Transform expected;
    680   expected.ApplyPerspectiveDepth(400);
    681 
    682   EXPECT_TRANSFORMATION_MATRIX_EQ(
    683       expected, operations1.Blend(operations2, -0.5));
    684 
    685   expected.MakeIdentity();
    686   expected.ApplyPerspectiveDepth(2000);
    687 
    688   EXPECT_TRANSFORMATION_MATRIX_EQ(
    689       expected, operations1.Blend(operations2, 1.5));
    690 }
    691 
    692 TEST(TransformOperationTest, ExtrapolateMatrixBlending) {
    693   gfx::Transform transform1;
    694   transform1.Translate3d(1, 1, 1);
    695   TransformOperations operations1;
    696   operations1.AppendMatrix(transform1);
    697 
    698   gfx::Transform transform2;
    699   transform2.Translate3d(3, 3, 3);
    700   TransformOperations operations2;
    701   operations2.AppendMatrix(transform2);
    702 
    703   gfx::Transform expected;
    704   EXPECT_TRANSFORMATION_MATRIX_EQ(
    705       expected, operations1.Blend(operations2, 1.5));
    706 
    707   expected.Translate3d(4, 4, 4);
    708   EXPECT_TRANSFORMATION_MATRIX_EQ(
    709       expected, operations1.Blend(operations2, -0.5));
    710 }
    711 
    712 TEST(TransformOperationTest, BlendedBoundsWhenTypesDoNotMatch) {
    713   TransformOperations operations_from;
    714   operations_from.AppendScale(2.0, 4.0, 8.0);
    715   operations_from.AppendTranslate(1.0, 2.0, 3.0);
    716 
    717   TransformOperations operations_to;
    718   operations_to.AppendTranslate(10.0, 20.0, 30.0);
    719   operations_to.AppendScale(4.0, 8.0, 16.0);
    720 
    721   gfx::BoxF box(1.f, 1.f, 1.f);
    722   gfx::BoxF bounds;
    723 
    724   SkMScalar min_progress = 0.f;
    725   SkMScalar max_progress = 1.f;
    726 
    727   EXPECT_FALSE(operations_to.BlendedBoundsForBox(
    728       box, operations_from, min_progress, max_progress, &bounds));
    729 }
    730 
    731 TEST(TransformOperationTest, BlendedBoundsForIdentity) {
    732   TransformOperations operations_from;
    733   operations_from.AppendIdentity();
    734   TransformOperations operations_to;
    735   operations_to.AppendIdentity();
    736 
    737   gfx::BoxF box(1.f, 2.f, 3.f);
    738   gfx::BoxF bounds;
    739 
    740   SkMScalar min_progress = 0.f;
    741   SkMScalar max_progress = 1.f;
    742 
    743   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    744       box, operations_from, min_progress, max_progress, &bounds));
    745   EXPECT_EQ(box.ToString(), bounds.ToString());
    746 }
    747 
    748 TEST(TransformOperationTest, BlendedBoundsForTranslate) {
    749   TransformOperations operations_from;
    750   operations_from.AppendTranslate(3.0, -4.0, 2.0);
    751   TransformOperations operations_to;
    752   operations_to.AppendTranslate(7.0, 4.0, -2.0);
    753 
    754   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
    755   gfx::BoxF bounds;
    756 
    757   SkMScalar min_progress = -0.5f;
    758   SkMScalar max_progress = 1.5f;
    759   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    760       box, operations_from, min_progress, max_progress, &bounds));
    761   EXPECT_EQ(gfx::BoxF(2.f, -6.f, -1.f, 12.f, 20.f, 12.f).ToString(),
    762             bounds.ToString());
    763 
    764   min_progress = 0.f;
    765   max_progress = 1.f;
    766   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    767       box, operations_from, min_progress, max_progress, &bounds));
    768   EXPECT_EQ(gfx::BoxF(4.f, -2.f, 1.f, 8.f, 12.f, 8.f).ToString(),
    769             bounds.ToString());
    770 
    771   TransformOperations identity;
    772   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    773         box, identity, min_progress, max_progress, &bounds));
    774   EXPECT_EQ(gfx::BoxF(1.f, 2.f, 1.f, 11.f, 8.f, 6.f).ToString(),
    775             bounds.ToString());
    776 
    777   EXPECT_TRUE(identity.BlendedBoundsForBox(
    778         box, operations_from, min_progress, max_progress, &bounds));
    779   EXPECT_EQ(gfx::BoxF(1.f, -2.f, 3.f, 7.f, 8.f, 6.f).ToString(),
    780             bounds.ToString());
    781 }
    782 
    783 TEST(TransformOperationTest, BlendedBoundsForScale) {
    784   TransformOperations operations_from;
    785   operations_from.AppendScale(3.0, 0.5, 2.0);
    786   TransformOperations operations_to;
    787   operations_to.AppendScale(7.0, 4.0, -2.0);
    788 
    789   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
    790   gfx::BoxF bounds;
    791 
    792   SkMScalar min_progress = -0.5f;
    793   SkMScalar max_progress = 1.5f;
    794   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    795       box, operations_from, min_progress, max_progress, &bounds));
    796   EXPECT_EQ(gfx::BoxF(1.f, -7.5f, -28.f, 44.f, 42.f, 56.f).ToString(),
    797             bounds.ToString());
    798 
    799   min_progress = 0.f;
    800   max_progress = 1.f;
    801   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    802       box, operations_from, min_progress, max_progress, &bounds));
    803   EXPECT_EQ(gfx::BoxF(3.f, 1.f, -14.f, 32.f, 23.f, 28.f).ToString(),
    804             bounds.ToString());
    805 
    806   TransformOperations identity;
    807   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    808         box, identity, min_progress, max_progress, &bounds));
    809   EXPECT_EQ(gfx::BoxF(1.f, 2.f, -14.f, 34.f, 22.f, 21.f).ToString(),
    810             bounds.ToString());
    811 
    812   EXPECT_TRUE(identity.BlendedBoundsForBox(
    813         box, operations_from, min_progress, max_progress, &bounds));
    814   EXPECT_EQ(gfx::BoxF(1.f, 1.f, 3.f, 14.f, 5.f, 11.f).ToString(),
    815             bounds.ToString());
    816 }
    817 
    818 TEST(TransformOperationTest, BlendedBoundsWithZeroScale) {
    819   TransformOperations zero_scale;
    820   zero_scale.AppendScale(0.0, 0.0, 0.0);
    821   TransformOperations non_zero_scale;
    822   non_zero_scale.AppendScale(2.0, -4.0, 5.0);
    823 
    824   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
    825   gfx::BoxF bounds;
    826 
    827   SkMScalar min_progress = 0.f;
    828   SkMScalar max_progress = 1.f;
    829   EXPECT_TRUE(zero_scale.BlendedBoundsForBox(
    830       box, non_zero_scale, min_progress, max_progress, &bounds));
    831   EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
    832             bounds.ToString());
    833 
    834   EXPECT_TRUE(non_zero_scale.BlendedBoundsForBox(
    835       box, zero_scale, min_progress, max_progress, &bounds));
    836   EXPECT_EQ(gfx::BoxF(0.f, -24.f, 0.f, 10.f, 24.f, 35.f).ToString(),
    837             bounds.ToString());
    838 
    839   EXPECT_TRUE(zero_scale.BlendedBoundsForBox(
    840       box, zero_scale, min_progress, max_progress, &bounds));
    841   EXPECT_EQ(gfx::BoxF().ToString(), bounds.ToString());
    842 }
    843 
    844 TEST(TransformOperationTest, BlendedBoundsForRotationTrivial) {
    845   TransformOperations operations_from;
    846   operations_from.AppendRotate(0.f, 0.f, 1.f, 0.f);
    847   TransformOperations operations_to;
    848   operations_to.AppendRotate(0.f, 0.f, 1.f, 360.f);
    849 
    850   float sqrt_2 = sqrt(2.f);
    851   gfx::BoxF box(
    852       -sqrt_2, -sqrt_2, 0.f, sqrt_2, sqrt_2, 0.f);
    853   gfx::BoxF bounds;
    854 
    855   // Since we're rotating 360 degrees, any box with dimensions between 0 and
    856   // 2 * sqrt(2) should give the same result.
    857   float sizes[] = { 0.f, 0.1f, sqrt_2, 2.f * sqrt_2 };
    858   for (size_t i = 0; i < arraysize(sizes); ++i) {
    859     box.set_size(sizes[i], sizes[i], 0.f);
    860     SkMScalar min_progress = 0.f;
    861     SkMScalar max_progress = 1.f;
    862     EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    863         box, operations_from, min_progress, max_progress, &bounds));
    864     EXPECT_EQ(gfx::BoxF(-2.f, -2.f, 0.f, 4.f, 4.f, 0.f).ToString(),
    865               bounds.ToString());
    866   }
    867 }
    868 
    869 TEST(TransformOperationTest, BlendedBoundsForRotationAllExtrema) {
    870   // If the normal is out of the plane, we can have up to 6 extrema (a min/max
    871   // in each dimension) between the endpoints of the arc. This test ensures that
    872   // we consider all 6.
    873   TransformOperations operations_from;
    874   operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
    875   TransformOperations operations_to;
    876   operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
    877 
    878   gfx::BoxF box(1.f, 0.f, 0.f, 0.f, 0.f, 0.f);
    879   gfx::BoxF bounds;
    880 
    881   float min = -1.f / 3.f;
    882   float max = 1.f;
    883   float size = max - min;
    884   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    885       box, operations_from, 0.f, 1.f, &bounds));
    886   EXPECT_EQ(gfx::BoxF(min, min, min, size, size, size).ToString(),
    887             bounds.ToString());
    888 }
    889 
    890 TEST(TransformOperationTest, BlendedBoundsForRotationDifferentAxes) {
    891   // We can handle rotations about a single axis. If the axes are different,
    892   // we revert to matrix interpolation for which inflated bounds cannot be
    893   // computed.
    894   TransformOperations operations_from;
    895   operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
    896   TransformOperations operations_to_same;
    897   operations_to_same.AppendRotate(1.f, 1.f, 1.f, 390.f);
    898   TransformOperations operations_to_opposite;
    899   operations_to_opposite.AppendRotate(-1.f, -1.f, -1.f, 390.f);
    900   TransformOperations operations_to_different;
    901   operations_to_different.AppendRotate(1.f, 3.f, 1.f, 390.f);
    902 
    903   gfx::BoxF box(1.f, 0.f, 0.f, 0.f, 0.f, 0.f);
    904   gfx::BoxF bounds;
    905 
    906   EXPECT_TRUE(operations_to_same.BlendedBoundsForBox(
    907       box, operations_from, 0.f, 1.f, &bounds));
    908   EXPECT_TRUE(operations_to_opposite.BlendedBoundsForBox(
    909       box, operations_from, 0.f, 1.f, &bounds));
    910   EXPECT_FALSE(operations_to_different.BlendedBoundsForBox(
    911       box, operations_from, 0.f, 1.f, &bounds));
    912 }
    913 
    914 TEST(TransformOperationTest, BlendedBoundsForRotationPointOnAxis) {
    915   // Checks that if the point to rotate is sitting on the axis of rotation, that
    916   // it does not get affected.
    917   TransformOperations operations_from;
    918   operations_from.AppendRotate(1.f, 1.f, 1.f, 30.f);
    919   TransformOperations operations_to;
    920   operations_to.AppendRotate(1.f, 1.f, 1.f, 390.f);
    921 
    922   gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
    923   gfx::BoxF bounds;
    924 
    925   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    926       box, operations_from, 0.f, 1.f, &bounds));
    927   EXPECT_EQ(box.ToString(), bounds.ToString());
    928 }
    929 
    930 // This would have been best as anonymous structs, but |arraysize| does not get
    931 // along with anonymous structs (and using ARRAYSIZE_UNSAFE seemed like a worse
    932 // option).
    933 struct ProblematicAxisTest {
    934   float x;
    935   float y;
    936   float z;
    937   gfx::BoxF expected;
    938 };
    939 
    940 TEST(TransformOperationTest, BlendedBoundsForRotationProblematicAxes) {
    941   // Zeros in the components of the axis of rotation turned out to be tricky to
    942   // deal with in practice. This function tests some potentially problematic
    943   // axes to ensure sane behavior.
    944 
    945   // Some common values used in the expected boxes.
    946   float dim1 = 0.292893f;
    947   float dim2 = sqrt(2.f);
    948   float dim3 = 2.f * dim2;
    949 
    950   ProblematicAxisTest tests[] = {
    951     { 0.f, 0.f, 0.f, gfx::BoxF(1.f, 1.f, 1.f, 0.f, 0.f, 0.f) },
    952     { 1.f, 0.f, 0.f, gfx::BoxF(1.f, -dim2, -dim2, 0.f, dim3, dim3) },
    953     { 0.f, 1.f, 0.f, gfx::BoxF(-dim2, 1.f, -dim2, dim3, 0.f, dim3) },
    954     { 0.f, 0.f, 1.f, gfx::BoxF(-dim2, -dim2, 1.f, dim3, dim3, 0.f) },
    955     { 1.f, 1.f, 0.f, gfx::BoxF(dim1, dim1, -1.f, dim2, dim2, 2.f) },
    956     { 0.f, 1.f, 1.f, gfx::BoxF(-1.f, dim1, dim1, 2.f, dim2, dim2) },
    957     { 1.f, 0.f, 1.f, gfx::BoxF(dim1, -1.f, dim1, dim2, 2.f, dim2) }
    958   };
    959 
    960   for (size_t i = 0; i < arraysize(tests); ++i) {
    961     float x = tests[i].x;
    962     float y = tests[i].y;
    963     float z = tests[i].z;
    964     TransformOperations operations_from;
    965     operations_from.AppendRotate(x, y, z, 0.f);
    966     TransformOperations operations_to;
    967     operations_to.AppendRotate(x, y, z, 360.f);
    968     gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
    969     gfx::BoxF bounds;
    970 
    971     EXPECT_TRUE(operations_to.BlendedBoundsForBox(
    972         box, operations_from, 0.f, 1.f, &bounds));
    973     EXPECT_EQ(tests[i].expected.ToString(), bounds.ToString());
    974   }
    975 }
    976 
    977 // These would have been best as anonymous structs, but |arraysize| does not get
    978 // along with anonymous structs (and using ARRAYSIZE_UNSAFE seemed like a worse
    979 // option).
    980 struct TestAxis {
    981   float x;
    982   float y;
    983   float z;
    984 };
    985 
    986 struct TestAngles {
    987   float theta_from;
    988   float theta_to;
    989 };
    990 
    991 struct TestProgress {
    992   float min_progress;
    993   float max_progress;
    994 };
    995 
    996 static void ExpectBoxesApproximatelyEqual(const gfx::BoxF& lhs,
    997                                           const gfx::BoxF& rhs,
    998                                           float tolerance) {
    999   EXPECT_NEAR(lhs.x(), rhs.x(), tolerance);
   1000   EXPECT_NEAR(lhs.y(), rhs.y(), tolerance);
   1001   EXPECT_NEAR(lhs.z(), rhs.z(), tolerance);
   1002   EXPECT_NEAR(lhs.width(), rhs.width(), tolerance);
   1003   EXPECT_NEAR(lhs.height(), rhs.height(), tolerance);
   1004   EXPECT_NEAR(lhs.depth(), rhs.depth(), tolerance);
   1005 }
   1006 
   1007 static void EmpiricallyTestBounds(const TransformOperations& from,
   1008                                   const TransformOperations& to,
   1009                                   SkMScalar min_progress,
   1010                                   SkMScalar max_progress,
   1011                                   bool test_containment_only) {
   1012   gfx::BoxF box(200.f, 500.f, 100.f, 100.f, 300.f, 200.f);
   1013   gfx::BoxF bounds;
   1014   EXPECT_TRUE(
   1015       to.BlendedBoundsForBox(box, from, min_progress, max_progress, &bounds));
   1016 
   1017   bool first_time = true;
   1018   gfx::BoxF empirical_bounds;
   1019   static const size_t kNumSteps = 10;
   1020   for (size_t step = 0; step < kNumSteps; ++step) {
   1021     float t = step / (kNumSteps - 1.f);
   1022     t = gfx::Tween::FloatValueBetween(t, min_progress, max_progress);
   1023     gfx::Transform partial_transform = to.Blend(from, t);
   1024     gfx::BoxF transformed = box;
   1025     partial_transform.TransformBox(&transformed);
   1026 
   1027     if (first_time) {
   1028       empirical_bounds = transformed;
   1029       first_time = false;
   1030     } else {
   1031       empirical_bounds.Union(transformed);
   1032     }
   1033   }
   1034 
   1035   if (test_containment_only) {
   1036     gfx::BoxF unified_bounds = bounds;
   1037     unified_bounds.Union(empirical_bounds);
   1038     // Convert to the screen space rects these boxes represent.
   1039     gfx::Rect bounds_rect = ToEnclosingRect(
   1040         gfx::RectF(bounds.x(), bounds.y(), bounds.width(), bounds.height()));
   1041     gfx::Rect unified_bounds_rect =
   1042         ToEnclosingRect(gfx::RectF(unified_bounds.x(),
   1043                                    unified_bounds.y(),
   1044                                    unified_bounds.width(),
   1045                                    unified_bounds.height()));
   1046     EXPECT_EQ(bounds_rect.ToString(), unified_bounds_rect.ToString());
   1047   } else {
   1048     // Our empirical estimate will be a little rough since we're only doing
   1049     // 100 samples.
   1050     static const float kTolerance = 1e-2f;
   1051     ExpectBoxesApproximatelyEqual(empirical_bounds, bounds, kTolerance);
   1052   }
   1053 }
   1054 
   1055 static void EmpiricallyTestBoundsEquality(const TransformOperations& from,
   1056                                           const TransformOperations& to,
   1057                                           SkMScalar min_progress,
   1058                                           SkMScalar max_progress) {
   1059   EmpiricallyTestBounds(from, to, min_progress, max_progress, false);
   1060 }
   1061 
   1062 static void EmpiricallyTestBoundsContainment(const TransformOperations& from,
   1063                                              const TransformOperations& to,
   1064                                              SkMScalar min_progress,
   1065                                              SkMScalar max_progress) {
   1066   EmpiricallyTestBounds(from, to, min_progress, max_progress, true);
   1067 }
   1068 
   1069 TEST(TransformOperationTest, BlendedBoundsForRotationEmpiricalTests) {
   1070   // Sets up various axis angle combinations, computes the bounding box and
   1071   // empirically tests that the transformed bounds are indeed contained by the
   1072   // computed bounding box.
   1073 
   1074   TestAxis axes[] = {
   1075     { 1.f, 1.f, 1.f },
   1076     { -1.f, -1.f, -1.f },
   1077     { -1.f, 2.f, 3.f },
   1078     { 1.f, -2.f, 3.f },
   1079     { 1.f, 2.f, -3.f },
   1080     { 0.f, 0.f, 0.f },
   1081     { 1.f, 0.f, 0.f },
   1082     { 0.f, 1.f, 0.f },
   1083     { 0.f, 0.f, 1.f },
   1084     { 1.f, 1.f, 0.f },
   1085     { 0.f, 1.f, 1.f },
   1086     { 1.f, 0.f, 1.f },
   1087     { -1.f, 0.f, 0.f },
   1088     { 0.f, -1.f, 0.f },
   1089     { 0.f, 0.f, -1.f },
   1090     { -1.f, -1.f, 0.f },
   1091     { 0.f, -1.f, -1.f },
   1092     { -1.f, 0.f, -1.f }
   1093   };
   1094 
   1095   TestAngles angles[] = {
   1096     { 5.f, 10.f },
   1097     { 10.f, 5.f },
   1098     { 0.f, 360.f },
   1099     { 20.f, 180.f },
   1100     { -20.f, -180.f },
   1101     { 180.f, -220.f },
   1102     { 220.f, 320.f }
   1103   };
   1104 
   1105   // We can go beyond the range [0, 1] (the bezier might slide out of this range
   1106   // at either end), but since the first and last knots are at (0, 0) and (1, 1)
   1107   // we will never go within it, so these tests are sufficient.
   1108   TestProgress progress[] = {
   1109     { 0.f, 1.f },
   1110     { -.25f, 1.25f },
   1111   };
   1112 
   1113   for (size_t i = 0; i < arraysize(axes); ++i) {
   1114     for (size_t j = 0; j < arraysize(angles); ++j) {
   1115       for (size_t k = 0; k < arraysize(progress); ++k) {
   1116         float x = axes[i].x;
   1117         float y = axes[i].y;
   1118         float z = axes[i].z;
   1119         TransformOperations operations_from;
   1120         operations_from.AppendRotate(x, y, z, angles[j].theta_from);
   1121         TransformOperations operations_to;
   1122         operations_to.AppendRotate(x, y, z, angles[j].theta_to);
   1123         EmpiricallyTestBoundsContainment(operations_from,
   1124                                          operations_to,
   1125                                          progress[k].min_progress,
   1126                                          progress[k].max_progress);
   1127       }
   1128     }
   1129   }
   1130 }
   1131 
   1132 TEST(TransformOperationTest, PerspectiveMatrixAndTransformBlendingEquivalency) {
   1133     TransformOperations from_operations;
   1134     from_operations.AppendPerspective(200);
   1135 
   1136     TransformOperations to_operations;
   1137     to_operations.AppendPerspective(1000);
   1138 
   1139     gfx::Transform from_transform;
   1140     from_transform.ApplyPerspectiveDepth(200);
   1141 
   1142     gfx::Transform to_transform;
   1143     to_transform.ApplyPerspectiveDepth(1000);
   1144 
   1145     static const int steps = 20;
   1146     for (int i = 0; i < steps; ++i) {
   1147       double progress = static_cast<double>(i) / (steps - 1);
   1148 
   1149       gfx::Transform blended_matrix = to_transform;
   1150       EXPECT_TRUE(blended_matrix.Blend(from_transform, progress));
   1151 
   1152       gfx::Transform blended_transform =
   1153           to_operations.Blend(from_operations, progress);
   1154 
   1155       EXPECT_TRANSFORMATION_MATRIX_EQ(blended_matrix, blended_transform);
   1156     }
   1157 }
   1158 
   1159 struct TestPerspectiveDepths {
   1160   float from_depth;
   1161   float to_depth;
   1162 };
   1163 
   1164 TEST(TransformOperationTest, BlendedBoundsForPerspective) {
   1165   TestPerspectiveDepths perspective_depths[] = {
   1166     { 600.f, 400.f },
   1167     { 800.f, 1000.f },
   1168     { 800.f, std::numeric_limits<float>::infinity() },
   1169   };
   1170 
   1171   TestProgress progress[] = {
   1172     { 0.f, 1.f },
   1173     { -0.1f, 1.1f },
   1174   };
   1175 
   1176   for (size_t i = 0; i < arraysize(perspective_depths); ++i) {
   1177     for (size_t j = 0; j < arraysize(progress); ++j) {
   1178       TransformOperations operations_from;
   1179       operations_from.AppendPerspective(perspective_depths[i].from_depth);
   1180       TransformOperations operations_to;
   1181       operations_to.AppendPerspective(perspective_depths[i].to_depth);
   1182       EmpiricallyTestBoundsEquality(operations_from,
   1183                                     operations_to,
   1184                                     progress[j].min_progress,
   1185                                     progress[j].max_progress);
   1186     }
   1187   }
   1188 }
   1189 
   1190 struct TestSkews {
   1191   float from_x;
   1192   float from_y;
   1193   float to_x;
   1194   float to_y;
   1195 };
   1196 
   1197 TEST(TransformOperationTest, BlendedBoundsForSkew) {
   1198   TestSkews skews[] = {
   1199     { 1.f, 0.5f, 0.5f, 1.f },
   1200     { 2.f, 1.f, 0.5f, 0.5f },
   1201   };
   1202 
   1203   TestProgress progress[] = {
   1204     { 0.f, 1.f },
   1205     { -0.1f, 1.1f },
   1206   };
   1207 
   1208   for (size_t i = 0; i < arraysize(skews); ++i) {
   1209     for (size_t j = 0; j < arraysize(progress); ++j) {
   1210       TransformOperations operations_from;
   1211       operations_from.AppendSkew(skews[i].from_x, skews[i].from_y);
   1212       TransformOperations operations_to;
   1213       operations_to.AppendSkew(skews[i].to_x, skews[i].to_y);
   1214       EmpiricallyTestBoundsEquality(operations_from,
   1215                                     operations_to,
   1216                                     progress[j].min_progress,
   1217                                     progress[j].max_progress);
   1218     }
   1219   }
   1220 }
   1221 
   1222 TEST(TransformOperationTest, BlendedBoundsForSequence) {
   1223   TransformOperations operations_from;
   1224   operations_from.AppendTranslate(2.0, 4.0, -1.0);
   1225   operations_from.AppendScale(-1.0, 2.0, 3.0);
   1226   operations_from.AppendTranslate(1.0, -5.0, 1.0);
   1227   TransformOperations operations_to;
   1228   operations_to.AppendTranslate(6.0, -2.0, 3.0);
   1229   operations_to.AppendScale(-3.0, -2.0, 5.0);
   1230   operations_to.AppendTranslate(13.0, -1.0, 5.0);
   1231 
   1232   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
   1233   gfx::BoxF bounds;
   1234 
   1235   SkMScalar min_progress = -0.5f;
   1236   SkMScalar max_progress = 1.5f;
   1237   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
   1238       box, operations_from, min_progress, max_progress, &bounds));
   1239   EXPECT_EQ(gfx::BoxF(-57.f, -59.f, -1.f, 76.f, 112.f, 80.f).ToString(),
   1240             bounds.ToString());
   1241 
   1242   min_progress = 0.f;
   1243   max_progress = 1.f;
   1244   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
   1245       box, operations_from, min_progress, max_progress, &bounds));
   1246   EXPECT_EQ(gfx::BoxF(-32.f, -25.f, 7.f, 42.f, 44.f, 48.f).ToString(),
   1247             bounds.ToString());
   1248 
   1249   TransformOperations identity;
   1250   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
   1251         box, identity, min_progress, max_progress, &bounds));
   1252   EXPECT_EQ(gfx::BoxF(-33.f, -13.f, 3.f, 57.f, 19.f, 52.f).ToString(),
   1253             bounds.ToString());
   1254 
   1255   EXPECT_TRUE(identity.BlendedBoundsForBox(
   1256         box, operations_from, min_progress, max_progress, &bounds));
   1257   EXPECT_EQ(gfx::BoxF(-7.f, -3.f, 2.f, 15.f, 23.f, 20.f).ToString(),
   1258             bounds.ToString());
   1259 }
   1260 
   1261 }  // namespace
   1262 }  // namespace cc
   1263