cc : Use effect id to decide if surface contents scale should be applied

cc/trees/draw_property_utils.cc

 // Copyright 2014 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/draw_property_utils.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 40 matching lines @@
   DCHECK_EQ(effect_node->mask_layer_id, -1) << "layer: " << layer->id();
   DCHECK_EQ(effect_node->replica_layer_id, -1) << "layer: " << layer->id();
   DCHECK(effect_node->filters.IsEmpty());
   DCHECK(effect_node->background_filters.IsEmpty());
 }
 
 void VerifySurfaceContentsScalesMatch(const int target_effect_id,
                                       const int target_transform_id,
                                       const EffectTree& effect_tree,
                                       const TransformTree& transform_tree) {
+  if (target_effect_id == -1) {
+    // This can happen when PaintArtifactCompositor builds property trees as it
+    // doesn't set effect ids on clip nodes.
+    return;
+  }
   const TransformNode* target_transform_node =
       transform_tree.Node(target_transform_id);
   const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
   DCHECK(target_transform_node->surface_contents_scale ==
          target_effect_node->surface_contents_scale)
       << " surface contents scale from transform tree: "
       << target_transform_node->surface_contents_scale.ToString()
       << " surface contents scale from effect tree: "
       << target_effect_node->surface_contents_scale.ToString();
 }
