Simplify application of perspective origin.

Source/core/layout/compositing/CompositedDeprecatedPaintLayerMapping.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 434 matching lines @@
         scrollingConfigChanged = true;
     }
 
     if (updateOverflowControlsLayers(requiresHorizontalScrollbarLayer(), requiresVerticalScrollbarLayer(), requiresScrollCornerLayer(), needsAncestorClip))
         layerConfigChanged = true;
 
     bool hasPerspective = false;
     // FIXME: Can |style| be really null that late in the DocumentCycle?
     if (const ComputedStyle* style = renderer->style())
         hasPerspective = style->hasPerspective();
-    bool needsChildTransformLayer = hasPerspective && (layerForChildrenTransform() == m_childTransformLayer.get()) && renderer->isBox();
+    bool needsChildTransformLayer = hasPerspective && renderer->isBox();
     if (updateChildTransformLayer(needsChildTransformLayer))
         layerConfigChanged = true;
 
     if (updateSquashingLayers(!m_squashedLayers.isEmpty()))
         layerConfigChanged = true;
 
     updateScrollParent(scrollParent);
     updateClipParent();
 
     if (layerConfigChanged)
@@ skipping 587 matching lines @@
     // m_foregroundLayer has to be inserted in the correct order with child layers,
     // so it's not inserted here.
     if (m_ancestorClippingLayer)
         m_ancestorClippingLayer->removeAllChildren();
 
     m_graphicsLayer->removeFromParent();
 
     if (m_ancestorClippingLayer)
         m_ancestorClippingLayer->addChild(m_graphicsLayer.get());
 
-    if (m_childContainmentLayer)
-        m_graphicsLayer->addChild(m_childContainmentLayer.get());
-    else if (m_childTransformLayer)
-        m_graphicsLayer->addChild(m_childTransformLayer.get());
+    // Layer to which children should be attached as we build the hierarchy.
+    GraphicsLayer* bottomLayer = m_graphicsLayer.get();
+    auto updateBottomLayer = [&bottomLayer](GraphicsLayer* layer) {
+        if (layer) {
+            bottomLayer->addChild(layer);
+            bottomLayer = layer;
+        }
+    };
 
