Determine face orientation in (x, y: w) projected space

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 309 matching lines @@
 }
 
 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 IsRootLayerOfNewRenderingContext(LayerType* layer) {
-  if (layer->parent())
-    return !layer->parent()->Is3dSorted() && layer->Is3dSorted();
-
-  return layer->Is3dSorted();
-}
-
-template <typename LayerType>
 static bool IsLayerBackFaceVisible(LayerType* layer) {
   // 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.
+  // rendering context" or not.
 
-  if (LayerIsInExisting3DRenderingContext(layer))
+  // TODO(trchen): We should use the accumulated transform between the layer
+  // and the flattening layer (i.e. the parent of the root of the 3D-rendering
+  // context) to determine face orientation. Using draw transform works here
+  // because we make 3D-transformed flattening layer always creating a surface.
+  // Such requirement is not really necessary.
+  if (layer->Is3dSorted())
     return layer->draw_transform().IsBackFaceVisible();
 
-  // In this case, either the layer establishes a new 3d rendering context, or
-  // is not in a 3d rendering context at all.
+  // TODO(trchen): This is not entirely correct because the paint effect should
+  // include the perspective transform from parent element, which is provided
+  // in a separate layer.
   return layer->transform().IsBackFaceVisible();
 }
 
 template <typename LayerType>
 static bool IsSurfaceBackFaceVisible(LayerType* layer,
                                      const gfx::Transform& draw_transform) {
-  if (LayerIsInExisting3DRenderingContext(layer))
+  if (layer->Is3dSorted())
     return 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;
+  return layer->transform().IsBackFaceVisible();
 }
 
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 template <typename LayerType>
 static gfx::Rect CalculateVisibleContentRect(
     LayerType* layer,
@@ skipping 2182 matching lines @@
       inputs->current_render_surface_layer_list_id);
 
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 }  // namespace cc