1 files changed, 33 insertions, 13 deletions

diff --git a/chromium/cc/trees/property_tree.cc b/chromium/cc/trees/property_tree.cc
index cbdb9d43e73..00ce2f2e65d 100644
--- a/chromium/cc/trees/property_tree.cc
+++ b/chromium/cc/trees/property_tree.cc
@@ -493,24 +493,27 @@ void TransformTree::UpdateSnapping(TransformNode* node) {
   // rounded, then what we're after is the scroll delta X, where ST * X = ST'.
   // I.e., we want a transform that will realize our snap. It follows that
   // X = ST^-1 * ST'. We cache ST and ST^-1 to make this more efficient.
-  gfx::Transform rounded = ToScreen(node->id);
-  rounded.RoundTranslationComponents();
-  gfx::Transform delta = FromScreen(node->id);
-  delta *= rounded;
-
-  DCHECK(delta.IsApproximatelyIdentityOrTranslation(SkDoubleToScalar(1e-4)))
+  DCHECK_LT(node->id, static_cast<int>(cached_data_.size()));
+  gfx::Transform& to_screen = cached_data_[node->id].to_screen;
+  to_screen.RoundTranslationComponents();
+  gfx::Transform& from_screen = cached_data_[node->id].from_screen;
+  gfx::Transform delta = from_screen;
+  delta *= to_screen;
+
+  constexpr float kTolerance = 1e-4f;
+  DCHECK(delta.IsApproximatelyIdentityOrTranslation(kTolerance))
       << delta.ToString();
 
   gfx::Vector2dF translation = delta.To2dTranslation();
+  node->snap_amount = translation;
+  if (translation.IsZero())
+    return;
 
-  // Now that we have our delta, we must apply it to each of our combined,
-  // to/from matrices.
-  SetToScreen(node->id, rounded);
-  node->to_parent.Translate(translation.x(), translation.y());
-  gfx::Transform from_screen = FromScreen(node->id);
   from_screen.matrix().postTranslate(-translation.x(), -translation.y(), 0);
-  SetFromScreen(node->id, from_screen);
-  node->snap_amount = translation;
+  node->to_parent.Translate(translation.x(), translation.y());
+  // Avoid accumulation of errors in to_parent.
+  if (node->to_parent.IsApproximatelyIdentityOrIntegerTranslation(kTolerance))
+    node->to_parent.RoundTranslationComponents();
 }
 
 void TransformTree::UpdateTransformChanged(TransformNode* node,
@@ -745,6 +748,17 @@ void EffectTree::UpdateHasMaskingChild(EffectNode* node,
   }
 }
 
+void EffectTree::UpdateOnlyDrawsVisibleContent(EffectNode* node,
+                                               EffectNode* parent_node) {
+  node->only_draws_visible_content = !node->has_copy_request;
+  if (parent_node)
+    node->only_draws_visible_content &= parent_node->only_draws_visible_content;
+  if (!node->backdrop_filters.IsEmpty()) {
+    node->only_draws_visible_content &=
+        !node->backdrop_filters.HasFilterOfType(FilterOperation::ZOOM);
+  }
+}
+
 void EffectTree::UpdateSurfaceContentsScale(EffectNode* effect_node) {
   if (!effect_node->HasRenderSurface()) {
     effect_node->surface_contents_scale = gfx::Vector2dF(1.0f, 1.0f);
@@ -829,6 +843,7 @@ void EffectTree::UpdateEffects(int id) {
   UpdateEffectChanged(node, parent_node);
   UpdateBackfaceVisibility(node, parent_node);
   UpdateHasMaskingChild(node, parent_node);
+  UpdateOnlyDrawsVisibleContent(node, parent_node);
   UpdateSurfaceContentsScale(node);
 }
 
@@ -1273,6 +1288,8 @@ void ScrollTree::OnScrollOffsetAnimated(ElementId id,
   if (!property_trees()->is_active)
     return;
 
+  TRACE_EVENT2("cc", "ScrollTree::OnScrollOffsetAnimated", "x",
+               scroll_offset.x(), "y", scroll_offset.y());
   ScrollNode* scroll_node = Node(scroll_tree_index);
   if (SetScrollOffset(id,
                       ClampScrollOffsetToLimits(scroll_offset, *scroll_node)))
@@ -1570,6 +1587,9 @@ void ScrollTree::SetBaseScrollOffset(ElementId id,
 
 bool ScrollTree::SetScrollOffset(ElementId id,
                                  const gfx::ScrollOffset& scroll_offset) {
+  // TODO(crbug.com/1087088): Remove TRACE_EVENT call when the bug is fixed
+  TRACE_EVENT2("cc", "ScrollTree::SetScrollOffset", "x", scroll_offset.x(), "y",
+               scroll_offset.y());
   if (property_trees()->is_main_thread) {
     if (scroll_offset_map_[id] == scroll_offset)
       return false;