-    if (m_scrollingLayer) {
-        GraphicsLayer* superLayer = m_graphicsLayer.get();
+    updateBottomLayer(m_childTransformLayer.get());
+    updateBottomLayer(m_childContainmentLayer.get());
+    updateBottomLayer(m_scrollingLayer.get());
 
-        if (m_childContainmentLayer)
-            superLayer = m_childContainmentLayer.get();
-
-        if (m_childTransformLayer)
-            superLayer = m_childTransformLayer.get();
-
-        superLayer->addChild(m_scrollingLayer.get());
-    }
-
-    // The clip for child layers does not include space for overflow controls, so they exist as
-    // siblings of the clipping layer if we have one. Normal children of this layer are set as
-    // children of the clipping layer.
-    if (m_overflowControlsClippingLayer) {
-        ASSERT(m_overflowControlsHostLayer);
-        m_graphicsLayer->addChild(m_overflowControlsClippingLayer.get());
-        m_overflowControlsClippingLayer->addChild(m_overflowControlsHostLayer.get());
-    } else if (m_overflowControlsHostLayer) {
-        m_graphicsLayer->addChild(m_overflowControlsHostLayer.get());
-    }
-
+    // Now constructing the subtree for the overflow controls.
+    bottomLayer = m_graphicsLayer.get();
+    updateBottomLayer(m_overflowControlsClippingLayer.get());
+    updateBottomLayer(m_overflowControlsHostLayer.get());
     if (m_layerForHorizontalScrollbar)
         m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
     if (m_layerForVerticalScrollbar)
         m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
     if (m_layerForScrollCorner)
         m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
 
     // The squashing containment layer, if it exists, becomes a no-op parent.
     if (m_squashingLayer) {
         ASSERT((m_ancestorClippingLayer && !m_squashingContainmentLayer) || (!m_ancestorClippingLayer && m_squashingContainmentLayer));
@@ skipping 125 matching lines @@
 
     if (m_maskLayer)
         m_maskLayer->setDrawsContent(true);
 
     if (m_childClippingMaskLayer)
         m_childClippingMaskLayer->setDrawsContent(true);
 }
 
 void CompositedDeprecatedPaintLayerMapping::updateChildrenTransform()
 {
-    if (GraphicsLayer* childTransformLayer = layerForChildrenTransform()) {
+    if (GraphicsLayer* childTransformLayer = this->childTransformLayer()) {
         childTransformLayer->setTransform(owningLayer().perspectiveTransform());
-        childTransformLayer->setTransformOrigin(FloatPoint3D(childTransformLayer->size().width() * 0.5f, childTransformLayer->size().height() * 0.5f, 0.f));
+        childTransformLayer->setTransformOrigin(owningLayer().perspectiveOrigin());
     }
 
     updateShouldFlattenTransform();
 }
 
 // Return true if the layers changed.
 bool CompositedDeprecatedPaintLayerMapping::updateClippingLayers(bool needsAncestorClip, bool needsDescendantClip)
 {
     bool layersChanged = false;
 
@@ skipping 134 matching lines @@
     return false;
 }
 
 enum ApplyToGraphicsLayersModeFlags {
     ApplyToLayersAffectedByPreserve3D = (1 << 0),
     ApplyToSquashingLayer = (1 << 1),
     ApplyToScrollbarLayers = (1 << 2),
     ApplyToBackgroundLayer = (1 << 3),
     ApplyToMaskLayers = (1 << 4),
     ApplyToContentLayers = (1 << 5),
+    ApplyToChildContainingLayers = (1 << 6), // layers between m_graphicsLayer and children

[Ian Vollick, 2015/04/01 18:00:09]

bikeshed: ApplyToGraphicsLayerDescendants

[Ian Vollick, 2015/04/01 18:18:18]

Chatted with Jeremy about this offline. My bikeshed color isn't accurate
(scrollbars), and I can't come up with a better one. Suggestion withdrawn :)

[jbroman, 2015/04/02 15:34:15]

Acknowledged.

     ApplyToAllGraphicsLayers = (ApplyToSquashingLayer | ApplyToScrollbarLayers | ApplyToBackgroundLayer | ApplyToMaskLayers | ApplyToLayersAffectedByPreserve3D | ApplyToContentLayers)
 };
 typedef unsigned ApplyToGraphicsLayersMode;
 
 template <typename Func>
 static void ApplyToGraphicsLayers(const CompositedDeprecatedPaintLayerMapping* mapping, const Func& f, ApplyToGraphicsLayersMode mode)
 {
     ASSERT(mode);
 
     if ((mode & ApplyToLayersAffectedByPreserve3D) && mapping->childTransformLayer())
         f(mapping->childTransformLayer());
     if (((mode & ApplyToLayersAffectedByPreserve3D) || (mode & ApplyToContentLayers)) && mapping->mainGraphicsLayer())
         f(mapping->mainGraphicsLayer());
-    if ((mode & ApplyToLayersAffectedByPreserve3D) && mapping->clippingLayer())
+    if (((mode & ApplyToLayersAffectedByPreserve3D) || (mode & ApplyToChildContainingLayers)) && mapping->clippingLayer())
         f(mapping->clippingLayer());
-    if ((mode & ApplyToLayersAffectedByPreserve3D) && mapping->scrollingLayer())
+    if (((mode & ApplyToLayersAffectedByPreserve3D) || (mode & ApplyToChildContainingLayers)) && mapping->scrollingLayer())
         f(mapping->scrollingLayer());
-    if ((mode & ApplyToLayersAffectedByPreserve3D) && mapping->scrollingBlockSelectionLayer())
+    if (((mode & ApplyToLayersAffectedByPreserve3D) || (mode & ApplyToChildContainingLayers)) && mapping->scrollingBlockSelectionLayer())
         f(mapping->scrollingBlockSelectionLayer());
-    if (((mode & ApplyToLayersAffectedByPreserve3D) || (mode & ApplyToContentLayers)) && mapping->scrollingContentsLayer())
+    if (((mode & ApplyToLayersAffectedByPreserve3D) || (mode & ApplyToContentLayers) || (mode & ApplyToChildContainingLayers)) && mapping->scrollingContentsLayer())
         f(mapping->scrollingContentsLayer());
     if (((mode & ApplyToLayersAffectedByPreserve3D) || (mode & ApplyToContentLayers)) && mapping->foregroundLayer())
         f(mapping->foregroundLayer());
 
+    if ((mode & ApplyToChildContainingLayers) && mapping->childTransformLayer())
+        f(mapping->childTransformLayer());
+
     if ((mode & ApplyToSquashingLayer) && mapping->squashingLayer())
         f(mapping->squashingLayer());
 
     if (((mode & ApplyToMaskLayers) || (mode & ApplyToContentLayers)) && mapping->maskLayer())
         f(mapping->maskLayer());
     if (((mode & ApplyToMaskLayers) || (mode & ApplyToContentLayers)) && mapping->childClippingMaskLayer())
         f(mapping->childClippingMaskLayer());
 
     if (((mode & ApplyToBackgroundLayer) || (mode & ApplyToContentLayers)) && mapping->backgroundLayer())
         f(mapping->backgroundLayer());
@@ skipping 43 matching lines @@
 void CompositedDeprecatedPaintLayerMapping::updateShouldFlattenTransform()
 {
     // All CLM-managed layers that could affect a descendant layer should update their
     // should-flatten-transform value (the other layers' transforms don't matter here).
     UpdateShouldFlattenTransformFunctor functor = { !m_owningLayer.shouldPreserve3D() };
     ApplyToGraphicsLayersMode mode = ApplyToLayersAffectedByPreserve3D;
     ApplyToGraphicsLayers(this, functor, mode);
 
     // Note, if we apply perspective, we have to set should flatten differently
     // so that the transform propagates to child layers correctly.
-    if (GraphicsLayer* childTransformLayer = layerForChildrenTransform()) {
-        bool hasPerspective = false;
-        // FIXME: Can |style| be really null here?
-        if (const ComputedStyle* style = m_owningLayer.layoutObject()->style())
-            hasPerspective = style->hasPerspective();
-        if (hasPerspective)
-            childTransformLayer->setShouldFlattenTransform(false);
-
-        // Note, if the target is the scrolling layer, we need to ensure that the
-        // scrolling content layer doesn't flatten the transform. (It would be nice
-        // if we could apply transform to the scrolling content layer, but that's
-        // too late, we need the children transform to be applied _before_ the
-        // scrolling offset.)
-        if (childTransformLayer == m_scrollingLayer.get()) {
-            m_scrollingContentsLayer->setShouldFlattenTransform(false);
-            m_scrollingBlockSelectionLayer->setShouldFlattenTransform(false);
-        }
+    if (hasChildTransformLayer()) {
+        ApplyToGraphicsLayers(this, [](GraphicsLayer* layer) {
+            layer->setShouldFlattenTransform(false);
+        }, ApplyToChildContainingLayers);
     }
 }
 
 bool CompositedDeprecatedPaintLayerMapping::updateForegroundLayer(bool needsForegroundLayer)
 {
     bool layerChanged = false;
     if (needsForegroundLayer) {
         if (!m_foregroundLayer) {
             m_foregroundLayer = createGraphicsLayer(CompositingReasonLayerForForeground);
             m_foregroundLayer->setPaintingPhase(GraphicsLayerPaintForeground);
@@ skipping 478 matching lines @@
 {
     if (m_squashingContainmentLayer)
         return m_squashingContainmentLayer.get();
 
     if (m_ancestorClippingLayer)
         return m_ancestorClippingLayer.get();
 
     return m_graphicsLayer.get();
 }
 
-GraphicsLayer* CompositedDeprecatedPaintLayerMapping::layerForChildrenTransform() const
-{
-    if (GraphicsLayer* clipLayer = clippingLayer())
-        return clipLayer;
-    if (m_scrollingLayer)
-        return m_scrollingLayer.get();
-    return m_childTransformLayer.get();
-}
-
 void CompositedDeprecatedPaintLayerMapping::setBlendMode(WebBlendMode blendMode)
 {
     if (m_ancestorClippingLayer) {
         m_ancestorClippingLayer->setBlendMode(blendMode);
         m_graphicsLayer->setBlendMode(WebBlendModeNormal);
     } else {
         m_graphicsLayer->setBlendMode(blendMode);
     }
 }
 
@@ skipping 359 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink