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);
+  const bool is_3d_sorted = (node->data.sorting_context_id != 0);
+  const bool no_transfrom_node_created = (layer->id() != node->owner_id);
+  const bool parent_also_in_same_rendering_context =
+      parent_node &&
+      parent_node->data.sorting_context_id == node->data.sorting_context_id;
+  if (is_3d_sorted &&
+      (no_transfrom_node_created || parent_also_in_same_rendering_context)) {
     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.sorting_context_id)
+    return false;
+
+  const TransformNode* parent_node = tree.parent(node);
+  if (parent_node &&
+      parent_node->data.sorting_context_id == node->data.sorting_context_id) {
     // 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();
 }
 
 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 892 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