cc/trees/property_tree_unittest.cc

   1 // Copyright 2014 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 "cc/trees/property_tree.h"
   6
   7 #include "cc/test/geometry_test_utils.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 namespace cc {
  11
  12 TEST(PropertyTreeTest, ComputeTransformRoot) {
  13   TransformTree tree;
  14   TransformNode& root = *tree.Node(0);
  15   root.data.local.Translate(2, 2);
  16   root.data.target_id = 0;
  17   tree.UpdateTransforms(0);
  18
  19   gfx::Transform expected;
  20   gfx::Transform transform;
  21   bool success = tree.ComputeTransform(0, 0, &transform);
  22   EXPECT_TRUE(success);
  23   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
  24
  25   transform.MakeIdentity();
  26   expected.Translate(2, 2);
  27   success = tree.ComputeTransform(0, -1, &transform);
  28   EXPECT_TRUE(success);
  29   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
  30
  31   transform.MakeIdentity();
  32   expected.MakeIdentity();
  33   expected.Translate(-2, -2);
  34   success = tree.ComputeTransform(-1, 0, &transform);
  35   EXPECT_TRUE(success);
  36   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
  37 }
  38
  39 TEST(PropertyTreeTest, ComputeTransformChild) {
  40   TransformTree tree;
  41   TransformNode& root = *tree.Node(0);
  42   root.data.local.Translate(2, 2);
  43   root.data.target_id = 0;
  44   tree.UpdateTransforms(0);
  45
  46   TransformNode child;
  47   child.data.local.Translate(3, 3);
  48   child.data.target_id = 0;
  49
  50   tree.Insert(child, 0);
  51   tree.UpdateTransforms(1);
  52
  53   gfx::Transform expected;
  54   gfx::Transform transform;
  55
  56   expected.Translate(3, 3);
  57   bool success = tree.ComputeTransform(1, 0, &transform);
  58   EXPECT_TRUE(success);
  59   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
  60
  61   transform.MakeIdentity();
  62   expected.MakeIdentity();
  63   expected.Translate(-3, -3);
  64   success = tree.ComputeTransform(0, 1, &transform);
  65   EXPECT_TRUE(success);
  66   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
  67
  68   transform.MakeIdentity();
  69   expected.MakeIdentity();
  70   expected.Translate(5, 5);
  71   success = tree.ComputeTransform(1, -1, &transform);
  72   EXPECT_TRUE(success);
  73   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
  74
  75   transform.MakeIdentity();
  76   expected.MakeIdentity();
  77   expected.Translate(-5, -5);
  78   success = tree.ComputeTransform(-1, 1, &transform);
  79   EXPECT_TRUE(success);
  80   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
  81 }
  82
  83 TEST(PropertyTreeTest, ComputeTransformSibling) {
  84   TransformTree tree;
  85   TransformNode& root = *tree.Node(0);
  86   root.data.local.Translate(2, 2);
  87   root.data.target_id = 0;
  88   tree.UpdateTransforms(0);
  89
  90   TransformNode child;
  91   child.data.local.Translate(3, 3);
  92   child.data.target_id = 0;
  93
  94   TransformNode sibling;
  95   sibling.data.local.Translate(7, 7);
  96   sibling.data.target_id = 0;
  97
  98   tree.Insert(child, 0);
  99   tree.Insert(sibling, 0);
 100
 101   tree.UpdateTransforms(1);
 102   tree.UpdateTransforms(2);
 103
 104   gfx::Transform expected;
 105   gfx::Transform transform;
 106
 107   expected.Translate(4, 4);
 108   bool success = tree.ComputeTransform(2, 1, &transform);
 109   EXPECT_TRUE(success);
 110   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 111
 112   transform.MakeIdentity();
 113   expected.MakeIdentity();
 114   expected.Translate(-4, -4);
 115   success = tree.ComputeTransform(1, 2, &transform);
 116   EXPECT_TRUE(success);
 117   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 118 }
 119
 120 TEST(PropertyTreeTest, ComputeTransformSiblingSingularAncestor) {
 121   // In this test, we have the following tree:
 122   // root
 123   //   + singular
 124   //     + child
 125   //     + sibling
 126   // Now singular has a singular transform, so we cannot use screen space
 127   // transforms to compute change of basis transforms between |child| and
 128   // |sibling|.
 129   TransformTree tree;
 130   TransformNode& root = *tree.Node(0);
 131   root.data.local.Translate(2, 2);
 132   root.data.target_id = 0;
 133   tree.UpdateTransforms(0);
 134
 135   TransformNode singular;
 136   singular.data.local.matrix().set(2, 2, 0.0);
 137   singular.data.target_id = 0;
 138
 139   TransformNode child;
 140   child.data.local.Translate(3, 3);
 141   child.data.target_id = 0;
 142
 143   TransformNode sibling;
 144   sibling.data.local.Translate(7, 7);
 145   sibling.data.target_id = 0;
 146
 147   tree.Insert(singular, 0);
 148   tree.Insert(child, 1);
 149   tree.Insert(sibling, 1);
 150
 151   tree.UpdateTransforms(1);
 152   tree.UpdateTransforms(2);
 153   tree.UpdateTransforms(3);
 154
 155   gfx::Transform expected;
 156   gfx::Transform transform;
 157
 158   expected.Translate(4, 4);
 159   bool success = tree.ComputeTransform(3, 2, &transform);
 160   EXPECT_TRUE(success);
 161   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 162
 163   transform.MakeIdentity();
 164   expected.MakeIdentity();
 165   expected.Translate(-4, -4);
 166   success = tree.ComputeTransform(2, 3, &transform);
 167   EXPECT_TRUE(success);
 168   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 169 }
 170
 171 TEST(PropertyTreeTest, MultiplicationOrder) {
 172   TransformTree tree;
 173   TransformNode& root = *tree.Node(0);
 174   root.data.local.Translate(2, 2);
 175   root.data.target_id = 0;
 176   tree.UpdateTransforms(0);
 177
 178   TransformNode child;
 179   child.data.local.Scale(2, 2);
 180   child.data.target_id = 0;
 181
 182   tree.Insert(child, 0);
 183   tree.UpdateTransforms(1);
 184
 185   gfx::Transform expected;
 186   expected.Translate(2, 2);
 187   expected.Scale(2, 2);
 188
 189   gfx::Transform transform;
 190   gfx::Transform inverse;
 191
 192   bool success = tree.ComputeTransform(1, -1, &transform);
 193   EXPECT_TRUE(success);
 194   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 195
 196   success = tree.ComputeTransform(-1, 1, &inverse);
 197   EXPECT_TRUE(success);
 198
 199   transform = transform * inverse;
 200   expected.MakeIdentity();
 201   EXPECT_TRANSFORMATION_MATRIX_EQ(expected, transform);
 202 }
 203
 204 }  // namespace cc