@@ skipping 22 matching lines @@
       ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
   gfx::Transform clip_to_target;
   if (clip_node->target_transform_id > target_node_id) {
     // In this case, layer has a scroll parent. We need to keep the scale
     // at the layer's target but remove the scale at the scroll parent's
     // target.
     if (property_trees->ComputeTransformToTarget(clip_node->target_transform_id,
                                                  target_effect_node->id,
                                                  &clip_to_target)) {
       // We don't have to apply surface contents scale when target is root.
-      if (target_node_id != 0) {
+      if (target_effect_node->id != 1) {
         PostConcatSurfaceContentsScale(target_effect_node, &clip_to_target);
 #if DCHECK_IS_ON()
         const TransformTree& transform_tree = property_trees->transform_tree;
         VerifySurfaceContentsScalesMatch(layer->effect_tree_index(),
                                          target_node_id, effect_tree,
                                          transform_tree);
 #endif
       }
 
       const EffectNode* source_node =
@@ skipping 58 matching lines @@
     const PropertyTrees* property_trees,
     int current_transform_id,
     int target_transform_id,
     int target_effect_id) {
   gfx::Transform current_to_target;
   if (!property_trees->ComputeTransformToTarget(
           current_transform_id, target_effect_id, &current_to_target))
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
   // We don't have to apply surface contents scale when target is root.
-  if (target_transform_id != 0) {
+  if (target_effect_id != 1) {
     const EffectTree& effect_tree = property_trees->effect_tree;
     const EffectNode* target_effect_node = effect_tree.Node(target_effect_id);
     PostConcatSurfaceContentsScale(target_effect_node, &current_to_target);
 #if DCHECK_IS_ON()
     const TransformTree& transform_tree = property_trees->transform_tree;
     VerifySurfaceContentsScalesMatch(target_effect_id, target_transform_id,
                                      effect_tree, transform_tree);
 #endif
   }
 
@@ skipping 321 matching lines @@
     } else {
       bool success = transform_tree.ComputeTransform(
           target_node_id, transform_node->id, &target_to_layer);
       if (!success) {
         // An animated singular transform may become non-singular during the
         // animation, so we still need to compute a visible rect. In this
         // situation, we treat the entire layer as visible.
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
-      if (target_node_id != 0) {
-        const EffectNode* target_effect_node =
-            ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
+      const EffectNode* target_effect_node =
+          ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
+      if (target_effect_node->id != 1) {
         ConcatInverseSurfaceContentsScale(target_effect_node, &target_to_layer);
 #if DCHECK_IS_ON()
         VerifySurfaceContentsScalesMatch(target_effect_node->id, target_node_id,
                                          effect_tree, transform_tree);
 #endif
       }
     }
     gfx::Transform target_to_content;
     target_to_content.Translate(-layer->offset_to_transform_parent().x(),
                                 -layer->offset_to_transform_parent().y());
@@ skipping 188 matching lines @@
 }
 
 static void ResetIfHasNanCoordinate(gfx::RectF* rect) {
   if (std::isnan(rect->x()) || std::isnan(rect->y()) ||
       std::isnan(rect->right()) || std::isnan(rect->bottom()))
     *rect = gfx::RectF();
 }
 
 void PostConcatSurfaceContentsScale(const EffectNode* effect_node,
                                     gfx::Transform* transform) {
+  if (!effect_node) {
+    // This can happen when PaintArtifactCompositor builds property trees as it
+    // doesn't set effect ids on clip nodes.
+    return;
+  }
   DCHECK(effect_node->has_render_surface);
   transform->matrix().postScale(effect_node->surface_contents_scale.x(),
                                 effect_node->surface_contents_scale.y(), 1.f);
 }
 
 void ConcatInverseSurfaceContentsScale(const EffectNode* effect_node,
                                        gfx::Transform* transform) {
   DCHECK(effect_node->has_render_surface);
   if (effect_node->surface_contents_scale.x() != 0.0 &&
       effect_node->surface_contents_scale.y() != 0.0)
@@ skipping 40 matching lines @@
         parent_clip_node->combined_clip_in_target_space;
     gfx::RectF parent_clip_in_target_space =
         parent_clip_node->clip_in_target_space;
     if (parent_target_transform_node &&
         parent_target_transform_node->id != clip_node->target_transform_id &&
         non_root_surfaces_enabled) {
       success &= property_trees->ComputeTransformToTarget(
           parent_target_transform_node->id, clip_node->target_effect_id,
           &parent_to_current);
       // We don't have to apply surface contents scale when target is root.
-      if (clip_node->target_transform_id != 0) {
+      if (clip_node->target_effect_id != 1) {
         const EffectNode* target_effect_node =
             effect_tree.Node(clip_node->target_effect_id);
         PostConcatSurfaceContentsScale(target_effect_node, &parent_to_current);
 #if DCHECK_IS_ON()
         VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
                                          clip_node->target_transform_id,
                                          effect_tree, transform_tree);
 #endif
       }
-      if (parent_clip_node->target_transform_id != 0) {
+      if (parent_clip_node->target_effect_id != 1) {
         const EffectNode* parent_target_effect_node =
             effect_tree.Node(parent_clip_node->target_effect_id);
         ConcatInverseSurfaceContentsScale(parent_target_effect_node,
                                           &parent_to_current);
 #if DCHECK_IS_ON()
         VerifySurfaceContentsScalesMatch(parent_clip_node->target_effect_id,
                                          parent_clip_node->target_transform_id,
                                          effect_tree, transform_tree);
 #endif
       }
@@ skipping 49 matching lines @@
 
       if (!non_root_surfaces_enabled) {
         source_to_target = transform_tree.ToScreen(clip_node->transform_id);
       } else if (transform_tree.ContentTargetId(transform_node->id) ==
                  clip_node->target_transform_id) {
         source_to_target = transform_tree.ToTarget(clip_node->transform_id);
       } else {
         success = property_trees->ComputeTransformToTarget(
             transform_node->id, clip_node->target_effect_id, &source_to_target);
         // We don't have to apply surface contents scale when target is root.
-        if (clip_node->target_transform_id != 0) {
+        if (clip_node->target_effect_id != 1) {
           const EffectNode* target_effect_node =
               effect_tree.Node(clip_node->target_effect_id);
           PostConcatSurfaceContentsScale(target_effect_node, &source_to_target);
 #if DCHECK_IS_ON()
           VerifySurfaceContentsScalesMatch(clip_node->target_effect_id,
                                            clip_node->target_transform_id,
                                            effect_tree, transform_tree);
 #endif
         }
         // source_to_target computation should be successful as target is an
@@ skipping 140 matching lines @@
                                       PropertyTrees* property_trees) {
   const int source_id = layer->transform_tree_index();
   int destination_id = FindTargetTransformTreeIndexFromEffectTree(
       property_trees->effect_tree, layer->effect_tree_index());
   const EffectNode* target_effect_node = ContentsTargetEffectNode(
       layer->effect_tree_index(), property_trees->effect_tree);
   gfx::Transform draw_transform;
   property_trees->ComputeTransformToTarget(source_id, target_effect_node->id,
                                            &draw_transform);
   // We don't have to apply surface contents scale when target is root.
-  if (destination_id != 0) {
+  if (target_effect_node->id != 1) {
     PostConcatSurfaceContentsScale(target_effect_node, &draw_transform);
 #if DCHECK_IS_ON()
     VerifySurfaceContentsScalesMatch(layer->effect_tree_index(), destination_id,
                                      property_trees->effect_tree,
                                      property_trees->transform_tree);
 #endif
   }
   if (layer->should_flatten_transform_from_property_tree())
     draw_transform.FlattenTo2d();
   draw_transform.Translate(layer->offset_to_transform_parent().x(),
@@ skipping 173 matching lines @@
       transform_tree.Node(render_surface->TransformTreeIndex());
   const EffectNode* effect_node =
       effect_tree.Node(render_surface->EffectTreeIndex());
   // The draw transform of root render surface is identity tranform.
   if (transform_node->id == 1) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   gfx::Transform render_surface_transform;
-  const TransformNode* target_transform_node =
-      transform_tree.Node(transform_tree.TargetId(transform_node->id));
   const EffectNode* target_effect_node =
       effect_tree.Node(effect_node->target_id);
   property_trees->ComputeTransformToTarget(
       transform_node->id, target_effect_node->id, &render_surface_transform);
   // We don't have to apply surface contents scale when target is root.
-  if (target_transform_node->id != 0) {
+  if (effect_node->target_id != 1) {
     PostConcatSurfaceContentsScale(target_effect_node,
                                    &render_surface_transform);
 #if DCHECK_IS_ON()
+    const TransformNode* target_transform_node =
+        transform_tree.Node(transform_tree.TargetId(transform_node->id));
     VerifySurfaceContentsScalesMatch(effect_node->target_id,
                                      target_transform_node->id, effect_tree,
                                      transform_tree);
 #endif
   }
 
   ConcatInverseSurfaceContentsScale(effect_node, &render_surface_transform);
 #if DCHECK_IS_ON()
   VerifySurfaceContentsScalesMatch(effect_node->id, transform_node->id,
                                    effect_tree, transform_tree);
@@ skipping 38 matching lines @@
   const bool success = property_trees->ComputeTransformToTarget(
       parent_clip_node->target_transform_id, target_effect_id,
       &clip_parent_target_to_target);
 
   if (!success) {
     render_surface->SetClipRect(gfx::Rect());
     return;
   }
 
   // We don't have to apply surface contents scale when target is root.
-  if (transform_tree.TargetId(transform_node->id) != 0) {
+  if (render_surface->EffectTreeIndex() != 1) {
     const EffectNode* effect_node =
         effect_tree.Node(render_surface->EffectTreeIndex());
     PostConcatSurfaceContentsScale(effect_node, &clip_parent_target_to_target);
 #if DCHECK_IS_ON()
     VerifySurfaceContentsScalesMatch(
         render_surface->EffectTreeIndex(),
         transform_tree.TargetId(transform_node->id), effect_tree,
         transform_tree);
 #endif
   }
@@ skipping 70 matching lines @@
 static gfx::Transform ReplicaToSurfaceTransform(
     const RenderSurfaceImpl* render_surface,
     const PropertyTrees* property_trees) {
   gfx::Transform replica_to_surface;
   if (!render_surface->HasReplica())
     return replica_to_surface;
   const LayerImpl* replica_layer = render_surface->ReplicaLayer();
   const EffectTree& effect_tree = property_trees->effect_tree;
   const EffectNode* surface_effect_node =
       effect_tree.Node(render_surface->EffectTreeIndex());
-  if (render_surface->TransformTreeIndex() != 0) {
+  if (render_surface->EffectTreeIndex() != 1) {
     replica_to_surface.Scale(surface_effect_node->surface_contents_scale.x(),
                              surface_effect_node->surface_contents_scale.y());
 #if DCHECK_IS_ON()
     const TransformTree& transform_tree = property_trees->transform_tree;
     VerifySurfaceContentsScalesMatch(render_surface->EffectTreeIndex(),
                                      render_surface->TransformTreeIndex(),
                                      effect_tree, transform_tree);
 #endif
   }
   replica_to_surface.Translate(replica_layer->offset_to_transform_parent().x(),
@@ skipping 182 matching lines @@
 void UpdateElasticOverscroll(PropertyTrees* property_trees,
                              const Layer* overscroll_elasticity_layer,
                              const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInternal(property_trees, overscroll_elasticity_layer,
                                   elastic_overscroll);
 }
 
 }  // namespace draw_property_utils
 
 }  // namespace cc