cc: Compute sublayer scale from effect tree

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 35 matching lines @@
           layer->effect_tree_index());
   if (effect_node->owner_id != layer->id())
     return;
   DCHECK_EQ(effect_node->data.mask_layer_id, -1) << "layer: " << layer->id();
   DCHECK_EQ(effect_node->data.replica_layer_id, -1) << "layer: " << layer->id();
   DCHECK(effect_node->data.background_filters.IsEmpty());
 }
 
 #endif
 
+static void AddSublayerScaleToTransform(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->data.has_render_surface
+          ? effect_node
+          : effect_tree.Node(effect_node->data.target_id);
+  transform->matrix().postScale(target_effect_node->data.sublayer_scale.x(),
+                                target_effect_node->data.sublayer_scale.y(),
+                                1.f);
+}
+
+#if DCHECK_IS_ON()
+void VerifySublayerScalesMatch(const int effect_node_id,
+                               const int target_transform_id,
+                               const EffectTree& effect_tree,
+                               const TransformTree& transform_tree) {
+  const TransformNode* target_transform_node =
+      transform_tree.Node(target_transform_id);
+  const EffectNode* effect_node = effect_tree.Node(effect_node_id);
+  const EffectNode* target_effect_node =
+      effect_node->data.has_render_surface
+          ? effect_node
+          : effect_tree.Node(effect_node->data.target_id);
+  DCHECK(target_transform_node->data.sublayer_scale ==
+         target_effect_node->data.sublayer_scale)
+      << " sublayer scale from transform tree: "
+      << target_transform_node->data.sublayer_scale.ToString()
+      << " sublayer scale from effect tree: "
+      << target_effect_node->data.sublayer_scale.ToString();
+}
+#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->data.target_id != target_node_id);
 
   gfx::Transform clip_to_target;
   if (clip_node->data.target_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.ComputeTransformWithDestinationSublayerScale(
-            clip_node->data.target_id, target_node_id, &clip_to_target)) {
+    if (transform_tree.ComputeTransform(clip_node->data.target_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);
+#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->data.target_id);
       if (source_node->data.sublayer_scale.x() != 0.f &&
           source_node->data.sublayer_scale.y() != 0.f)
         clip_to_target.Scale(1.0f / source_node->data.sublayer_scale.x(),
                              1.0f / source_node->data.sublayer_scale.y());
       *clip_rect_in_target_space = MathUtil::MapClippedRect(
           clip_to_target, clip_node->data.clip_in_target_space);
     } else {
       return false;
     }
   } else {
     if (transform_tree.ComputeTransform(clip_node->data.target_id,
                                         target_node_id, &clip_to_target)) {
       *clip_rect_in_target_space = MathUtil::ProjectClippedRect(
           clip_to_target, clip_node->data.clip_in_target_space);
     } else {
       return false;
     }
   }
   return true;
 }
 
 struct ConditionalClip {
   bool is_clipped;
   gfx::RectF clip_rect;
 };
 
 static ConditionalClip ComputeTargetRectInLocalSpace(
     gfx::RectF rect,

[jaydasika, 2016/07/06 18:52:31]

Ah, forgot to upload immediately after rebasing. This is all rebase.

     const TransformTree& transform_tree,
     int current_transform_id,
     int target_transform_id) {
   gfx::Transform current_to_target;
   if (!transform_tree.ComputeTransformWithSourceSublayerScale(
           current_transform_id, target_transform_id, &current_to_target))
     // If transform is not invertible, cannot apply clip.
     return ConditionalClip{false, gfx::RectF()};
 
   if (current_transform_id > target_transform_id)
@@ skipping 148 matching lines @@
       if (clip_node->data.target_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->data.layers_are_clipped)
           continue;
 
         // Compute the clip rect in target space and store it.
         if (!ComputeClipRectInTargetSpace(layer, clip_node, transform_tree,
-                                          target_node_id,
+                                          effect_tree, target_node_id,
                                           &clip_rect_in_target_space))
           continue;
       }
 
       if (!clip_rect_in_target_space.IsEmpty()) {
         layer->set_clip_rect(gfx::ToEnclosingRect(clip_rect_in_target_space));
       } else {
         layer->set_clip_rect(gfx::Rect());
       }
     }
   }
 }
 
 bool GetLayerClipRect(const scoped_refptr<Layer> layer,
                       const ClipNode* clip_node,
                       const TransformTree& transform_tree,
+                      const EffectTree& effect_tree,
                       int target_node_id,
                       gfx::RectF* clip_rect_in_target_space) {
   return ComputeClipRectInTargetSpace(layer.get(), clip_node, transform_tree,
-                                      target_node_id,
+                                      effect_tree, target_node_id,
                                       clip_rect_in_target_space);
 }
 
 bool GetLayerClipRect(const LayerImpl* layer,
                       const ClipNode* clip_node,
                       const TransformTree& transform_tree,
+                      const EffectTree& effect_tree,
                       int target_node_id,
                       gfx::RectF* clip_rect_in_target_space) {
   // This is equivalent of calling ComputeClipRectInTargetSpace.
   *clip_rect_in_target_space = gfx::RectF(layer->clip_rect());
   return transform_tree.Node(target_node_id)->data.ancestors_are_invertible;
 }
 
 template <typename LayerType>
 void CalculateVisibleRects(
     const typename LayerType::LayerListType& visible_layer_list,
@@ skipping 89 matching lines @@
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
 
       // We use the clip node's clip_in_target_space (and not
       // combined_clip_in_target_space) here because we want to clip
       // with respect to clip parent's local clip and not its combined clip as
       // the combined clip has even the clip parent's target's clip baked into
       // it and as our target is different, we don't want to use it in our
       // visible rect computation.
-      if (!GetLayerClipRect(layer, clip_node, transform_tree, target_node_id,
+      if (!GetLayerClipRect(layer, clip_node, transform_tree, effect_tree,
+                            target_node_id,
                             &combined_clip_rect_in_target_space)) {
         layer->set_visible_layer_rect(gfx::Rect(layer_bounds));
         continue;
       }
     } else {
       if (clip_node->data.target_is_clipped) {
         combined_clip_rect_in_target_space =
             clip_node->data.combined_clip_in_target_space;
       } else {
         combined_clip_rect_in_target_space =
@@ skipping 493 matching lines @@
     return node->data.transform_id;
   node = effect_tree.Node(node->data.target_id);
   return node->data.transform_id;
 }
 
 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());
-  // TODO(jaydasika) : Remove this after sorting out how sublayer scale works
-  // for these ids.
-  if (destination_id == 0 || destination_id == 1)
-    return;
   gfx::Transform draw_transform;
   property_trees->transform_tree.ComputeTransform(source_id, destination_id,
                                                   &draw_transform);
-  TransformNode* target_node =
-      property_trees->transform_tree.Node(destination_id);
-  draw_transform.matrix().postScale(target_node->data.sublayer_scale.x(),
-                                    target_node->data.sublayer_scale.y(), 1.f);
+  // 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);
+    VerifySublayerScalesMatch(layer->effect_tree_index(), destination_id,
+                              property_trees->effect_tree,
+                              property_trees->transform_tree);
+  }
   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());
   DCHECK(draw_transform.ApproximatelyEqual(
       DrawTransform(layer, property_trees->transform_tree)))
       << " layer: " << layer->id() << " source transform id: " << source_id
       << " destination transform id: " << destination_id
       << " draw transform from transform tree: "
       << DrawTransform(layer, property_trees->transform_tree).ToString()
