WIP: backface visibility plumbing (not for review)

third_party/WebKit/Source/core/paint/PaintPropertyTreeBuilder.cpp

 // Copyright 2015 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 "core/paint/PaintPropertyTreeBuilder.h"
 
 #include "core/frame/FrameView.h"
 #include "core/layout/LayoutView.h"
 #include "core/paint/ObjectPaintProperties.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/graphics/paint/ClipPaintPropertyNode.h"
 #include "platform/graphics/paint/TransformPaintPropertyNode.h"
 #include "platform/transforms/TransformationMatrix.h"
 
 namespace blink {
 
 // The context for layout tree walk.
 // The walk will be done in the primary tree order (= DOM order), thus the context will also be
 // responsible for bookkeeping tree state in other order, for example, the most recent position
 // container seen.
 struct PaintPropertyTreeBuilderContext {
     PaintPropertyTreeBuilderContext()
         : currentTransform(nullptr)
         , currentClip(nullptr)
         , transformForOutOfFlowPositioned(nullptr)
         , clipForOutOfFlowPositioned(nullptr)
         , transformForFixedPositioned(nullptr)
         , clipForFixedPositioned(nullptr)
-        , currentEffect(nullptr) { }
+        , currentEffect(nullptr)
+        , preserving3d(false)
+        , backfaceHidden(false) { }
 
     // The combination of a transform and paint offset describes a linear space.
     // When a layout object recur to its children, the main context is expected to refer
     // the object's border box, then the callee will derive its own border box by translating
     // the space with its own layout location.
     TransformPaintPropertyNode* currentTransform;
     LayoutPoint paintOffset;
     // The clip node describes the accumulated raster clip for the current subtree.
     // Note that the computed raster region in canvas space for a clip node is independent from
     // the transform and paint offset above. Also the actual raster region may be affected
@@ skipping 12 matching lines @@
     ClipPaintPropertyNode* clipForOutOfFlowPositioned;
 
     TransformPaintPropertyNode* transformForFixedPositioned;
     LayoutPoint paintOffsetForFixedPositioned;
     ClipPaintPropertyNode* clipForFixedPositioned;
 
     // The effect hierarchy is applied by the stacking context tree. It is guaranteed that every
     // DOM descendant is also a stacking context descendant. Therefore, we don't need extra
     // bookkeeping for effect nodes and can generate the effect tree from a DOM-order traversal.
     EffectPaintPropertyNode* currentEffect;
+
+    bool preserving3d;
+    bool backfaceHidden;
 };
 
 void PaintPropertyTreeBuilder::buildPropertyTrees(FrameView& rootFrame)
 {
     walk(rootFrame, PaintPropertyTreeBuilderContext());
 }
 
 void PaintPropertyTreeBuilder::walk(FrameView& frameView, const PaintPropertyTreeBuilderContext& context)
 {
     PaintPropertyTreeBuilderContext localContext(context);
@@ skipping 243 matching lines @@
     // Note: Currently only layer painter makes use of the pre-computed context.
     // This condition may be loosened with no adverse effects beside memory use.
     if (!object.hasLayer())
         return nullptr;
 
     OwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> recordedContext = adoptPtr(new ObjectPaintProperties::LocalBorderBoxProperties);
     recordedContext->paintOffset = context.paintOffset;
     recordedContext->properties.transform = context.currentTransform;
     recordedContext->properties.clip = context.currentClip;
     recordedContext->properties.effect = context.currentEffect;
+    recordedContext->properties.backfaceHidden = context.backfaceHidden;
     return recordedContext.release();
 }
 
 void PaintPropertyTreeBuilder::walk(LayoutObject& object, const PaintPropertyTreeBuilderContext& context)
 {
+
+//fprintf(stderr, "walk trees, build propz.\n");
+//if (object.node())
+//    object.node()->showTreeForThisInFlatTree();
+//fprintf(stderr, "layout object %s\n\n", object.node() ? object.node()->nodeName().utf8().data() : "dunno");
+
     PaintPropertyTreeBuilderContext localContext(context);
 
+    fprintf(stderr, "walking into %s, context.preserving3d %d, context.backfaceHidden %d, object.preserves3d %d, object.backfacehidden %d\n",
+        object.debugName().utf8().data(),
+        localContext.preserving3d,
+        localContext.backfaceHidden,
+        object.styleRef().preserves3D(),
+        object.hasHiddenBackface());
+
+    localContext.preserving3d = object.styleRef().preserves3D();
+    if (localContext.preserving3d) {
+        if (object.hasTransformRelatedProperty())
+            localContext.backfaceHidden = object.hasHiddenBackface();
+    } else {
+        //if (object.hasTransformRelatedProperty())
+        localContext.backfaceHidden = false;
+        if (object.hasHiddenBackface())
+            localContext.backfaceHidden = true;
+    }
+
     deriveBorderBoxFromContainerContext(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPaintOffsetTranslation = createPaintOffsetTranslationIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForTransform = createTransformIfNeeded(object, localContext);
     RefPtr<EffectPaintPropertyNode> newEffectNode = createEffectIfNeeded(object, localContext);
     OwnPtr<ObjectPaintProperties::LocalBorderBoxProperties> newRecordedContext = recordTreeContextIfNeeded(object, localContext);
     RefPtr<ClipPaintPropertyNode> newClipNodeForOverflowClip = createOverflowClipIfNeeded(object, localContext);
     // TODO(trchen): Insert flattening transform here, as specified by
     // http://www.w3.org/TR/css3-transforms/#transform-style-property
     RefPtr<TransformPaintPropertyNode> newTransformNodeForPerspective = createPerspectiveIfNeeded(object, localContext);
     RefPtr<TransformPaintPropertyNode> newTransformNodeForScrollTranslation = createScrollTranslationIfNeeded(object, localContext);
@@ skipping 13 matching lines @@
         object.clearObjectPaintProperties();
     }
 
     for (LayoutObject* child = object.slowFirstChild(); child; child = child->nextSibling()) {
         if (child->isBoxModelObject() || child->isSVG())
             walk(*child, localContext);
     }
 }
 
 } // namespace blink