cc:: Add transform nodes at boundaries of 3d rendering contexts

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 186 matching lines @@
     } else {
       layer->set_visible_rect_from_property_trees(gfx::Rect(layer_bounds));
       // As the layer is unclipped, the clip rect in target space of this layer
       // is not used. So, we set it to an empty rect.
       layer->set_clip_rect_in_target_space_from_property_trees(gfx::Rect());
     }
   }
 }
 
 template <typename LayerType>
-static bool IsRootLayerOfNewRenderingContext(LayerType* layer) {
-  if (layer->parent())
-    return !layer->parent()->Is3dSorted() && layer->Is3dSorted();
-  return layer->Is3dSorted();
-}
-
-template <typename LayerType>
-static inline bool LayerIsInExisting3DRenderingContext(LayerType* layer) {
-  return layer->Is3dSorted() && layer->parent() &&
-         layer->parent()->Is3dSorted() &&
-         layer->parent()->sorting_context_id() == layer->sorting_context_id();
-}
-
-template <typename LayerType>
 static bool TransformToScreenIsKnown(LayerType* layer,
                                      const TransformTree& tree) {
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   return !node->data.to_screen_is_animated;
 }
 
 template <typename LayerType>
 static bool HasSingularTransform(LayerType* layer, const TransformTree& tree) {
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   return !node->data.is_invertible || !node->data.ancestors_are_invertible;
 }
 
 template <typename LayerType>
 static bool IsLayerBackFaceVisible(LayerType* layer,
                                    const TransformTree& tree) {
   // A layer with singular transform is not drawn. So, we can assume that its
   // backface is not visible.
   if (HasSingularTransform(layer, tree))
     return false;
   // The current W3C spec on CSS transforms says that backface visibility should
   // be determined differently depending on whether the layer is in a "3d
   // rendering context" or not. For Chromium code, we can determine whether we
   // are in a 3d rendering context by checking if the parent preserves 3d.
 
-  if (LayerIsInExisting3DRenderingContext(layer))
+  const TransformNode* node = tree.Node(layer->transform_tree_index());
+  const TransformNode* parent_node = tree.parent(node);
+  if (node->data.is_3d_sorted && parent_node && parent_node->data.is_3d_sorted)

[ajuma, 2016/01/25 14:35:22]

Is this equivalent to the existing logic? Say we have: ...L->A->B->C->M....
somewhere in the tree, where A,B,C are all 3d sorted, and L,M are not. In the
existing code, B and C are treated as being in an existing 3d context (and A
isn't). In the new code, A and M will have transform nodes, but B and C won't.
But this means neither B nor C will be treated as being in an existing 3d
context.

[weiliangc, 2016/01/25 21:29:26]

Would it make sense for A, B/C, and M to create 3 transform nodes?
  Ta
 / \
Tb  Tm
Where Ta would indicate root, Tb would be existing, and Tm would be endOf?

[ajuma, 2016/01/25 21:53:00]

That makes sense (if adding 3 nodes isn't too expensive).

[jaydasika, 2016/01/26 00:10:01]

I think we can do with just 2 nodes. A and M will create transform
nodes.

IsInExistingRenderingContext =
if (node owner = layer)
  node->is_3d_sorted && parent->is_3d_sorted
else
  node->is_3d_sorted

     return DrawTransformFromPropertyTrees(layer, tree).IsBackFaceVisible();
 
   // In this case, either the layer establishes a new 3d rendering context, or
   // is not in a 3d rendering context at all.
   return layer->transform().IsBackFaceVisible();
 }
 
 template <typename LayerType>
 static bool IsSurfaceBackFaceVisible(LayerType* layer,
                                      const TransformTree& tree) {
   if (HasSingularTransform(layer, tree))
     return false;
-  if (LayerIsInExisting3DRenderingContext(layer)) {
-    const TransformNode* node = tree.Node(layer->transform_tree_index());
+  const TransformNode* node = tree.Node(layer->transform_tree_index());
+  // If the render_surface is not part of a new or existing rendering context,
+  // then the layers that contribute to this surface will decide back-face
+  // visibility for themselves.
+  if (!node->data.is_3d_sorted)
+    return false;
+
+  const TransformNode* parent_node = tree.parent(node);
+  if (parent_node && parent_node->data.is_3d_sorted) {
     // Draw transform as a contributing render surface.
     // TODO(enne): we shouldn't walk the tree during a tree walk.
     gfx::Transform surface_draw_transform;
     tree.ComputeTransform(node->id, node->data.target_id,
                           &surface_draw_transform);
     return surface_draw_transform.IsBackFaceVisible();
   }
 
-  if (IsRootLayerOfNewRenderingContext(layer))
-    return layer->transform().IsBackFaceVisible();
-
-  // If the render_surface is not part of a new or existing rendering context,
-  // then the layers that contribute to this surface will decide back-face
-  // visibility for themselves.
-  return false;
+  // We use layer's transform to determine back face visibility when its the
+  // root of a new rendering context.
+  return layer->transform().IsBackFaceVisible();

[ajuma, 2016/01/25 14:35:22]

If we reach here, it it necessarily the case that the layer is the root of a new
rendering context? (Consider the example from the comment above, where multiple
3d sorted layers have the same transform id.)

[jaydasika, 2016/01/27 20:52:37]

We always have a transform node for surfaces. So we won't have that issue here.

[ajuma, 2016/01/28 00:08:35]

Oh, right, I missed that this layer owns a surface.

 }
 
 template <typename LayerType>
 static bool IsAnimatingTransformToScreen(LayerType* layer,
                                          const TransformTree& tree) {
   const TransformNode* node = tree.Node(layer->transform_tree_index());
   return node->data.to_screen_is_animated;
 }
 
 static inline bool TransformToScreenIsKnown(Layer* layer,
@@ skipping 891 matching lines @@
 
 void UpdateElasticOverscrollInPropertyTrees(
     PropertyTrees* property_trees,
     const Layer* overscroll_elasticity_layer,
     const gfx::Vector2dF& elastic_overscroll) {
   UpdateElasticOverscrollInPropertyTreesInternal(
       property_trees, overscroll_elasticity_layer, elastic_overscroll);
 }
 
 }  // namespace cc