Use counters for opacity with transform-style:preserve-3d

third_party/WebKit/Source/core/layout/compositing/CompositedLayerMapping.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 382 matching lines @@
     // so it is legitimate to compute and cache the composited bounds for this layer.
     updateCompositedBounds();
 
     if (PaintLayerReflectionInfo* reflection = m_owningLayer.reflectionInfo()) {
         if (reflection->reflectionLayer()->hasCompositedLayerMapping())
             reflection->reflectionLayer()->compositedLayerMapping()->updateCompositedBounds();
     }
 
     PaintLayerCompositor* compositor = this->compositor();
     LayoutObject* layoutObject = this->layoutObject();
+    const ComputedStyle& style = layoutObject->styleRef();
 
     bool layerConfigChanged = false;
     setBackgroundLayerPaintsFixedRootBackground(compositor->needsFixedRootBackgroundLayer(&m_owningLayer));
 
     // The background layer is currently only used for fixed root backgrounds.
     if (updateBackgroundLayer(m_backgroundLayerPaintsFixedRootBackground))
         layerConfigChanged = true;
 
     if (updateForegroundLayer(compositor->needsContentsCompositingLayer(&m_owningLayer)))
         layerConfigChanged = true;
@@ skipping 18 matching lines @@
 
     bool scrollingConfigChanged = false;
     if (updateScrollingLayers(m_owningLayer.needsCompositedScrolling())) {
         layerConfigChanged = true;
         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 = layoutObject->style())
-        hasPerspective = style->hasPerspective();
+    bool hasPerspective = style.hasPerspective();
     bool needsChildTransformLayer = hasPerspective && layoutObject->isBox();
     if (updateChildTransformLayer(needsChildTransformLayer))
         layerConfigChanged = true;
 
     if (updateSquashingLayers(!m_squashedLayers.isEmpty()))
         layerConfigChanged = true;
 
     updateScrollParent(scrollParent);
     updateClipParent(scrollParent);
 
     if (layerConfigChanged)
         updateInternalHierarchy();
 
     if (scrollingConfigChanged) {
         if (layoutObject->view())
             compositor->scrollingLayerDidChange(&m_owningLayer);
     }
 
     // A mask layer is not part of the hierarchy proper, it's an auxiliary layer
     // that's plugged into another GraphicsLayer that is part of the hierarchy.
     // It has no parent or child GraphicsLayer. For that reason, we process it
     // here, after the hierarchy has been updated.
     bool maskLayerChanged = updateMaskLayer(layoutObject->hasMask());
     if (maskLayerChanged)
         m_graphicsLayer->setMaskLayer(m_maskLayer.get());
 
     bool hasChildClippingLayer = compositor->clipsCompositingDescendants(&m_owningLayer) && (hasClippingLayer() || hasScrollingLayer());
     // If we have a border radius or clip path on a scrolling layer, we need a clipping mask to properly
     // clip the scrolled contents, even if there are no composited descendants.
-    bool hasClipPath = layoutObject->style()->clipPath();
-    bool needsChildClippingMask = (hasClipPath || layoutObject->style()->hasBorderRadius()) && (hasChildClippingLayer || isAcceleratedContents(layoutObject) || hasScrollingLayer());
+    bool hasClipPath = style.clipPath();
+    bool needsChildClippingMask = (hasClipPath || style.hasBorderRadius()) && (hasChildClippingLayer || isAcceleratedContents(layoutObject) || hasScrollingLayer());
 
     GraphicsLayer* layerToApplyChildClippingMask = nullptr;
     bool shouldApplyChildClippingMaskOnContents = false;
     if (needsChildClippingMask) {
         if (hasClipPath) {
             // Clip path clips the entire subtree, including scrollbars. It must be attached directly onto
             // the main m_graphicsLayer.
             layerToApplyChildClippingMask = m_graphicsLayer.get();
         } else if (hasClippingLayer()) {
             layerToApplyChildClippingMask = clippingLayer();
@@ skipping 63 matching lines @@
             layerConfigChanged = true;
     }
 
     // Changes to either the internal hierarchy or the mask layer have an impact
     // on painting phases, so we need to update when either are updated.
     if (layerConfigChanged || maskLayerChanged)
         updatePaintingPhases();
 
     updateElementIdAndCompositorMutableProperties();
 
-    m_graphicsLayer->setHasWillChangeTransformHint(m_owningLayer.layoutObject()->styleRef().hasWillChangeTransformHint());
+    m_graphicsLayer->setHasWillChangeTransformHint(style.hasWillChangeTransformHint());
+
+    m_owningLayer.update3DTransformedDescendantStatus();
+    if (style.preserves3D() && style.hasOpacity() && m_owningLayer.has3DTransformedDescendant())
+        UseCounter::count(layoutObject->document(), UseCounter::OpacityWithPreserve3DQuirk);
 
     return layerConfigChanged;
 }
 
 static IntRect clipBox(LayoutBox* layoutObject)
 {
     LayoutRect result = LayoutRect(LayoutRect::infiniteIntRect());
     if (layoutObject->hasOverflowClip() || layoutObject->style()->containsPaint())
         result = layoutObject->overflowClipRect(LayoutPoint());
 
@@ skipping 2005 matching lines @@
     } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
         name = "Scrolling Contents Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink