cc: Compute draw transforms correctly when non root surfaces disabled

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 63 matching lines @@
       << target_transform_node->surface_contents_scale.ToString()
       << " surface contents scale from effect tree: "
       << target_effect_node->surface_contents_scale.ToString();
 }
 #endif
 
 static const EffectNode* ContentsTargetEffectNode(
     const int effect_tree_index,
     const EffectTree& effect_tree) {
   const EffectNode* effect_node = effect_tree.Node(effect_tree_index);
-  return effect_node->has_render_surface
-             ? effect_node
-             : effect_tree.Node(effect_node->target_id);
+  return effect_node->render_surface ? effect_node
+                                     : effect_tree.Node(effect_node->target_id);
 }
 
 template <typename LayerType>
 bool ComputeClipRectInTargetSpace(const LayerType* layer,
                                   const ClipNode* clip_node,
                                   const PropertyTrees* property_trees,
                                   int target_node_id,
                                   gfx::RectF* clip_rect_in_target_space) {
   DCHECK(layer->clip_tree_index() == clip_node->id);
   DCHECK(clip_node->target_transform_id != target_node_id);
@@ skipping 427 matching lines @@
           ContentsTargetEffectNode(layer->effect_tree_index(), effect_tree);
       bool success = property_trees->ComputeTransformFromTarget(
           transform_node->id, target_effect_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_effect_node->id != EffectTree::kContentsRootNodeId) {
+      if (target_effect_node->id > EffectTree::kContentsRootNodeId) {
         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 655 matching lines @@
                       bool layer_is_drawn,
                       const TransformTree& tree) {
   return LayerNeedsUpdateInternal(layer, layer_is_drawn, tree);
 }
 
 gfx::Transform DrawTransform(const LayerImpl* layer,
                              const TransformTree& transform_tree,
                              const EffectTree& effect_tree) {
   gfx::Transform xform;
   const bool owns_non_root_surface =
-      !IsRootLayer(layer) && layer->has_render_surface();
+      !IsRootLayer(layer) && layer->render_surface();
   if (!owns_non_root_surface) {
     // If you're not the root, or you don't own a surface, you need to apply
     // your local offset.
-    xform = transform_tree.ToTarget(layer->transform_tree_index(),
-                                    layer->render_target_effect_tree_index());
+    xform =
+        transform_tree.property_trees()->non_root_surfaces_enabled
+            ? transform_tree.ToTarget(layer->transform_tree_index(),
+                                      layer->render_target_effect_tree_index())
+            : transform_tree.ToScreen(layer->transform_tree_index());
     if (layer->should_flatten_transform_from_property_tree())
       xform.FlattenTo2d();
     xform.Translate(layer->offset_to_transform_parent().x(),
                     layer->offset_to_transform_parent().y());
   } else {
     // Surfaces need to apply their surface contents scale.
     const EffectNode* effect_node =
         effect_tree.Node(layer->effect_tree_index());
     xform.Scale(effect_node->surface_contents_scale.x(),
                 effect_node->surface_contents_scale.y());
@@ skipping 209 matching lines @@
 
 void ComputeLayerDrawProperties(LayerImpl* layer,
                                 const PropertyTrees* property_trees) {
   const TransformNode* transform_node =
       property_trees->transform_tree.Node(layer->transform_tree_index());
   const ClipNode* clip_node =
       property_trees->clip_tree.Node(layer->clip_tree_index());
 
   layer->draw_properties().screen_space_transform =
       ScreenSpaceTransformInternal(layer, property_trees->transform_tree);
   if (property_trees->non_root_surfaces_enabled) {

[ajuma, 2016/08/04 19:58:30]

Do we still need this branch if DrawTransform now does the right thing when
non-root surfaces are disabled?

[sunxd, 2016/08/04 21:27:23]

I think we can get rid of it.

     layer->draw_properties().target_space_transform = DrawTransform(
         layer, property_trees->transform_tree, property_trees->effect_tree);
   } else {
     layer->draw_properties().target_space_transform =
         layer->draw_properties().screen_space_transform;
   }
   layer->draw_properties().screen_space_transform_is_animating =
       transform_node->to_screen_is_potentially_animated;
 
   layer->draw_properties().opacity =
@@ skipping 148 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