cc/animation/transform_operations_unittest.cc

   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/geometry/box_f.h"
  14 #include "ui/gfx/geometry/rect_conversions.h"
  15 #include "ui/gfx/geometry/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 TEST(TransformOperationTest, BlendedBoundsForRotationProblematicAxes) {
 931   // Zeros in the components of the axis of rotation turned out to be tricky to
 932   // deal with in practice. This function tests some potentially problematic
 933   // axes to ensure sane behavior.
 934
 935   // Some common values used in the expected boxes.
 936   float dim1 = 0.292893f;
 937   float dim2 = sqrt(2.f);
 938   float dim3 = 2.f * dim2;
 939
 940   struct {
 941     float x;
 942     float y;
 943     float z;
 944     gfx::BoxF expected;
 945   } tests[] = {{0.f, 0.f, 0.f, gfx::BoxF(1.f, 1.f, 1.f, 0.f, 0.f, 0.f)},
 946                {1.f, 0.f, 0.f, gfx::BoxF(1.f, -dim2, -dim2, 0.f, dim3, dim3)},
 947                {0.f, 1.f, 0.f, gfx::BoxF(-dim2, 1.f, -dim2, dim3, 0.f, dim3)},
 948                {0.f, 0.f, 1.f, gfx::BoxF(-dim2, -dim2, 1.f, dim3, dim3, 0.f)},
 949                {1.f, 1.f, 0.f, gfx::BoxF(dim1, dim1, -1.f, dim2, dim2, 2.f)},
 950                {0.f, 1.f, 1.f, gfx::BoxF(-1.f, dim1, dim1, 2.f, dim2, dim2)},
 951                {1.f, 0.f, 1.f, gfx::BoxF(dim1, -1.f, dim1, dim2, 2.f, dim2)}};
 952
 953   for (size_t i = 0; i < arraysize(tests); ++i) {
 954     float x = tests[i].x;
 955     float y = tests[i].y;
 956     float z = tests[i].z;
 957     TransformOperations operations_from;
 958     operations_from.AppendRotate(x, y, z, 0.f);
 959     TransformOperations operations_to;
 960     operations_to.AppendRotate(x, y, z, 360.f);
 961     gfx::BoxF box(1.f, 1.f, 1.f, 0.f, 0.f, 0.f);
 962     gfx::BoxF bounds;
 963
 964     EXPECT_TRUE(operations_to.BlendedBoundsForBox(
 965         box, operations_from, 0.f, 1.f, &bounds));
 966     EXPECT_EQ(tests[i].expected.ToString(), bounds.ToString());
 967   }
 968 }
 969
 970 static void ExpectBoxesApproximatelyEqual(const gfx::BoxF& lhs,
 971                                           const gfx::BoxF& rhs,
 972                                           float tolerance) {
 973   EXPECT_NEAR(lhs.x(), rhs.x(), tolerance);
 974   EXPECT_NEAR(lhs.y(), rhs.y(), tolerance);
 975   EXPECT_NEAR(lhs.z(), rhs.z(), tolerance);
 976   EXPECT_NEAR(lhs.width(), rhs.width(), tolerance);
 977   EXPECT_NEAR(lhs.height(), rhs.height(), tolerance);
 978   EXPECT_NEAR(lhs.depth(), rhs.depth(), tolerance);
 979 }
 980
 981 static void EmpiricallyTestBounds(const TransformOperations& from,
 982                                   const TransformOperations& to,
 983                                   SkMScalar min_progress,
 984                                   SkMScalar max_progress,
 985                                   bool test_containment_only) {
 986   gfx::BoxF box(200.f, 500.f, 100.f, 100.f, 300.f, 200.f);
 987   gfx::BoxF bounds;
 988   EXPECT_TRUE(
 989       to.BlendedBoundsForBox(box, from, min_progress, max_progress, &bounds));
 990
 991   bool first_time = true;
 992   gfx::BoxF empirical_bounds;
 993   static const size_t kNumSteps = 10;
 994   for (size_t step = 0; step < kNumSteps; ++step) {
 995     float t = step / (kNumSteps - 1.f);
 996     t = gfx::Tween::FloatValueBetween(t, min_progress, max_progress);
 997     gfx::Transform partial_transform = to.Blend(from, t);
 998     gfx::BoxF transformed = box;
 999     partial_transform.TransformBox(&transformed);
1000
1001     if (first_time) {
1002       empirical_bounds = transformed;
1003       first_time = false;
1004     } else {
1005       empirical_bounds.Union(transformed);
1006     }
1007   }
1008
1009   if (test_containment_only) {
1010     gfx::BoxF unified_bounds = bounds;
1011     unified_bounds.Union(empirical_bounds);
1012     // Convert to the screen space rects these boxes represent.
1013     gfx::Rect bounds_rect = ToEnclosingRect(
1014         gfx::RectF(bounds.x(), bounds.y(), bounds.width(), bounds.height()));
1015     gfx::Rect unified_bounds_rect =
1016         ToEnclosingRect(gfx::RectF(unified_bounds.x(),
1017                                    unified_bounds.y(),
1018                                    unified_bounds.width(),
1019                                    unified_bounds.height()));
1020     EXPECT_EQ(bounds_rect.ToString(), unified_bounds_rect.ToString());
1021   } else {
1022     // Our empirical estimate will be a little rough since we're only doing
1023     // 100 samples.
1024     static const float kTolerance = 1e-2f;
1025     ExpectBoxesApproximatelyEqual(empirical_bounds, bounds, kTolerance);
1026   }
1027 }
1028
1029 static void EmpiricallyTestBoundsEquality(const TransformOperations& from,
1030                                           const TransformOperations& to,
1031                                           SkMScalar min_progress,
1032                                           SkMScalar max_progress) {
1033   EmpiricallyTestBounds(from, to, min_progress, max_progress, false);
1034 }
1035
1036 static void EmpiricallyTestBoundsContainment(const TransformOperations& from,
1037                                              const TransformOperations& to,
1038                                              SkMScalar min_progress,
1039                                              SkMScalar max_progress) {
1040   EmpiricallyTestBounds(from, to, min_progress, max_progress, true);
1041 }
1042
1043 TEST(TransformOperationTest, BlendedBoundsForRotationEmpiricalTests) {
1044   // Sets up various axis angle combinations, computes the bounding box and
1045   // empirically tests that the transformed bounds are indeed contained by the
1046   // computed bounding box.
1047
1048   struct {
1049     float x;
1050     float y;
1051     float z;
1052   } axes[] = {{1.f, 1.f, 1.f},
1053               {-1.f, -1.f, -1.f},
1054               {-1.f, 2.f, 3.f},
1055               {1.f, -2.f, 3.f},
1056               {1.f, 2.f, -3.f},
1057               {0.f, 0.f, 0.f},
1058               {1.f, 0.f, 0.f},
1059               {0.f, 1.f, 0.f},
1060               {0.f, 0.f, 1.f},
1061               {1.f, 1.f, 0.f},
1062               {0.f, 1.f, 1.f},
1063               {1.f, 0.f, 1.f},
1064               {-1.f, 0.f, 0.f},
1065               {0.f, -1.f, 0.f},
1066               {0.f, 0.f, -1.f},
1067               {-1.f, -1.f, 0.f},
1068               {0.f, -1.f, -1.f},
1069               {-1.f, 0.f, -1.f}};
1070
1071   struct {
1072     float theta_from;
1073     float theta_to;
1074   } angles[] = {{5.f, 10.f},
1075                 {10.f, 5.f},
1076                 {0.f, 360.f},
1077                 {20.f, 180.f},
1078                 {-20.f, -180.f},
1079                 {180.f, -220.f},
1080                 {220.f, 320.f}};
1081
1082   // We can go beyond the range [0, 1] (the bezier might slide out of this range
1083   // at either end), but since the first and last knots are at (0, 0) and (1, 1)
1084   // we will never go within it, so these tests are sufficient.
1085   struct {
1086     float min_progress;
1087     float max_progress;
1088   } progress[] = {
1089         {0.f, 1.f}, {-.25f, 1.25f},
1090     };
1091
1092   for (size_t i = 0; i < arraysize(axes); ++i) {
1093     for (size_t j = 0; j < arraysize(angles); ++j) {
1094       for (size_t k = 0; k < arraysize(progress); ++k) {
1095         float x = axes[i].x;
1096         float y = axes[i].y;
1097         float z = axes[i].z;
1098         TransformOperations operations_from;
1099         operations_from.AppendRotate(x, y, z, angles[j].theta_from);
1100         TransformOperations operations_to;
1101         operations_to.AppendRotate(x, y, z, angles[j].theta_to);
1102         EmpiricallyTestBoundsContainment(operations_from,
1103                                          operations_to,
1104                                          progress[k].min_progress,
1105                                          progress[k].max_progress);
1106       }
1107     }
1108   }
1109 }
1110
1111 TEST(TransformOperationTest, PerspectiveMatrixAndTransformBlendingEquivalency) {
1112     TransformOperations from_operations;
1113     from_operations.AppendPerspective(200);
1114
1115     TransformOperations to_operations;
1116     to_operations.AppendPerspective(1000);
1117
1118     gfx::Transform from_transform;
1119     from_transform.ApplyPerspectiveDepth(200);
1120
1121     gfx::Transform to_transform;
1122     to_transform.ApplyPerspectiveDepth(1000);
1123
1124     static const int steps = 20;
1125     for (int i = 0; i < steps; ++i) {
1126       double progress = static_cast<double>(i) / (steps - 1);
1127
1128       gfx::Transform blended_matrix = to_transform;
1129       EXPECT_TRUE(blended_matrix.Blend(from_transform, progress));
1130
1131       gfx::Transform blended_transform =
1132           to_operations.Blend(from_operations, progress);
1133
1134       EXPECT_TRANSFORMATION_MATRIX_EQ(blended_matrix, blended_transform);
1135     }
1136 }
1137
1138 TEST(TransformOperationTest, BlendedBoundsForPerspective) {
1139   struct {
1140     float from_depth;
1141     float to_depth;
1142   } perspective_depths[] = {
1143         {600.f, 400.f},
1144         {800.f, 1000.f},
1145         {800.f, std::numeric_limits<float>::infinity()},
1146     };
1147
1148   struct {
1149     float min_progress;
1150     float max_progress;
1151   } progress[] = {
1152         {0.f, 1.f}, {-0.1f, 1.1f},
1153     };
1154
1155   for (size_t i = 0; i < arraysize(perspective_depths); ++i) {
1156     for (size_t j = 0; j < arraysize(progress); ++j) {
1157       TransformOperations operations_from;
1158       operations_from.AppendPerspective(perspective_depths[i].from_depth);
1159       TransformOperations operations_to;
1160       operations_to.AppendPerspective(perspective_depths[i].to_depth);
1161       EmpiricallyTestBoundsEquality(operations_from,
1162                                     operations_to,
1163                                     progress[j].min_progress,
1164                                     progress[j].max_progress);
1165     }
1166   }
1167 }
1168
1169 TEST(TransformOperationTest, BlendedBoundsForSkew) {
1170   struct {
1171     float from_x;
1172     float from_y;
1173     float to_x;
1174     float to_y;
1175   } skews[] = {
1176         {1.f, 0.5f, 0.5f, 1.f}, {2.f, 1.f, 0.5f, 0.5f},
1177     };
1178
1179   struct {
1180     float min_progress;
1181     float max_progress;
1182   } progress[] = {
1183         {0.f, 1.f}, {-0.1f, 1.1f},
1184     };
1185
1186   for (size_t i = 0; i < arraysize(skews); ++i) {
1187     for (size_t j = 0; j < arraysize(progress); ++j) {
1188       TransformOperations operations_from;
1189       operations_from.AppendSkew(skews[i].from_x, skews[i].from_y);
1190       TransformOperations operations_to;
1191       operations_to.AppendSkew(skews[i].to_x, skews[i].to_y);
1192       EmpiricallyTestBoundsEquality(operations_from,
1193                                     operations_to,
1194                                     progress[j].min_progress,
1195                                     progress[j].max_progress);
1196     }
1197   }
1198 }
1199
1200 TEST(TransformOperationTest, NonCommutativeRotations) {
1201   TransformOperations operations_from;
1202   operations_from.AppendRotate(1.0, 0.0, 0.0, 0.0);
1203   operations_from.AppendRotate(0.0, 1.0, 0.0, 0.0);
1204   TransformOperations operations_to;
1205   operations_to.AppendRotate(1.0, 0.0, 0.0, 45.0);
1206   operations_to.AppendRotate(0.0, 1.0, 0.0, 135.0);
1207
1208   gfx::BoxF box(0, 0, 0, 1, 1, 1);
1209   gfx::BoxF bounds;
1210
1211   SkMScalar min_progress = 0.0f;
1212   SkMScalar max_progress = 1.0f;
1213   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1214       box, operations_from, min_progress, max_progress, &bounds));
1215   gfx::Transform blended_transform =
1216       operations_to.Blend(operations_from, max_progress);
1217   gfx::Point3F blended_point(0.9f, 0.9f, 0.0f);
1218   blended_transform.TransformPoint(&blended_point);
1219   gfx::BoxF expanded_bounds = bounds;
1220   expanded_bounds.ExpandTo(blended_point);
1221   EXPECT_EQ(bounds.ToString(), expanded_bounds.ToString());
1222 }
1223
1224 TEST(TransformOperationTest, BlendedBoundsForSequence) {
1225   TransformOperations operations_from;
1226   operations_from.AppendTranslate(1.0, -5.0, 1.0);
1227   operations_from.AppendScale(-1.0, 2.0, 3.0);
1228   operations_from.AppendTranslate(2.0, 4.0, -1.0);
1229   TransformOperations operations_to;
1230   operations_to.AppendTranslate(13.0, -1.0, 5.0);
1231   operations_to.AppendScale(-3.0, -2.0, 5.0);
1232   operations_to.AppendTranslate(6.0, -2.0, 3.0);
1233
1234   gfx::BoxF box(1.f, 2.f, 3.f, 4.f, 4.f, 4.f);
1235   gfx::BoxF bounds;
1236
1237   SkMScalar min_progress = -0.5f;
1238   SkMScalar max_progress = 1.5f;
1239   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1240       box, operations_from, min_progress, max_progress, &bounds));
1241   EXPECT_EQ(gfx::BoxF(-57.f, -59.f, -1.f, 76.f, 112.f, 80.f).ToString(),
1242             bounds.ToString());
1243
1244   min_progress = 0.f;
1245   max_progress = 1.f;
1246   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1247       box, operations_from, min_progress, max_progress, &bounds));
1248   EXPECT_EQ(gfx::BoxF(-32.f, -25.f, 7.f, 42.f, 44.f, 48.f).ToString(),
1249             bounds.ToString());
1250
1251   TransformOperations identity;
1252   EXPECT_TRUE(operations_to.BlendedBoundsForBox(
1253         box, identity, min_progress, max_progress, &bounds));
1254   EXPECT_EQ(gfx::BoxF(-33.f, -13.f, 3.f, 57.f, 19.f, 52.f).ToString(),
1255             bounds.ToString());
1256
1257   EXPECT_TRUE(identity.BlendedBoundsForBox(
1258         box, operations_from, min_progress, max_progress, &bounds));
1259   EXPECT_EQ(gfx::BoxF(-7.f, -3.f, 2.f, 15.f, 23.f, 20.f).ToString(),
1260             bounds.ToString());
1261 }
1262
1263 TEST(TransformOperationTest, AffectsScaleWithSingleOperation) {
1264   TransformOperations empty_operations;
1265   EXPECT_FALSE(empty_operations.AffectsScale());
1266
1267   TransformOperations identity;
1268   identity.AppendIdentity();
1269   EXPECT_FALSE(identity.AffectsScale());
1270
1271   TransformOperations translate;
1272   translate.AppendTranslate(1.f, 2.f, 3.f);
1273   EXPECT_FALSE(translate.AffectsScale());
1274
1275   TransformOperations rotate;
1276   rotate.AppendRotate(1.f, 2.f, 3.f, 4.f);
1277   EXPECT_FALSE(rotate.AffectsScale());
1278
1279   TransformOperations scale;
1280   scale.AppendScale(1.f, 2.f, 3.f);
1281   EXPECT_TRUE(scale.AffectsScale());
1282
1283   TransformOperations skew;
1284   skew.AppendSkew(1.f, 2.f);
1285   EXPECT_FALSE(skew.AffectsScale());
1286
1287   TransformOperations perspective;
1288   perspective.AppendPerspective(1.f);
1289   EXPECT_FALSE(perspective.AffectsScale());
1290
1291   TransformOperations identity_matrix;
1292   identity_matrix.AppendMatrix(gfx::Transform());
1293   EXPECT_FALSE(identity_matrix.AffectsScale());
1294
1295   TransformOperations translation_matrix;
1296   gfx::Transform translation_transform;
1297   translation_transform.Translate3d(1.f, 2.f, 3.f);
1298   translation_matrix.AppendMatrix(translation_transform);
1299   EXPECT_FALSE(translation_matrix.AffectsScale());
1300
1301   TransformOperations scaling_matrix;
1302   gfx::Transform scaling_transform;
1303   scaling_transform.Scale(2.f, 2.f);
1304   scaling_matrix.AppendMatrix(scaling_transform);
1305   EXPECT_TRUE(scaling_matrix.AffectsScale());
1306 }
1307
1308 TEST(TransformOperationTest, AffectsScaleWithMultipleOperations) {
1309   TransformOperations operations1;
1310   operations1.AppendSkew(1.f, 2.f);
1311   operations1.AppendTranslate(1.f, 2.f, 3.f);
1312   operations1.AppendIdentity();
1313   EXPECT_FALSE(operations1.AffectsScale());
1314
1315   TransformOperations operations2;
1316   operations2.AppendPerspective(2.f);
1317   operations2.AppendScale(1.f, 2.f, 3.f);
1318   operations2.AppendTranslate(3.f, 2.f, 1.f);
1319   EXPECT_TRUE(operations2.AffectsScale());
1320 }
1321
1322 TEST(TransformOperationTest, IsTranslationWithSingleOperation) {
1323   TransformOperations empty_operations;
1324   EXPECT_TRUE(empty_operations.IsTranslation());
1325
1326   TransformOperations identity;
1327   identity.AppendIdentity();
1328   EXPECT_TRUE(identity.IsTranslation());
1329
1330   TransformOperations translate;
1331   translate.AppendTranslate(1.f, 2.f, 3.f);
1332   EXPECT_TRUE(translate.IsTranslation());
1333
1334   TransformOperations rotate;
1335   rotate.AppendRotate(1.f, 2.f, 3.f, 4.f);
1336   EXPECT_FALSE(rotate.IsTranslation());
1337
1338   TransformOperations scale;
1339   scale.AppendScale(1.f, 2.f, 3.f);
1340   EXPECT_FALSE(scale.IsTranslation());
1341
1342   TransformOperations skew;
1343   skew.AppendSkew(1.f, 2.f);
1344   EXPECT_FALSE(skew.IsTranslation());
1345
1346   TransformOperations perspective;
1347   perspective.AppendPerspective(1.f);
1348   EXPECT_FALSE(perspective.IsTranslation());
1349
1350   TransformOperations identity_matrix;
1351   identity_matrix.AppendMatrix(gfx::Transform());
1352   EXPECT_TRUE(identity_matrix.IsTranslation());
1353
1354   TransformOperations translation_matrix;
1355   gfx::Transform translation_transform;
1356   translation_transform.Translate3d(1.f, 2.f, 3.f);
1357   translation_matrix.AppendMatrix(translation_transform);
1358   EXPECT_TRUE(translation_matrix.IsTranslation());
1359
1360   TransformOperations scaling_matrix;
1361   gfx::Transform scaling_transform;
1362   scaling_transform.Scale(2.f, 2.f);
1363   scaling_matrix.AppendMatrix(scaling_transform);
1364   EXPECT_FALSE(scaling_matrix.IsTranslation());
1365 }
1366
1367 TEST(TransformOperationTest, IsTranslationWithMultipleOperations) {
1368   TransformOperations operations1;
1369   operations1.AppendSkew(1.f, 2.f);
1370   operations1.AppendTranslate(1.f, 2.f, 3.f);
1371   operations1.AppendIdentity();
1372   EXPECT_FALSE(operations1.IsTranslation());
1373
1374   TransformOperations operations2;
1375   operations2.AppendIdentity();
1376   operations2.AppendTranslate(3.f, 2.f, 1.f);
1377   gfx::Transform translation_transform;
1378   translation_transform.Translate3d(1.f, 2.f, 3.f);
1379   operations2.AppendMatrix(translation_transform);
1380   EXPECT_TRUE(operations2.IsTranslation());
1381 }
1382
1383 TEST(TransformOperationTest, ScaleComponent) {
1384   gfx::Vector3dF scale;
1385
1386   // Scale.
1387   TransformOperations operations1;
1388   operations1.AppendScale(-3.f, 2.f, 5.f);
1389   EXPECT_TRUE(operations1.ScaleComponent(&scale));
1390   EXPECT_EQ(gfx::Vector3dF(-3.f, 2.f, 5.f), scale);
1391
1392   // Translate + Scale.
1393   TransformOperations operations5;
1394   operations5.AppendTranslate(1.f, 2.f, 3.f);
1395   operations5.AppendScale(2.f, 5.f, 4.f);
1396   EXPECT_TRUE(operations5.ScaleComponent(&scale));
1397   EXPECT_EQ(gfx::Vector3dF(2.f, 5.f, 4.f), scale);
1398
1399   // Translate + Scale + Matrix with translate.
1400   gfx::Transform translation_transform;
1401   translation_transform.Translate3d(1.f, 2.f, 3.f);
1402   operations5.AppendMatrix(translation_transform);
1403   EXPECT_TRUE(operations5.ScaleComponent(&scale));
1404   EXPECT_EQ(gfx::Vector3dF(2.f, 5.f, 4.f), scale);
1405 }
1406
1407 TEST(TransformOperationTest, ScaleComponentCannotBeComputed) {
1408   gfx::Vector3dF scale;
1409
1410   // Scale can.
1411   TransformOperations operations1;
1412   operations1.AppendScale(2.f, 2.f, 2.f);
1413   EXPECT_TRUE(operations1.ScaleComponent(&scale));
1414   EXPECT_EQ(gfx::Vector3dF(2.f, 2.f, 2.f), scale);
1415
1416   // Translate can.
1417   TransformOperations operations2;
1418   operations2.AppendTranslate(1.f, 2.f, 3.f);
1419   EXPECT_TRUE(operations2.ScaleComponent(&scale));
1420   EXPECT_EQ(gfx::Vector3dF(1.f, 1.f, 1.f), scale);
1421
1422   // Scale + translate can.
1423   TransformOperations operations3;
1424   operations3.AppendScale(2.f, 3.f, 2.f);
1425   operations3.AppendTranslate(1.f, 2.f, 3.f);
1426   EXPECT_TRUE(operations3.ScaleComponent(&scale));
1427   EXPECT_EQ(gfx::Vector3dF(2.f, 3.f, 2.f), scale);
1428
1429   // Two Scales can't.
1430   TransformOperations operations4;
1431   operations4.AppendScale(2.f, 3.f, 2.f);
1432   operations4.AppendScale(3.f, 2.f, 3.f);
1433   EXPECT_FALSE(operations4.ScaleComponent(&scale));
1434
1435   // Matrix can't.
1436   TransformOperations operations5;
1437   operations5.AppendScale(2.f, 2.f, 2.f);
1438   gfx::Transform scaling_transform;
1439   scaling_transform.Scale(2.f, 2.f);
1440   operations5.AppendMatrix(scaling_transform);
1441   EXPECT_FALSE(operations5.ScaleComponent(&scale));
1442
1443   // Scale + Rotate can't.
1444   TransformOperations operations7;
1445   operations7.AppendScale(2.f, 2.f, 2.f);
1446   operations7.AppendRotate(1.f, 2.f, 3.f, 4.f);
1447   EXPECT_FALSE(operations7.ScaleComponent(&scale));
1448
1449   // Scale + Skew can't.
1450   TransformOperations operations9;
1451   operations9.AppendScale(2.f, 2.f, 2.f);
1452   operations9.AppendSkew(1.f, 2.f);
1453   EXPECT_FALSE(operations9.ScaleComponent(&scale));
1454
1455   // Scale + Perspective can't.
1456   TransformOperations operations11;
1457   operations11.AppendScale(2.f, 2.f, 2.f);
1458   operations11.AppendPerspective(1.f);
1459   EXPECT_FALSE(operations11.ScaleComponent(&scale));
1460 }
1461
1462 }  // namespace
1463 }  // namespace cc