cc: Convert backface LTHCommon tests from Layer->LayerImpl

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 <vector>
 
 #include "cc/base/math_util.h"
 #include "cc/layers/layer.h"
@@ skipping 119 matching lines @@
 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()->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>
@@ skipping 12 matching lines @@
 
   if (LayerIsInExisting3DRenderingContext(layer))
     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 (LayerIsInExisting3DRenderingContext(layer)) {
+    const TransformNode* node = tree.Node(layer->transform_tree_index());
+    // Draw transform as a contributing render surface.
+    return node->data.local.IsBackFaceVisible();

[enne (OOO), 2015/07/10 22:22:34]

to_target is just identity for something that creates a surface, so I think
local is what I want, but I'm not 100% sure.

[ajuma, 2015/07/10 22:56:53]

I think we want the transform from this node to node->data.target_id rather than
just the local transform (e.g. maybe the local transform is a 180-degree
rotation, but the parent node also is a 180-degree rotation, and the target is
somewhere further up).

+  }
+
+  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;
+}
+
+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,
                                             const TransformTree& tree) {
   return !IsAnimatingTransformToScreen(layer, tree);
 }
 
 static inline bool TransformToScreenIsKnown(LayerImpl* layer,
                                             const TransformTree& tree) {
   return true;
 }
 
 template <typename LayerType>
 static bool HasInvertibleOrAnimatedTransform(LayerType* layer) {
   return layer->transform_is_invertible() || layer->TransformIsAnimating();
 }
 
 static inline bool SubtreeShouldBeSkipped(LayerImpl* layer,
-                                          bool layer_is_drawn) {
+                                          bool layer_is_drawn,
+                                          const TransformTree& tree) {
   // If the layer transform is not invertible, it should not be drawn.
   // TODO(ajuma): Correctly process subtrees with singular transform for the
   // case where we may animate to a non-singular transform and wish to
   // pre-raster.
   if (!HasInvertibleOrAnimatedTransform(layer))
     return true;
 
   // When we need to do a readback/copy of a layer's output, we can not skip
   // it or any of its ancestors.
   if (layer->draw_properties().layer_or_descendant_has_copy_request)
     return false;
 
   // We cannot skip the the subtree if a descendant has a wheel or touch handler
   // or the hit testing code will break (it requires fresh transforms, etc).
   if (layer->draw_properties().layer_or_descendant_has_input_handler)
     return false;
 
   // If the layer is not drawn, then skip it and its subtree.
   if (!layer_is_drawn)
     return true;
 
+  if (layer->render_surface() && !layer->double_sided() &&
+      IsSurfaceBackFaceVisible(layer, tree))
+    return true;
+
   // If layer is on the pending tree and opacity is being animated then
   // this subtree can't be skipped as we need to create, prioritize and
   // include tiles for this layer when deciding if tree can be activated.
   if (layer->layer_tree_impl()->IsPendingTree() && layer->OpacityIsAnimating())
     return false;
 
   // The opacity of a layer always applies to its children (either implicitly
   // via a render surface or explicitly if the parent preserves 3D), so the
   // entire subtree can be skipped if this layer is fully transparent.
   return !layer->opacity();
 }
 
-static inline bool SubtreeShouldBeSkipped(Layer* layer, bool layer_is_drawn) {
+static inline bool SubtreeShouldBeSkipped(Layer* layer,
+                                          bool layer_is_drawn,
+                                          const TransformTree& tree) {
   // If the layer transform is not invertible, it should not be drawn.
   if (!layer->transform_is_invertible() && !layer->TransformIsAnimating())
     return true;
 
   // When we need to do a readback/copy of a layer's output, we can not skip
   // it or any of its ancestors.
   if (layer->draw_properties().layer_or_descendant_has_copy_request)
     return false;
 
   // We cannot skip the the subtree if a descendant has a wheel or touch handler
   // or the hit testing code will break (it requires fresh transforms, etc).
   if (layer->draw_properties().layer_or_descendant_has_input_handler)
     return false;
 
   // If the layer is not drawn, then skip it and its subtree.
   if (!layer_is_drawn)
     return true;
 
+  if (layer->render_surface() && !layer->double_sided() &&
+      !layer->TransformIsAnimating() && IsSurfaceBackFaceVisible(layer, tree))
+    return true;
+
   // If the opacity is being animated then the opacity on the main thread is
   // unreliable (since the impl thread may be using a different opacity), so it
   // should not be trusted.
   // In particular, it should not cause the subtree to be skipped.
   // Similarly, for layers that might animate opacity using an impl-only
   // animation, their subtree should also not be skipped.
   return !layer->opacity() && !layer->OpacityIsAnimating() &&
          !layer->OpacityCanAnimateOnImplThread();
 }
 
@@ skipping 44 matching lines @@
 void FindLayersThatNeedUpdates(
     LayerType* layer,
     const TransformTree& tree,
     bool subtree_is_visible_from_ancestor,
     typename LayerType::LayerListType* update_layer_list,
     std::vector<LayerType*>* visible_layer_list) {
   bool layer_is_drawn =
       layer->HasCopyRequest() ||
       (subtree_is_visible_from_ancestor && !layer->hide_layer_and_subtree());
 
-  if (layer->parent() && SubtreeShouldBeSkipped(layer, layer_is_drawn))
+  if (layer->parent() && SubtreeShouldBeSkipped(layer, layer_is_drawn, tree))
     return;
 
   if (!LayerShouldBeSkipped(layer, layer_is_drawn, tree)) {
     visible_layer_list->push_back(layer);
     update_layer_list->push_back(layer);
   }
 
   // Append mask layers to the update layer list.  They don't have valid visible
   // rects, so need to get added after the above calculation.  Replica layers
   // don't need to be updated.
@@ skipping 303 matching lines @@
   if (static_cast<int>(layer->offset_to_transform_parent().x()) !=
       layer->offset_to_transform_parent().x())
     return false;
   if (static_cast<int>(layer->offset_to_transform_parent().y()) !=
       layer->offset_to_transform_parent().y())
     return false;
   return true;
 }
 
 }  // namespace cc