@@ skipping 145 matching lines @@
       xform.FlattenTo2d();
     xform.Translate(layer->offset_to_transform_parent().x(),
                     layer->offset_to_transform_parent().y());
   } else {
     // Surfaces need to apply their sublayer scale.
     xform.Scale(node->data.sublayer_scale.x(), node->data.sublayer_scale.y());
   }
   return xform;
 }
 
-static void SetSurfaceDrawTransform(const TransformTree& tree,
+static void SetSurfaceDrawTransform(const TransformTree& transform_tree,
+                                    const EffectTree& effect_tree,
                                     RenderSurfaceImpl* render_surface) {
-  const TransformNode* node = tree.Node(render_surface->TransformTreeIndex());
+  const TransformNode* transform_node =
+      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 (node->id == 1) {
+  if (transform_node->id == 1) {
     render_surface->SetDrawTransform(gfx::Transform());
     return;
   }
 
   gfx::Transform render_surface_transform;
-  const TransformNode* target_node = tree.Node(tree.TargetId(node->id));
-  tree.ComputeTransformWithDestinationSublayerScale(node->id, target_node->id,
-                                                    &render_surface_transform);
-  if (node->data.sublayer_scale.x() != 0.0 &&
-      node->data.sublayer_scale.y() != 0.0)
-    render_surface_transform.Scale(1.0 / node->data.sublayer_scale.x(),
-                                   1.0 / node->data.sublayer_scale.y());
+  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->data.target_id, effect_tree,
+                                &render_surface_transform);
+    VerifySublayerScalesMatch(effect_node->data.target_id,

[ajuma, 2016/07/06 21:35:29]

This should be called only if DCHECK_IS_ON.

[jaydasika, 2016/07/06 22:18:40]

Done.

+                              target_transform_node->id, effect_tree,
+                              transform_tree);
+  }
+
+  DCHECK(transform_node->data.sublayer_scale ==
+         effect_node->data.sublayer_scale);
+  if (effect_node->data.sublayer_scale.x() != 0.0 &&
+      effect_node->data.sublayer_scale.y() != 0.0)
+    render_surface_transform.Scale(1.0 / effect_node->data.sublayer_scale.x(),
+                                   1.0 / effect_node->data.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->data.target_is_clipped);
 }
@@ skipping 173 matching lines @@
       gfx::Rect(mask_layer->bounds());
 }
 
 void ComputeSurfaceDrawProperties(const PropertyTrees* property_trees,
                                   RenderSurfaceImpl* render_surface) {
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(render_surface->ClipTreeIndex());
 
   SetSurfaceIsClipped(clip_node, render_surface);
   SetSurfaceDrawOpacity(property_trees->effect_tree, render_surface);
-  SetSurfaceDrawTransform(property_trees->transform_tree, render_surface);
+  SetSurfaceDrawTransform(property_trees->transform_tree,
+                          property_trees->effect_tree, render_surface);
   render_surface->SetScreenSpaceTransform(
       property_trees->transform_tree.ToScreenSpaceTransformWithoutSublayerScale(
           render_surface->TransformTreeIndex()));
 
   if (render_surface->HasReplica()) {
     gfx::Transform replica_to_surface = ReplicaToSurfaceTransform(
         render_surface, property_trees->transform_tree);
     render_surface->SetReplicaDrawTransform(render_surface->draw_transform() *
                                             replica_to_surface);
     render_surface->SetReplicaScreenSpaceTransform(
@@ skipping 103 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