cc: Use sublayer scale from effect tree (1)

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 38 matching lines @@
           layer->effect_tree_index());
   if (effect_node->owner_id != layer->id())
     return;
   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->background_filters.IsEmpty());
 }
 
 #endif
 
-static void AddSublayerScaleToTransform(const int effect_node_id,
-                                        const EffectTree& effect_tree,
-                                        gfx::Transform* transform) {
+static void ApplySublayerScale(const int effect_node_id,
+                               const EffectTree& effect_tree,
+                               gfx::Transform* transform) {
   const EffectNode* effect_node = effect_tree.Node(effect_node_id);
   const EffectNode* target_effect_node =
       effect_node->has_render_surface
           ? effect_node
           : effect_tree.Node(effect_node->target_id);
   transform->matrix().postScale(target_effect_node->sublayer_scale.x(),
                                 target_effect_node->sublayer_scale.y(), 1.f);
 }
 
 #if DCHECK_IS_ON()
@@ skipping 18 matching lines @@
 #endif
 
 template <typename LayerType>
 bool ComputeClipRectInTargetSpace(const LayerType* layer,
                                   const ClipNode* clip_node,
                                   const TransformTree& transform_tree,
                                   const EffectTree& effect_tree,
                                   int target_node_id,
                                   gfx::RectF* clip_rect_in_target_space) {
   DCHECK(layer->clip_tree_index() == clip_node->id);
-  DCHECK(clip_node->target_id != target_node_id);
+  DCHECK(clip_node->target_transform_id != target_node_id);
 
   gfx::Transform clip_to_target;
-  if (clip_node->target_id > target_node_id) {
+  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 (transform_tree.ComputeTransform(clip_node->target_id, target_node_id,
-                                        &clip_to_target)) {
+    if (transform_tree.ComputeTransform(clip_node->target_transform_id,
+                                        target_node_id, &clip_to_target)) {
       // We don't have to apply sublayer scale when target is root.
       if (target_node_id != 0) {
-        AddSublayerScaleToTransform(layer->effect_tree_index(), effect_tree,
-                                    &clip_to_target);
+        ApplySublayerScale(layer->effect_tree_index(), effect_tree,
+                           &clip_to_target);
 #if DCHECK_IS_ON()
         VerifySublayerScalesMatch(layer->effect_tree_index(), target_node_id,
                                   effect_tree, transform_tree);
 #endif
       }
 
       const TransformNode* source_node =
-          transform_tree.Node(clip_node->target_id);
+          transform_tree.Node(clip_node->target_transform_id);
       if (source_node->sublayer_scale.x() != 0.f &&
           source_node->sublayer_scale.y() != 0.f)
         clip_to_target.Scale(1.0f / source_node->sublayer_scale.x(),
                              1.0f / source_node->sublayer_scale.y());
       *clip_rect_in_target_space = MathUtil::MapClippedRect(
           clip_to_target, clip_node->clip_in_target_space);
     } else {
       return false;
     }
   } else {
-    if (transform_tree.ComputeTransform(clip_node->target_id, target_node_id,
-                                        &clip_to_target)) {
+    if (transform_tree.ComputeTransform(clip_node->target_transform_id,
+                                        target_node_id, &clip_to_target)) {
       *clip_rect_in_target_space = MathUtil::ProjectClippedRect(
           clip_to_target, clip_node->clip_in_target_space);
     } else {
       return false;
     }
   }
   return true;
 }
 
 struct ConditionalClip {
@@ skipping 16 matching lines @@
     return ConditionalClip{true,  // is_clipped.
                            MathUtil::MapClippedRect(current_to_target, rect)};
 
   return ConditionalClip{true,  // is_clipped.
                          MathUtil::ProjectClippedRect(current_to_target, rect)};
 }
 
 static ConditionalClip ComputeLocalRectInTargetSpace(
     gfx::RectF rect,
     const TransformTree& transform_tree,
+    const EffectTree& effect_tree,
     int current_transform_id,
-    int target_transform_id) {
+    int target_transform_id,
+    int target_effect_id) {
   gfx::Transform current_to_target;
-  if (!transform_tree.ComputeTransformWithDestinationSublayerScale(
-          current_transform_id, target_transform_id, &current_to_target))
+  if (!transform_tree.ComputeTransform(current_transform_id,
+                                       target_transform_id, &current_to_target))
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
+  // We don't have to apply sublayer scale when target is root.
+  if (target_transform_id != 0) {
+    ApplySublayerScale(target_effect_id, effect_tree, &current_to_target);
+#if DCHECK_IS_ON()
+    VerifySublayerScalesMatch(target_effect_id, target_transform_id,
+                              effect_tree, transform_tree);
+#endif
+  }
 
   if (current_transform_id > target_transform_id)
     return ConditionalClip{true,  // is_clipped.
                            MathUtil::MapClippedRect(current_to_target, rect)};
 
   return ConditionalClip{true,  // is_clipped.
                          MathUtil::ProjectClippedRect(current_to_target, rect)};
 }
 
 static ConditionalClip ComputeCurrentClip(const ClipNode* clip_node,
                                           const TransformTree& transform_tree,
-                                          int target_transform_id) {
+                                          const EffectTree& effect_tree,
+                                          int target_transform_id,
+                                          int target_effect_id) {
   if (clip_node->transform_id != target_transform_id)
     return ComputeLocalRectInTargetSpace(clip_node->clip, transform_tree,
-                                         clip_node->transform_id,
-                                         target_transform_id);
+                                         effect_tree, clip_node->transform_id,
+                                         target_transform_id, target_effect_id);
 
   gfx::RectF current_clip = clip_node->clip;
   gfx::Vector2dF sublayer_scale =
       transform_tree.Node(target_transform_id)->sublayer_scale;
   if (sublayer_scale.x() > 0 && sublayer_scale.y() > 0)
     current_clip.Scale(sublayer_scale.x(), sublayer_scale.y());
   return ConditionalClip{true /* is_clipped */, current_clip};
 }
 
 static ConditionalClip ComputeAccumulatedClip(
@@ skipping 37 matching lines @@
   // to check applies_local_clip.
   while (!clip_node->applies_local_clip && parent_chain.size() > 0) {
     clip_node = parent_chain.top();
     parent_chain.pop();
   }
 
   if (!clip_node->applies_local_clip)
     // No clip node applying clip in between.
     return ConditionalClip{false, gfx::RectF()};
 
-  ConditionalClip current_clip =
-      ComputeCurrentClip(clip_node, transform_tree, target_transform_id);
+  ConditionalClip current_clip = ComputeCurrentClip(
+      clip_node, transform_tree, effect_tree, target_transform_id, target_id);
   is_clipped = current_clip.is_clipped;
   gfx::RectF accumulated_clip = current_clip.clip_rect;
 
   while (parent_chain.size() > 0) {
     clip_node = parent_chain.top();
     parent_chain.pop();
     if (!clip_node->applies_local_clip) {
       continue;
     }
-    ConditionalClip current_clip =
-        ComputeCurrentClip(clip_node, transform_tree, target_transform_id);
+    ConditionalClip current_clip = ComputeCurrentClip(
+        clip_node, transform_tree, effect_tree, target_transform_id, target_id);
 
     // If transform is not invertible, no clip will be applied.
     if (!current_clip.is_clipped)
       return ConditionalClip{false, gfx::RectF()};
 
     is_clipped = true;
     accumulated_clip =
         gfx::IntersectRects(accumulated_clip, current_clip.clip_rect);
   }
 
@@ skipping 24 matching lines @@
     if (!fully_visible) {
       const TransformNode* transform_node =
           transform_tree.Node(layer->transform_tree_index());
       int target_node_id = transform_tree.ContentTargetId(transform_node->id);
 
       // The clip node stores clip rect in its target space.
       gfx::RectF clip_rect_in_target_space = clip_node->clip_in_target_space;
 
       // If required, this clip rect should be mapped to the current layer's
       // target space.
-      if (clip_node->target_id != target_node_id) {
+      if (clip_node->target_transform_id != target_node_id) {
         // In this case, layer has a clip parent or scroll parent (or shares the
         // target with an ancestor layer that has clip parent) and the clip
         // parent's target is different from the layer's target. As the layer's
         // target has unclippped descendants, it is unclippped.
         if (!clip_node->layers_are_clipped)
           continue;
 
         // Compute the clip rect in target space and store it.
         if (!ComputeClipRectInTargetSpace(layer, clip_node, transform_tree,
                                           effect_tree, target_node_id,
@@ skipping 111 matching lines @@
       layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
       continue;
     }
 
     int target_node_id = transform_tree.ContentTargetId(transform_node->id);
 
     // The clip node stores clip rect in its target space. If required,
     // this clip rect should be mapped to the current layer's target space.
     gfx::RectF combined_clip_rect_in_target_space;
 
-    if (clip_node->target_id != target_node_id) {
+    if (clip_node->target_transform_id != target_node_id) {
       // In this case, layer has a clip parent or scroll parent (or shares the
       // target with an ancestor layer that has clip parent) and the clip
       // parent's target is different from the layer's target. As the layer's
       // target has unclippped descendants, it is unclippped.
       if (!clip_node->layers_are_clipped) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
 
       // We use the clip node's clip_in_target_space (and not
@@ skipping 249 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 ComputeClips(ClipTree* clip_tree,
                   const TransformTree& transform_tree,
+                  const EffectTree& effect_tree,
                   bool non_root_surfaces_enabled) {
   if (!clip_tree->needs_update())
     return;
   for (int i = 1; i < static_cast<int>(clip_tree->size()); ++i) {
     ClipNode* clip_node = clip_tree->Node(i);
 
     if (clip_node->id == 1) {
       ResetIfHasNanCoordinate(&clip_node->clip);
       clip_node->clip_in_target_space = clip_node->clip;
       clip_node->combined_clip_in_target_space = clip_node->clip;
       continue;
     }
     const TransformNode* transform_node =
         transform_tree.Node(clip_node->transform_id);
     ClipNode* parent_clip_node = clip_tree->parent(clip_node);
 
     gfx::Transform parent_to_current;
     const TransformNode* parent_target_transform_node =
-        transform_tree.Node(parent_clip_node->target_id);
+        transform_tree.Node(parent_clip_node->target_transform_id);
     bool success = true;
 
     // Clips must be combined in target space. We cannot, for example, combine
     // clips in the space of the child clip. The reason is non-affine
     // transforms. Say we have the following tree T->A->B->C, and B clips C, but
     // draw into target T. It may be the case that A applies a perspective
     // transform, and B and C are at different z positions. When projected into
     // target space, the relative sizes and positions of B and C can shift.
     // Since it's the relationship in target space that matters, that's where we
     // must combine clips. For each clip node, we save the clip rects in its
     // target space. So, we need to get the ancestor clip rect in the current
     // clip node's target space.
     gfx::RectF parent_combined_clip_in_target_space =
         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_id &&
+        parent_target_transform_node->id != clip_node->target_transform_id &&
         non_root_surfaces_enabled) {
-      success &= transform_tree.ComputeTransformWithDestinationSublayerScale(
-          parent_target_transform_node->id, clip_node->target_id,
+      success &= transform_tree.ComputeTransform(
+          parent_target_transform_node->id, clip_node->target_transform_id,
           &parent_to_current);
+      // We don't have to apply sublayer scale when target is root.
+      if (clip_node->target_transform_id != 0) {
+        ApplySublayerScale(clip_node->target_effect_id, effect_tree,
+                           &parent_to_current);
+#if DCHECK_IS_ON()
+        VerifySublayerScalesMatch(clip_node->target_effect_id,
+                                  clip_node->target_transform_id, effect_tree,
+                                  transform_tree);
+#endif
+      }
       if (parent_target_transform_node->sublayer_scale.x() > 0 &&
           parent_target_transform_node->sublayer_scale.y() > 0)
         parent_to_current.Scale(
             1.f / parent_target_transform_node->sublayer_scale.x(),
             1.f / parent_target_transform_node->sublayer_scale.y());
       // If we can't compute a transform, it's because we had to use the inverse
       // of a singular transform. We won't draw in this case, so there's no need
       // to compute clips.
       if (!success)
         continue;
@@ skipping 38 matching lines @@
         // no clip. So, clip_in_target_space is not used and hence we can set
         // it to an empty rect.
         clip_node->clip_in_target_space = gfx::RectF();
       }
     } else {
       gfx::Transform source_to_target;
 
       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_id) {
+                 clip_node->target_transform_id) {
         source_to_target = transform_tree.ToTarget(clip_node->transform_id);
       } else {
-        success = transform_tree.ComputeTransformWithDestinationSublayerScale(
-            transform_node->id, clip_node->target_id, &source_to_target);
+        success = transform_tree.ComputeTransform(
+            transform_node->id, clip_node->target_transform_id,
+            &source_to_target);
+        // We don't have to apply sublayer scale when target is root.
+        if (clip_node->target_transform_id != 0) {
+          ApplySublayerScale(clip_node->target_effect_id, effect_tree,
+                             &source_to_target);
+#if DCHECK_IS_ON()
+          VerifySublayerScalesMatch(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
         // ancestor of the transform node.
         DCHECK(success);
       }
 
       gfx::RectF source_clip_in_target_space =
           MathUtil::MapClippedRect(source_to_target, clip_node->clip);
 
       // With surfaces disabled, the only case where we use only the local clip
       // for layer clipping is the case where no non-viewport ancestor node
@@ skipping 134 matching lines @@
 static void VerifyDrawTransformsMatch(LayerImpl* layer,
                                       PropertyTrees* property_trees) {
   const int source_id = layer->transform_tree_index();
   int destination_id = FindTargetTransformTreeIndexFromEffectTree(
       property_trees->effect_tree, layer->effect_tree_index());
   gfx::Transform draw_transform;
   property_trees->transform_tree.ComputeTransform(source_id, destination_id,
                                                   &draw_transform);
   // We don't have to apply sublayer scale when target is root.
   if (destination_id != 0) {
-    AddSublayerScaleToTransform(layer->effect_tree_index(),
-                                property_trees->effect_tree, &draw_transform);
+    ApplySublayerScale(layer->effect_tree_index(), property_trees->effect_tree,
+                       &draw_transform);
 #if DCHECK_IS_ON()
     VerifySublayerScalesMatch(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(),
                            layer->offset_to_transform_parent().y());
@@ skipping 16 matching lines @@
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   UpdateRenderTarget(&property_trees->effect_tree,
                      property_trees->non_root_surfaces_enabled);
   ComputeTransforms(&property_trees->transform_tree);
+  // Computation of clips uses sublayer scale which is updated while computing
+  // effects. So, ComputeEffects should be before ComputeClips.
+  ComputeEffects(&property_trees->effect_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
-               can_render_to_separate_surface);
-  ComputeEffects(&property_trees->effect_tree);
+               property_trees->effect_tree, can_render_to_separate_surface);
 
   FindLayersThatNeedUpdates(root_layer->layer_tree_impl(),
                             property_trees->transform_tree,
                             property_trees->effect_tree, visible_layer_list);
   CalculateClipRects<LayerImpl>(*visible_layer_list, property_trees->clip_tree,
                                 property_trees->transform_tree,
                                 property_trees->effect_tree,
                                 can_render_to_separate_surface);
   CalculateVisibleRects<LayerImpl>(
       *visible_layer_list, property_trees->clip_tree,
       property_trees->transform_tree, property_trees->effect_tree,
       can_render_to_separate_surface);
 }
 
 void UpdatePropertyTrees(PropertyTrees* property_trees,
                          bool can_render_to_separate_surface) {
   if (property_trees->non_root_surfaces_enabled !=
       can_render_to_separate_surface) {
     property_trees->non_root_surfaces_enabled = can_render_to_separate_surface;
     property_trees->transform_tree.set_needs_update(true);
   }
   if (property_trees->transform_tree.needs_update()) {
     property_trees->clip_tree.set_needs_update(true);
     property_trees->effect_tree.set_needs_update(true);
   }
   ComputeTransforms(&property_trees->transform_tree);
+  // Computation of clips uses sublayer scale which is updated while computing
+  // effects. So, ComputeEffects should be before ComputeClips.
+  ComputeEffects(&property_trees->effect_tree);
   ComputeClips(&property_trees->clip_tree, property_trees->transform_tree,
-               can_render_to_separate_surface);
-  ComputeEffects(&property_trees->effect_tree);
+               property_trees->effect_tree, can_render_to_separate_surface);
 }
 
 void ComputeVisibleRectsForTesting(PropertyTrees* property_trees,
                                    bool can_render_to_separate_surface,
                                    LayerList* update_layer_list) {
   CalculateVisibleRects<Layer>(*update_layer_list, property_trees->clip_tree,
                                property_trees->transform_tree,
                                property_trees->effect_tree,
                                can_render_to_separate_surface);
 }
@@ skipping 103 matching lines @@
     return;
   }
 
   gfx::Transform render_surface_transform;
   const TransformNode* target_transform_node =
       transform_tree.Node(transform_tree.TargetId(transform_node->id));
   transform_tree.ComputeTransform(transform_node->id, target_transform_node->id,
                                   &render_surface_transform);
   // We don't have to apply sublayer scale when target is root.
   if (target_transform_node->id != 0) {
-    AddSublayerScaleToTransform(effect_node->target_id, effect_tree,
-                                &render_surface_transform);
+    ApplySublayerScale(effect_node->target_id, effect_tree,
+                       &render_surface_transform);
 #if DCHECK_IS_ON()
     VerifySublayerScalesMatch(effect_node->target_id, target_transform_node->id,
                               effect_tree, transform_tree);
 #endif
   }
 
   DCHECK(transform_node->sublayer_scale == effect_node->sublayer_scale);
   if (effect_node->sublayer_scale.x() != 0.0 &&
       effect_node->sublayer_scale.y() != 0.0)
     render_surface_transform.Scale(1.0 / effect_node->sublayer_scale.x(),
                                    1.0 / effect_node->sublayer_scale.y());
   render_surface->SetDrawTransform(render_surface_transform);
 }
 
 static void SetSurfaceIsClipped(const ClipNode* clip_node,
                                 RenderSurfaceImpl* render_surface) {
   DCHECK(render_surface->OwningLayerId() == clip_node->owner_id)
       << "we now create clip node for every render surface";
 
   render_surface->SetIsClipped(clip_node->target_is_clipped);
 }
 
 static void SetSurfaceClipRect(const ClipNode* parent_clip_node,
                                const TransformTree& transform_tree,
+                               const EffectTree& effect_tree,
                                RenderSurfaceImpl* render_surface) {
   if (!render_surface->is_clipped()) {
     render_surface->SetClipRect(gfx::Rect());
     return;
   }
 
   const TransformNode* transform_node =
       transform_tree.Node(render_surface->TransformTreeIndex());
   if (transform_tree.TargetId(transform_node->id) ==
-      parent_clip_node->target_id) {
+      parent_clip_node->target_transform_id) {
     render_surface->SetClipRect(
         gfx::ToEnclosingRect(parent_clip_node->clip_in_target_space));
     return;
   }
 
   // In this case, the clip child has reset the clip node for subtree and hence
   // the parent clip node's clip rect is in clip parent's target space and not
   // our target space. We need to transform it to our target space.
   gfx::Transform clip_parent_target_to_target;
-  const bool success =
-      transform_tree.ComputeTransformWithDestinationSublayerScale(
-          parent_clip_node->target_id,
-          transform_tree.TargetId(transform_node->id),
-          &clip_parent_target_to_target);
+  const bool success = transform_tree.ComputeTransform(
+      parent_clip_node->target_transform_id,
+      transform_tree.TargetId(transform_node->id),
+      &clip_parent_target_to_target);
 
   if (!success) {
     render_surface->SetClipRect(gfx::Rect());
     return;
   }
 
-  DCHECK_LT(parent_clip_node->target_id,
+  // We don't have to apply sublayer scale when target is root.
+  if (transform_tree.TargetId(transform_node->id) != 0) {
+    ApplySublayerScale(render_surface->EffectTreeIndex(), effect_tree,
+                       &clip_parent_target_to_target);
+#if DCHECK_IS_ON()
+    VerifySublayerScalesMatch(render_surface->EffectTreeIndex(),
+                              transform_tree.TargetId(transform_node->id),
+                              effect_tree, transform_tree);
+#endif
+  }
+
+  DCHECK_LT(parent_clip_node->target_transform_id,
             transform_tree.TargetId(transform_node->id));
   render_surface->SetClipRect(gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
       clip_parent_target_to_target, parent_clip_node->clip_in_target_space)));
 }
 
 template <typename LayerType>
 static gfx::Transform ScreenSpaceTransformInternal(LayerType* layer,
                                                    const TransformTree& tree) {
   gfx::Transform xform(1, 0, 0, 1, layer->offset_to_transform_parent().x(),
                        layer->offset_to_transform_parent().y());
@@ skipping 146 matching lines @@
     render_surface->SetReplicaDrawTransform(render_surface->draw_transform() *
                                             replica_to_surface);
     render_surface->SetReplicaScreenSpaceTransform(
         render_surface->screen_space_transform() * replica_to_surface);
   } else {
     render_surface->SetReplicaDrawTransform(gfx::Transform());
     render_surface->SetReplicaScreenSpaceTransform(gfx::Transform());
   }
 
   SetSurfaceClipRect(property_trees->clip_tree.parent(clip_node),
-                     property_trees->transform_tree, render_surface);
+                     property_trees->transform_tree,
+                     property_trees->effect_tree, render_surface);
 }
 
 #if DCHECK_IS_ON()
 static void ValidatePageScaleLayer(const Layer* page_scale_layer) {
   DCHECK_EQ(page_scale_layer->position().ToString(), gfx::PointF().ToString());
   DCHECK_EQ(page_scale_layer->transform_origin().ToString(),
             gfx::Point3F().ToString());
 }
 
 static void ValidatePageScaleLayer(const LayerImpl* page_scale_layer) {}
@@ skipping 84 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