cc :: Move tracking of layer_property_changed to main thread (2)

This is a follow up to http://crrev.com/1688563002.
Properties moved in this CL are :
bounds, position, transform_origin

BUG=584512
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1697613002

Cr-Commit-Position: refs/heads/master@{#375768}

14 files changed, 169 insertions, 17 deletions

diff --git a/cc/layers/layer.cc b/cc/layers/layer.cc
index 50c138f..24eed8d 100644
--- a/cc/layers/layer.cc
+++ b/cc/layers/layer.cc
@@ -366,6 +366,8 @@ void Layer::SetBounds(const gfx::Size& size) {
   if (!layer_tree_host_)
     return;
 
+  if (masks_to_bounds())
+    SetSubtreePropertyChanged();
   SetNeedsCommit();
 }
 
@@ -636,6 +638,7 @@ void Layer::SetPosition(const gfx::PointF& position) {
   if (!layer_tree_host_)
     return;
 
+  SetSubtreePropertyChanged();
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
               transform_tree_index())) {
@@ -643,6 +646,7 @@ void Layer::SetPosition(const gfx::PointF& position) {
       transform_node->data.update_post_local_transform(position,
                                                        transform_origin());
       transform_node->data.needs_local_transform_update = true;
+      transform_node->data.transform_changed = true;
       layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
       SetNeedsCommitNoRebuild();
       return;
@@ -721,6 +725,7 @@ void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   if (!layer_tree_host_)
     return;
 
+  SetSubtreePropertyChanged();
   if (TransformNode* transform_node =
           layer_tree_host_->property_trees()->transform_tree.Node(
               transform_tree_index())) {
@@ -729,6 +734,7 @@ void Layer::SetTransformOrigin(const gfx::Point3F& transform_origin) {
       transform_node->data.update_post_local_transform(position(),
                                                        transform_origin);
       transform_node->data.needs_local_transform_update = true;
+      transform_node->data.transform_changed = true;
       layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
       SetNeedsCommitNoRebuild();
       return;
diff --git a/cc/layers/layer_impl.cc b/cc/layers/layer_impl.cc
index 0e4d326..a938515 100644
--- a/cc/layers/layer_impl.cc
+++ b/cc/layers/layer_impl.cc
@@ -693,6 +693,17 @@ void LayerImpl::SetStackingOrderChanged(bool stacking_order_changed) {
   }
 }
 
+bool LayerImpl::LayerPropertyChanged() const {
+  if (layer_property_changed_)
+    return true;
+  TransformNode* node =
+      layer_tree_impl()->property_trees()->transform_tree.Node(
+          transform_tree_index());
+  if (node && node->data.transform_changed)
+    return true;
+  return false;
+}
+
 void LayerImpl::NoteLayerPropertyChanged() {
   layer_property_changed_ = true;
   layer_tree_impl()->set_needs_update_draw_properties();
@@ -735,6 +746,11 @@ const char* LayerImpl::LayerTypeAsString() const {
 
 void LayerImpl::ResetAllChangeTrackingForSubtree() {
   layer_property_changed_ = false;
+  if (TransformNode* transform_node =
+          layer_tree_impl_->property_trees()->transform_tree.Node(
+              transform_tree_index())) {
+    transform_node->data.transform_changed = false;
+  }
 
   update_rect_.SetRect(0, 0, 0, 0);
   damage_rect_.SetRect(0, 0, 0, 0);
@@ -930,9 +946,7 @@ void LayerImpl::SetBounds(const gfx::Size& bounds) {
 
   layer_tree_impl()->DidUpdateScrollState(id());
 
-  if (masks_to_bounds())
-    NoteLayerPropertyChangedForSubtree();
-  else
+  if (!masks_to_bounds())
     NoteLayerPropertyChanged();
 }
 
@@ -1034,7 +1048,6 @@ void LayerImpl::SetTransformOrigin(const gfx::Point3F& transform_origin) {
   if (transform_origin_ == transform_origin)
     return;
   transform_origin_ = transform_origin;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetBackgroundColor(SkColor background_color) {
@@ -1211,7 +1224,6 @@ void LayerImpl::SetPosition(const gfx::PointF& position) {
     return;
 
   position_ = position;
-  NoteLayerPropertyChangedForSubtree();
 }
 
 void LayerImpl::SetShouldFlattenTransform(bool flatten) {
diff --git a/cc/layers/layer_impl.h b/cc/layers/layer_impl.h
index fb9195f..93dff96 100644
--- a/cc/layers/layer_impl.h
+++ b/cc/layers/layer_impl.h
@@ -573,7 +573,7 @@ class CC_EXPORT LayerImpl : public LayerAnimationValueObserver,
 
   void SetStackingOrderChanged(bool stacking_order_changed);
 
-  bool LayerPropertyChanged() const { return layer_property_changed_; }
+  bool LayerPropertyChanged() const;
 
   void ResetAllChangeTrackingForSubtree();
 
diff --git a/cc/layers/layer_impl_unittest.cc b/cc/layers/layer_impl_unittest.cc
index 5bde4a3..6813aea 100644
--- a/cc/layers/layer_impl_unittest.cc
+++ b/cc/layers/layer_impl_unittest.cc
@@ -161,11 +161,8 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
   // Changing these properties affects the entire subtree of layers.
-  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(
-      root->SetTransformOrigin(arbitrary_point_3f));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(arbitrary_filters));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetFilters(FilterOperations()));
-  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetPosition(arbitrary_point_f));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->ScrollBy(arbitrary_vector2d));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetScrollDelta(gfx::Vector2d()));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->PushScrollOffsetFromMainThread(
@@ -188,9 +185,6 @@ TEST(LayerImplTest, VerifyLayerChangesAreTrackedProperly) {
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
   root->SetMasksToBounds(true);
-  // Should be a different size than previous call, to ensure it marks tree
-  // changed.
-  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBounds(arbitrary_size));
   host_impl.active_tree()->property_trees()->needs_rebuild = true;
   host_impl.active_tree()->BuildPropertyTreesForTesting();
 
@@ -342,7 +336,8 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(
       layer->SetReplicaLayer(LayerImpl::Create(host_impl.active_tree(), 5));
       layer->NoteLayerPropertyChanged());
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer2->SetPosition(arbitrary_point_f));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer2->SetPosition(arbitrary_point_f);
+                                      layer->NoteLayerPropertyChanged());
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetShouldFlattenTransform(false);
                                       layer->NoteLayerPropertyChanged());
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->Set3dSortingContextId(1);
@@ -358,7 +353,8 @@ TEST(LayerImplTest, VerifyNeedsUpdateDrawProperties) {
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBlendMode(arbitrary_blend_mode);
                                       layer->NoteLayerPropertyChanged());
   VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetTransform(arbitrary_transform));
-  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size));
+  VERIFY_NEEDS_UPDATE_DRAW_PROPERTIES(layer->SetBounds(arbitrary_size);
+                                      layer->NoteLayerPropertyChanged());
 
   // Unrelated functions, set to the same values, no needs update.
   VERIFY_NO_NEEDS_UPDATE_DRAW_PROPERTIES(
diff --git a/cc/layers/layer_unittest.cc b/cc/layers/layer_unittest.cc
index f9904c0..1d76738 100644
--- a/cc/layers/layer_unittest.cc
+++ b/cc/layers/layer_unittest.cc
@@ -893,30 +893,39 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(AtLeast(1));
   scoped_refptr<Layer> root = Layer::Create(layer_settings_);
   scoped_refptr<Layer> child = Layer::Create(layer_settings_);
+  scoped_refptr<Layer> child2 = Layer::Create(layer_settings_);
   scoped_refptr<Layer> grand_child = Layer::Create(layer_settings_);
   scoped_refptr<Layer> dummy_layer1 = Layer::Create(layer_settings_);
   scoped_refptr<Layer> dummy_layer2 = Layer::Create(layer_settings_);
 
   layer_tree_host_->SetRootLayer(root);
   root->AddChild(child);
+  root->AddChild(child2);
   child->AddChild(grand_child);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
+  child->SetForceRenderSurface(true);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(AtLeast(1));
+  child2->SetScrollParent(grand_child.get());
   SkXfermode::Mode arbitrary_blend_mode = SkXfermode::kMultiply_Mode;
   scoped_ptr<LayerImpl> root_impl =
       LayerImpl::Create(host_impl_.active_tree(), 1);
   scoped_ptr<LayerImpl> child_impl =
       LayerImpl::Create(host_impl_.active_tree(), 2);
-  scoped_ptr<LayerImpl> grand_child_impl =
+  scoped_ptr<LayerImpl> child2_impl =
       LayerImpl::Create(host_impl_.active_tree(), 3);
-  scoped_ptr<LayerImpl> dummy_layer1_impl =
+  scoped_ptr<LayerImpl> grand_child_impl =
       LayerImpl::Create(host_impl_.active_tree(), 4);
-  scoped_ptr<LayerImpl> dummy_layer2_impl =
+  scoped_ptr<LayerImpl> dummy_layer1_impl =
       LayerImpl::Create(host_impl_.active_tree(), 5);
+  scoped_ptr<LayerImpl> dummy_layer2_impl =
+      LayerImpl::Create(host_impl_.active_tree(), 6);
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetMaskLayer(dummy_layer1.get()));
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get());
       dummy_layer1->PushPropertiesTo(dummy_layer1_impl.get()));
 
