Rename LayoutStyle to papayawhip

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 99 matching lines @@
 static inline bool isAcceleratedCanvas(const LayoutObject* renderer)
 {
     if (renderer->isCanvas()) {
         HTMLCanvasElement* canvas = toHTMLCanvasElement(renderer->node());
         if (CanvasRenderingContext* context = canvas->renderingContext())
             return context->isAccelerated();
     }
     return false;
 }
 
-static bool hasBoxDecorationsOrBackgroundImage(const LayoutStyle& style)
+static bool hasBoxDecorationsOrBackgroundImage(const ComputedStyle& style)
 {
     return style.hasBoxDecorations() || style.hasBackgroundImage();
 }
 
 static bool contentLayerSupportsDirectBackgroundComposition(const LayoutObject* renderer)
 {
     // No support for decorations - border, border-radius or outline.
     // Only simple background - solid color or transparent.
     if (hasBoxDecorationsOrBackgroundImage(renderer->styleRef()))
         return false;
@@ skipping 122 matching lines @@
     m_childContainmentLayer = nullptr;
     m_childTransformLayer = nullptr;
     m_maskLayer = nullptr;
     m_childClippingMaskLayer = nullptr;
 
     m_scrollingLayer = nullptr;
     m_scrollingContentsLayer = nullptr;
     m_scrollingBlockSelectionLayer = nullptr;
 }
 
-void CompositedDeprecatedPaintLayerMapping::updateOpacity(const LayoutStyle& style)
+void CompositedDeprecatedPaintLayerMapping::updateOpacity(const ComputedStyle& style)
 {
     m_graphicsLayer->setOpacity(compositingOpacity(style.opacity()));
 }
 
-void CompositedDeprecatedPaintLayerMapping::updateTransform(const LayoutStyle& style)
+void CompositedDeprecatedPaintLayerMapping::updateTransform(const ComputedStyle& style)
 {
     // FIXME: This could use m_owningLayer.transform(), but that currently has transform-origin
     // baked into it, and we don't want that.
     TransformationMatrix t;
     if (m_owningLayer.hasTransformRelatedProperty()) {
-        style.applyTransform(t, LayoutSize(toLayoutBox(layoutObject())->pixelSnappedSize()), LayoutStyle::ExcludeTransformOrigin);
+        style.applyTransform(t, LayoutSize(toLayoutBox(layoutObject())->pixelSnappedSize()), ComputedStyle::ExcludeTransformOrigin);
         makeMatrixRenderable(t, compositor()->hasAcceleratedCompositing());
     }
 
     m_graphicsLayer->setTransform(t);
 }
 
-void CompositedDeprecatedPaintLayerMapping::updateFilters(const LayoutStyle& style)
+void CompositedDeprecatedPaintLayerMapping::updateFilters(const ComputedStyle& style)
 {
     m_graphicsLayer->setFilters(owningLayer().computeFilterOperations(style));
 }
 
-void CompositedDeprecatedPaintLayerMapping::updateLayerBlendMode(const LayoutStyle& style)
+void CompositedDeprecatedPaintLayerMapping::updateLayerBlendMode(const ComputedStyle& style)
 {
     setBlendMode(style.blendMode());
 }
 
 void CompositedDeprecatedPaintLayerMapping::updateIsRootForIsolatedGroup()
 {
     bool isolate = m_owningLayer.shouldIsolateCompositedDescendants();
 
     // non stacking context layers should never isolate
     ASSERT(m_owningLayer.stackingNode()->isStackingContext() || !isolate);
 
     m_graphicsLayer->setIsRootForIsolatedGroup(isolate);
 }
 
-void CompositedDeprecatedPaintLayerMapping::updateScrollBlocksOn(const LayoutStyle& style)
+void CompositedDeprecatedPaintLayerMapping::updateScrollBlocksOn(const ComputedStyle& style)
 {
     // Note that blink determines the default scroll blocking policy, even
     // when the scroll-blocks-on CSS feature isn't enabled.
     WebScrollBlocksOn blockingMode = WebScrollBlocksOnStartTouch | WebScrollBlocksOnWheelEvent;
 
     if (RuntimeEnabledFeatures::cssScrollBlocksOnEnabled())
         blockingMode = style.scrollBlocksOn();
 
     m_graphicsLayer->setScrollBlocksOn(blockingMode);
 }
@@ skipping 131 matching lines @@
     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 LayoutStyle* style = renderer->style())
+    if (const ComputedStyle* style = renderer->style())
         hasPerspective = style->hasPerspective();
     bool needsChildTransformLayer = hasPerspective && (layerForChildrenTransform() == m_childTransformLayer.get()) && renderer->isBox();
     if (updateChildTransformLayer(needsChildTransformLayer))
         layerConfigChanged = true;
 
     if (updateSquashingLayers(!m_squashedLayers.isEmpty()))
         layerConfigChanged = true;
 
     updateScrollParent(scrollParent);
     updateClipParent();
@@ skipping 1009 matching lines @@
     // 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 LayoutStyle* style = m_owningLayer.layoutObject()->style())
+        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()) {
@@ skipping 422 matching lines @@
     updateDrawsContent();
 
     // Image animation is "lazy", in that it automatically stops unless someone is drawing
     // the image. So we have to kick the animation each time; this has the downside that the
     // image will keep animating, even if its layer is not visible.
     image->startAnimation();
 }
 
 FloatPoint3D CompositedDeprecatedPaintLayerMapping::computeTransformOrigin(const IntRect& borderBox) const
 {
-    const LayoutStyle& style = layoutObject()->styleRef();
+    const ComputedStyle& style = layoutObject()->styleRef();
 
     FloatPoint3D origin;
     origin.setX(floatValueForLength(style.transformOriginX(), borderBox.width()));
     origin.setY(floatValueForLength(style.transformOriginY(), borderBox.height()));
     origin.setZ(style.transformOriginZ());
 
     return origin;
 }
 
 // Return the offset from the top-left of this compositing layer at which the
@@ skipping 436 matching lines @@
     } else if (graphicsLayer == m_scrollingBlockSelectionLayer.get()) {
         name = "Scrolling Block Selection Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace blink