cc: Compute SurfacePropertyChanged without depending on owning layer

cc/trees/damage_tracker_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/damage_tracker.h"
 
 #include <stddef.h>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer_impl.h"
@@ skipping 396 matching lines @@
   // not because of the old damage state.
   ClearDamageForAllSurfaces(root);
   root->layer_tree_impl()->property_trees()->needs_rebuild = true;
   EmulateDrawingOneFrame(root);
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_TRUE(root_damage_rect.IsEmpty());
 
   // Then, test the actual layer movement.
   ClearDamageForAllSurfaces(root);
-  child->SetPosition(gfx::PointF(200.f, 230.f));
-  child->NoteLayerPropertyChanged();
-  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  gfx::Transform translation;
+  translation.Translate(100.f, 130.f);
+  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
+      translation, child->transform_tree_index(), root->layer_tree_impl());

[ajuma, 2016/09/23 14:10:58]

The layer's original position is (100, 100). Moving it to (200, 230) by
animating its transform rather than by resetting its position means we don't
need to rebuild property trees. The changes to the two tests below are similar.

   EmulateDrawingOneFrame(root);
 
   // Expect damage to be the combination of the previous one and the new one.
   expected_rect.Union(gfx::Rect(200, 230, 30, 30));
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
   EXPECT_FLOAT_RECT_EQ(expected_rect, root_damage_rect);
 }
 
 TEST_F(DamageTrackerTest, VerifyDamageWhenSurfaceRemoved) {
@@ skipping 637 matching lines @@
   // the entire child1 surface, but the damage tracker still needs the correct
   // logic to compute the exposed region on the root surface.
 
   // TODO(shawnsingh): the expectations of this test case should change when we
   // add support for a unique scissor_rect per RenderSurface. In that case, the
   // child1 surface should be completely unchanged, since we are only
   // transforming it, while the root surface would be damaged appropriately.
 
   LayerImpl* root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->test_properties()->children[0];
-  LayerImpl* grand_child1 = child1->test_properties()->children[0];
-  LayerImpl* grand_child2 = child1->test_properties()->children[1];
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   ClearDamageForAllSurfaces(root);
-  child1->SetPosition(gfx::PointF(50.f, 50.f));
-  child1->NoteLayerPropertyChanged();
-  grand_child1->NoteLayerPropertyChanged();
-  grand_child2->NoteLayerPropertyChanged();
-  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  gfx::Transform translation;
+  translation.Translate(-50.f, -50.f);
+  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
+      translation, child1->transform_tree_index(), root->layer_tree_impl());
   EmulateDrawingOneFrame(root);
   child_damage_rect =
           child1->render_surface()->damage_tracker()->current_damage_rect();
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
 
   // The new surface bounds should be damaged entirely.
   EXPECT_EQ(gfx::Rect(190, 190, 16, 18).ToString(),
             child_damage_rect.ToString());
 
@@ skipping 167 matching lines @@
   // child surface damage should include the normal and replica surfaces.
   EXPECT_EQ(gfx::Rect(6, 8).ToString(), grand_child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(194, 200, 12, 8).ToString(),
             child_damage_rect.ToString());
   EXPECT_EQ(gfx::Rect(294, 300, 12, 8).ToString(), root_damage_rect.ToString());
 
   // CASE 2: moving the descendant surface should cause both the original and
   //         reflected areas to be damaged on the target.
   ClearDamageForAllSurfaces(root);
   gfx::Rect old_content_rect = child1->render_surface()->content_rect();
-  grand_child1->SetPosition(gfx::PointF(195.f, 205.f));
-  grand_child1->NoteLayerPropertyChanged();
-  root->layer_tree_impl()->property_trees()->needs_rebuild = true;
+  gfx::Transform translation;
+  translation.Translate(-5.f, 5.f);
+  root->layer_tree_impl()->property_trees()->transform_tree.OnTransformAnimated(
+      translation, grand_child1->transform_tree_index(),
+      root->layer_tree_impl());
+  grand_child1->test_properties()->transform = translation;
   EmulateDrawingOneFrame(root);
   ASSERT_EQ(old_content_rect.width(),
             child1->render_surface()->content_rect().width());
   ASSERT_EQ(old_content_rect.height(),
             child1->render_surface()->content_rect().height());
-
   grand_child_damage_rect =
           grand_child1->render_surface()->
               damage_tracker()->current_damage_rect();
   child_damage_rect =
           child1->render_surface()->damage_tracker()->current_damage_rect();
   root_damage_rect =
           root->render_surface()->damage_tracker()->current_damage_rect();
 
   // The child surface damage should include normal and replica surfaces for
   // both old and new locations.
@@ skipping 364 matching lines @@
 }
 
 TEST_F(DamageTrackerTest, HugeDamageRect) {
   // This number is so large that we start losting floating point accuracy.
   const int kBigNumber = 900000000;
   // Walk over a range to find floating point inaccuracy boundaries that move
   // toward the wrong direction.
   const int kRange = 5000;
 
   for (int i = 0; i < kRange; ++i) {
-    LayerImpl* root = CreateTestTreeWithOneSurface();
+    LayerImpl* root = CreateAndSetUpTestTreeWithOneSurface();
     LayerImpl* child = root->test_properties()->children[0];
 
     gfx::Transform transform;
     transform.Translate(-kBigNumber, -kBigNumber);
 
     // The child layer covers (0, 0, i, i) of the viewport,
     // but has a huge negative position.
     child->SetPosition(gfx::PointF());
     child->SetBounds(gfx::Size(kBigNumber + i, kBigNumber + i));
     child->test_properties()->transform = transform;
@@ skipping 11 matching lines @@
     gfx::Rect root_damage_rect =
         root->render_surface()->damage_tracker()->current_damage_rect();
     gfx::Rect damage_we_care_about = gfx::Rect(i, i);
     EXPECT_LE(damage_we_care_about.right(), root_damage_rect.right());
     EXPECT_LE(damage_we_care_about.bottom(), root_damage_rect.bottom());
   }
 }
 
 }  // namespace
 }  // namespace cc