@@ -925,6 +934,7 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get()));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
@@ -932,6 +942,7 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get()));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsFullTreeSync()).Times(1);
@@ -939,6 +950,7 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get());
       dummy_layer2->PushPropertiesTo(dummy_layer2_impl.get()));
 
@@ -947,6 +959,7 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get()));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
@@ -954,6 +967,7 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get());
       dummy_layer2->PushPropertiesTo(dummy_layer2_impl.get()));
 
@@ -962,6 +976,7 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get()));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
@@ -969,10 +984,68 @@ TEST_F(LayerTest, LayerPropertyChangedForSubtree) {
   EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
       root->PushPropertiesTo(root_impl.get());
       child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
       grand_child->PushPropertiesTo(grand_child_impl.get()));
 
   EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
   EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBlendMode(arbitrary_blend_mode));
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
+      root->PushPropertiesTo(root_impl.get());
+      child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
+      grand_child->PushPropertiesTo(grand_child_impl.get()));
+
+  // Should be a different size than previous call, to ensure it marks tree
+  // changed.
+  gfx::Size arbitrary_size = gfx::Size(111, 222);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGED(root->SetBounds(arbitrary_size));
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
+      root->PushPropertiesTo(root_impl.get());
+      child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
+      grand_child->PushPropertiesTo(grand_child_impl.get()));
+
+  gfx::PointF arbitrary_point_f = gfx::PointF(0.125f, 0.25f);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  root->SetPosition(arbitrary_point_f);
+  TransformNode* node = layer_tree_host_->property_trees()->transform_tree.Node(
+      root->transform_tree_index());
+  EXPECT_TRUE(node->data.transform_changed);
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
+      root->PushPropertiesTo(root_impl.get());
+      child->PushPropertiesTo(child_impl.get());
+      child2->PushPropertiesTo(child2_impl.get());
+      grand_child->PushPropertiesTo(grand_child_impl.get());
+      layer_tree_host_->property_trees()->transform_tree.ResetChangeTracking());
+  EXPECT_FALSE(node->data.transform_changed);
+
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  child->SetPosition(arbitrary_point_f);
+  node = layer_tree_host_->property_trees()->transform_tree.Node(
+      child->transform_tree_index());
+  EXPECT_TRUE(node->data.transform_changed);
+  // child2 is not in the subtree of child, but its scroll parent is. So, its
+  // to_screen will be effected by change in position of child2.
+  layer_tree_host_->property_trees()->transform_tree.UpdateTransforms(
+      child2->transform_tree_index());
+  node = layer_tree_host_->property_trees()->transform_tree.Node(
+      child2->transform_tree_index());
+  EXPECT_TRUE(node->data.transform_changed);
+  EXECUTE_AND_VERIFY_SUBTREE_CHANGES_RESET(
+      child->PushPropertiesTo(child_impl.get());
+      grand_child->PushPropertiesTo(grand_child_impl.get());
+      layer_tree_host_->property_trees()->transform_tree.ResetChangeTracking());
+  node = layer_tree_host_->property_trees()->transform_tree.Node(
+      child->transform_tree_index());
+  EXPECT_FALSE(node->data.transform_changed);
+
+  gfx::Point3F arbitrary_point_3f = gfx::Point3F(0.125f, 0.25f, 0.f);
+  EXPECT_CALL(*layer_tree_host_, SetNeedsCommit()).Times(1);
+  root->SetTransformOrigin(arbitrary_point_3f);
+  node = layer_tree_host_->property_trees()->transform_tree.Node(
+      root->transform_tree_index());
+  EXPECT_TRUE(node->data.transform_changed);
 }
 
 TEST_F(LayerTest, AddAndRemoveChild) {
diff --git a/cc/layers/picture_layer_impl_unittest.cc b/cc/layers/picture_layer_impl_unittest.cc
index 9d1bbc9..1447442 100644
--- a/cc/layers/picture_layer_impl_unittest.cc
+++ b/cc/layers/picture_layer_impl_unittest.cc
@@ -3961,6 +3961,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // Full occlusion.
   layer1->SetPosition(gfx::PointF());
+  layer1->NoteLayerPropertyChanged();
 
   RebuildPropertyTreesOnPendingTree();
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
@@ -4068,6 +4069,7 @@ TEST_F(OcclusionTrackingPictureLayerImplTest,
 
   // Full occlusion.
   layer1->SetPosition(gfx::PointF());
+  layer1->NoteLayerPropertyChanged();
 
   RebuildPropertyTreesOnPendingTree();
   host_impl_.AdvanceToNextFrame(base::TimeDelta::FromMilliseconds(200));
diff --git a/cc/proto/property_tree.proto b/cc/proto/property_tree.proto
index 0f02d7e..7622d68 100644
--- a/cc/proto/property_tree.proto
+++ b/cc/proto/property_tree.proto
@@ -18,6 +18,7 @@ package cc.proto;
 // cc/trees/property_tree.h
 
 // Proto for struct TransformNodeData.
+// NEXT ID: 41
 message TranformNodeData {
   optional Transform pre_local = 1;
   optional Transform local = 2;
@@ -48,6 +49,7 @@ message TranformNodeData {
   optional bool affected_by_outer_viewport_bounds_delta_x = 26;
   optional bool affected_by_outer_viewport_bounds_delta_y = 27;
   optional bool in_subtree_of_page_scale_layer = 28;
+  optional bool transform_changed = 40;
   optional float post_local_scale_factor = 29;
   optional float local_maximum_animation_target_scale = 30;
   optional float local_starting_animation_scale = 31;
@@ -63,6 +65,7 @@ message TranformNodeData {
 }
 
 // Proto for struct ClipNodeData.
+// NEXT ID: 12
 message ClipNodeData {
   optional RectF clip = 1;
   optional RectF combined_clip_in_target_space = 2;
@@ -79,6 +82,7 @@ message ClipNodeData {
 }
 
 // Proto for struct EffectNodeData.
+// NEXT ID: 11
 message EffectNodeData {
   optional float opacity = 1;
   optional float screen_space_opacity = 2;
@@ -93,6 +97,7 @@ message EffectNodeData {
 }
 
 // Proto for struct ScrollNodeData
+// NEXT ID: 9
 message ScrollNodeData {
   optional bool scrollable = 1;
   optional int32 main_thread_scrolling_reasons = 2;
diff --git a/cc/trees/damage_tracker_unittest.cc b/cc/trees/damage_tracker_unittest.cc
index 5c86483a..d62b6cc 100644
--- a/cc/trees/damage_tracker_unittest.cc
+++ b/cc/trees/damage_tracker_unittest.cc
@@ -394,6 +394,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForPropertyChanges) {
   // Then, test the actual layer movement.
   ClearDamageForAllSurfaces(root.get());
   child->SetPosition(gfx::PointF(200.f, 230.f));
+  child->NoteLayerPropertyChanged();
   EmulateDrawingOneFrame(root.get());
 
   // Expect damage to be the combination of the previous one and the new one.
@@ -417,6 +418,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForTransformedLayer) {
   child->SetTransformOrigin(gfx::Point3F(
       child->bounds().width() * 0.5f, child->bounds().height() * 0.5f, 0.f));
   child->SetPosition(gfx::PointF(85.f, 85.f));
+  child->NoteLayerPropertyChanged();
   EmulateDrawingOneFrame(root.get());
 
   // Sanity check that the layer actually moved to (85, 85), damaging its old
@@ -905,11 +907,16 @@ TEST_F(DamageTrackerTest, VerifyDamageForSurfaceChangeFromAncestorLayer) {
 
   scoped_ptr<LayerImpl> root = CreateAndSetUpTestTreeWithTwoSurfaces();
   LayerImpl* child1 = root->children()[0].get();
+  LayerImpl* grand_child1 = child1->children()[0].get();
+  LayerImpl* grand_child2 = child1->children()[1].get();
   gfx::Rect child_damage_rect;
   gfx::Rect root_damage_rect;
 
   ClearDamageForAllSurfaces(root.get());
   child1->SetPosition(gfx::PointF(50.f, 50.f));
+  child1->NoteLayerPropertyChanged();
+  grand_child1->NoteLayerPropertyChanged();
+  grand_child2->NoteLayerPropertyChanged();
   EmulateDrawingOneFrame(root.get());
   child_damage_rect =
           child1->render_surface()->damage_tracker()->current_damage_rect();
@@ -1088,6 +1095,7 @@ TEST_F(DamageTrackerTest, VerifyDamageForReplica) {
   ClearDamageForAllSurfaces(root.get());
   gfx::Rect old_content_rect = child1->render_surface()->content_rect();
   grand_child1->SetPosition(gfx::PointF(195.f, 205.f));
+  grand_child1->NoteLayerPropertyChanged();
   EmulateDrawingOneFrame(root.get());
   ASSERT_EQ(old_content_rect.width(),
             child1->render_surface()->content_rect().width());
diff --git a/cc/trees/layer_tree_host.cc b/cc/trees/layer_tree_host.cc
index ce09a69..42a97ea 100644
--- a/cc/trees/layer_tree_host.cc
+++ b/cc/trees/layer_tree_host.cc
@@ -484,6 +484,7 @@ void LayerTreeHost::FinishCommitOnImplThread(LayerTreeHostImpl* host_impl) {
   sync_tree->UpdatePropertyTreeScrollingAndAnimationFromMainThread();
 
   micro_benchmark_controller_.ScheduleImplBenchmarks(host_impl);
+  property_trees_.transform_tree.ResetChangeTracking();
 }
 
 void LayerTreeHost::WillCommit() {
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 99f7781..1bcd37d 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -1705,6 +1705,10 @@ void LayerTreeHostImpl::DrawLayers(FrameData* frame) {
         DidDrawDamagedArea();
   }
   active_tree_->root_layer()->ResetAllChangeTrackingForSubtree();
+  active_tree_->root_layer()
+      ->layer_tree_impl()
+      ->property_trees()
+      ->transform_tree.ResetChangeTracking();
 
   active_tree_->set_has_ever_been_drawn(true);
   devtools_instrumentation::DidDrawFrame(id_);
@@ -1992,6 +1996,12 @@ void LayerTreeHostImpl::ActivateSyncTree() {
     TreeSynchronizer::PushProperties(pending_tree_->root_layer(),
                                      active_tree_->root_layer());
     pending_tree_->PushPropertiesTo(active_tree_.get());
+    if (pending_tree_->root_layer()) {
+      pending_tree_->root_layer()
+          ->layer_tree_impl()
+          ->property_trees()
+          ->transform_tree.ResetChangeTracking();
+    }
 
     // Now that we've synced everything from the pending tree to the active
     // tree, rename the pending tree the recycle tree so we can reuse it on the
diff --git a/cc/trees/layer_tree_host_impl_unittest.cc b/cc/trees/layer_tree_host_impl_unittest.cc
index bb65c02..756ad9a 100644
--- a/cc/trees/layer_tree_host_impl_unittest.cc
+++ b/cc/trees/layer_tree_host_impl_unittest.cc
@@ -3273,6 +3273,7 @@ TEST_F(LayerTreeHostImplTest, DidDrawNotCalledOnHiddenLayer) {
 
   // Ensure visible_layer_rect for layer is not empty
   layer->SetPosition(gfx::PointF());
+  layer->NoteLayerPropertyChanged();
 
   EXPECT_FALSE(layer->will_draw_called());
   EXPECT_FALSE(layer->did_draw_called());
@@ -6599,6 +6600,10 @@ TEST_F(LayerTreeHostImplTest, PartialSwapReceivesDamageRect) {
   // expected swap rect: vertically flipped, with origin at bottom left corner.
   layer_tree_host_impl->active_tree()->root_layer()->children()[0]->SetPosition(
       gfx::PointF());
+  layer_tree_host_impl->active_tree()
+      ->root_layer()
+      ->children()[0]
+      ->NoteLayerPropertyChanged();
   layer_tree_host_impl->active_tree()->property_trees()->needs_rebuild = true;
   layer_tree_host_impl->active_tree()->BuildPropertyTreesForTesting();
   EXPECT_EQ(DRAW_SUCCESS, layer_tree_host_impl->PrepareToDraw(&frame));
diff --git a/cc/trees/layer_tree_impl_unittest.cc b/cc/trees/layer_tree_impl_unittest.cc
index 32cfe45..bd8a810 100644
--- a/cc/trees/layer_tree_impl_unittest.cc
+++ b/cc/trees/layer_tree_impl_unittest.cc
@@ -2017,6 +2017,7 @@ TEST_F(LayerTreeImplTest, HitTestingTouchHandlerRegionsForLayerThatIsNotDrawn) {
   // inside the test_layer.
   test_layer = host_impl().active_tree()->root_layer()->children()[0].get();
   test_layer->SetPosition(gfx::PointF(10.f, 10.f));
+  test_layer->NoteLayerPropertyChanged();
   expected_screen_space_transform.MakeIdentity();
   expected_screen_space_transform.Translate(10.f, 10.f);
 
diff --git a/cc/trees/property_tree.cc b/cc/trees/property_tree.cc
index a22961c..579c4ee 100644
--- a/cc/trees/property_tree.cc
+++ b/cc/trees/property_tree.cc
@@ -145,6 +145,7 @@ TransformNodeData::TransformNodeData()
       affected_by_outer_viewport_bounds_delta_x(false),
       affected_by_outer_viewport_bounds_delta_y(false),
       in_subtree_of_page_scale_layer(false),
+      transform_changed(false),
       post_local_scale_factor(1.0f),
       local_maximum_animation_target_scale(0.f),
       local_starting_animation_scale(0.f),
@@ -187,6 +188,7 @@ bool TransformNodeData::operator==(const TransformNodeData& other) const {
              other.affected_by_outer_viewport_bounds_delta_y &&
          in_subtree_of_page_scale_layer ==
              other.in_subtree_of_page_scale_layer &&
+         transform_changed == other.transform_changed &&
          post_local_scale_factor == other.post_local_scale_factor &&
          local_maximum_animation_target_scale ==
              other.local_maximum_animation_target_scale &&
@@ -270,6 +272,7 @@ void TransformNodeData::ToProtobuf(proto::TreeNode* proto) const {
       affected_by_outer_viewport_bounds_delta_y);
 
   data->set_in_subtree_of_page_scale_layer(in_subtree_of_page_scale_layer);
+  data->set_transform_changed(transform_changed);
   data->set_post_local_scale_factor(post_local_scale_factor);
   data->set_local_maximum_animation_target_scale(
       local_maximum_animation_target_scale);
@@ -335,6 +338,7 @@ void TransformNodeData::FromProtobuf(const proto::TreeNode& proto) {
       data.affected_by_outer_viewport_bounds_delta_y();
 
   in_subtree_of_page_scale_layer = data.in_subtree_of_page_scale_layer();
+  transform_changed = data.transform_changed();
   post_local_scale_factor = data.post_local_scale_factor();
   local_maximum_animation_target_scale =
       data.local_maximum_animation_target_scale();
@@ -608,10 +612,18 @@ bool TransformTree::NeedsSourceToParentUpdate(TransformNode* node) {
           node->parent_id != node->data.source_node_id);
 }
 
+void TransformTree::ResetChangeTracking() {
+  for (int id = 1; id < static_cast<int>(size()); ++id) {
+    TransformNode* node = Node(id);
+    node->data.transform_changed = false;
+  }
+}
+
 void TransformTree::UpdateTransforms(int id) {
   TransformNode* node = Node(id);
   TransformNode* parent_node = parent(node);
   TransformNode* target_node = Node(node->data.target_id);
+  TransformNode* source_node = Node(node->data.source_node_id);
   if (node->data.needs_local_transform_update ||
       NeedsSourceToParentUpdate(node))
     UpdateLocalTransform(node);
@@ -623,6 +635,7 @@ void TransformTree::UpdateTransforms(int id) {
   UpdateAnimationProperties(node, parent_node);
   UpdateSnapping(node);
   UpdateNodeAndAncestorsHaveIntegerTranslations(node, parent_node);
+  UpdateTransformChanged(node, parent_node, source_node);
 }
 
 bool TransformTree::IsDescendant(int desc_id, int source_id) const {
@@ -982,6 +995,19 @@ void TransformTree::UpdateSnapping(TransformNode* node) {
   node->data.scroll_snap = translation;
 }
 
+void TransformTree::UpdateTransformChanged(TransformNode* node,
+                                           TransformNode* parent_node,
+                                           TransformNode* source_node) {
+  if (parent_node && parent_node->data.transform_changed) {
+    node->data.transform_changed = true;
+    return;
+  }
+
+  if (source_node && source_node->id != parent_node->id &&
+      source_to_parent_updates_allowed_ && source_node->data.transform_changed)
+    node->data.transform_changed = true;
+}
+
 void TransformTree::SetDeviceTransform(const gfx::Transform& transform,
                                        gfx::PointF root_position) {
   gfx::Transform root_post_local = transform;
diff --git a/cc/trees/property_tree.h b/cc/trees/property_tree.h
index 5265bc6..26182d7 100644
--- a/cc/trees/property_tree.h
+++ b/cc/trees/property_tree.h
@@ -135,6 +135,9 @@ struct CC_EXPORT TransformNodeData {
   // layer scale factor should include the page scale factor.
   bool in_subtree_of_page_scale_layer : 1;
 
+  // We need to track changes to to_screen transform to compute the damage rect.
+  bool transform_changed : 1;
+
   // TODO(vollick): will be moved when accelerated effects are implemented.
   float post_local_scale_factor;
 
@@ -388,6 +391,7 @@ class CC_EXPORT TransformTree final : public PropertyTree<TransformNode> {
   // aligned with respect to one another.
   bool Are2DAxisAligned(int source_id, int dest_id) const;
 
+  void ResetChangeTracking();
   // Updates the parent, target, and screen space transforms and snapping.
   void UpdateTransforms(int id);
 
@@ -477,6 +481,9 @@ class CC_EXPORT TransformTree final : public PropertyTree<TransformNode> {
                                  TransformNode* parent_node);
   void UndoSnapping(TransformNode* node);
   void UpdateSnapping(TransformNode* node);
+  void UpdateTransformChanged(TransformNode* node,
+                              TransformNode* parent_node,
+                              TransformNode* source_node);
   void UpdateNodeAndAncestorsHaveIntegerTranslations(
       TransformNode* node,
       TransformNode* parent_node);