Rename LayoutStyle to papayawhip

Source/core/paint/DeprecatedPaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 326 matching lines @@
             paintInvalidationContainerWasScrolled && !child->isPaintInvalidationContainer());
     }
 }
 
 void DeprecatedPaintLayer::updateTransformationMatrix()
 {
     if (m_transform) {
         LayoutBox* box = layoutBox();
         ASSERT(box);
         m_transform->makeIdentity();
-        box->style()->applyTransform(*m_transform, LayoutSize(box->pixelSnappedSize()), LayoutStyle::IncludeTransformOrigin);
+        box->style()->applyTransform(*m_transform, LayoutSize(box->pixelSnappedSize()), ComputedStyle::IncludeTransformOrigin);
         makeMatrixRenderable(*m_transform, compositor()->hasAcceleratedCompositing());
     }
 }
 
-void DeprecatedPaintLayer::updateTransform(const LayoutStyle* oldStyle, const LayoutStyle& newStyle)
+void DeprecatedPaintLayer::updateTransform(const ComputedStyle* oldStyle, const ComputedStyle& newStyle)
 {
     if (oldStyle && newStyle.transformDataEquivalent(*oldStyle))
         return;
 
     // hasTransform() on the renderer is also true when there is transform-style: preserve-3d or perspective set,
     // so check style too.
     bool hasTransform = layoutObject()->hasTransformRelatedProperty() && newStyle.hasTransform();
     bool had3DTransform = has3DTransform();
 
     bool hadTransform = m_transform;
@@ skipping 28 matching lines @@
 
     if (shouldPreserve3D())
         renderingContext = this;
 
     for (DeprecatedPaintLayer* current = enclosingLayerForContainingBlock(this); current && current->shouldPreserve3D(); current = enclosingLayerForContainingBlock(current))
         renderingContext = current;
 
     return renderingContext;
 }
 
-TransformationMatrix DeprecatedPaintLayer::currentTransform(LayoutStyle::ApplyTransformOrigin applyOrigin) const
+TransformationMatrix DeprecatedPaintLayer::currentTransform(ComputedStyle::ApplyTransformOrigin applyOrigin) const
 {
     if (!m_transform)
         return TransformationMatrix();
 
     // m_transform includes transform-origin, so we need to recompute the transform here.
-    if (applyOrigin == LayoutStyle::ExcludeTransformOrigin) {
+    if (applyOrigin == ComputedStyle::ExcludeTransformOrigin) {
         LayoutBox* box = layoutBox();
         TransformationMatrix currTransform;
-        box->style()->applyTransform(currTransform, LayoutSize(box->pixelSnappedSize()), LayoutStyle::ExcludeTransformOrigin);
+        box->style()->applyTransform(currTransform, LayoutSize(box->pixelSnappedSize()), ComputedStyle::ExcludeTransformOrigin);
         makeMatrixRenderable(currTransform, compositor()->hasAcceleratedCompositing());
         return currTransform;
     }
 
     return *m_transform;
 }
 
 TransformationMatrix DeprecatedPaintLayer::renderableTransform(PaintBehavior paintBehavior) const
 {
     if (!m_transform)
@@ skipping 476 matching lines @@
     m_needsPositionUpdate = false;
 #endif
     return positionOrOffsetChanged;
 }
 
 TransformationMatrix DeprecatedPaintLayer::perspectiveTransform() const
 {
     if (!layoutObject()->hasTransformRelatedProperty())
         return TransformationMatrix();
 
-    const LayoutStyle& style = layoutObject()->styleRef();
+    const ComputedStyle& style = layoutObject()->styleRef();
     if (!style.hasPerspective())
         return TransformationMatrix();
 
     // Maybe fetch the perspective from the backing?
     const IntRect borderBox = toLayoutBox(layoutObject())->pixelSnappedBorderBoxRect();
     const float boxWidth = borderBox.width();
     const float boxHeight = borderBox.height();
 
     float perspectiveOriginX = floatValueForLength(style.perspectiveOriginX(), boxWidth);
     float perspectiveOriginY = floatValueForLength(style.perspectiveOriginY(), boxHeight);
@@ skipping 10 matching lines @@
 
     return t;
 }
 
 FloatPoint DeprecatedPaintLayer::perspectiveOrigin() const
 {
     if (!layoutObject()->hasTransformRelatedProperty())
         return FloatPoint();
 
     const LayoutRect borderBox = toLayoutBox(layoutObject())->borderBoxRect();
-    const LayoutStyle& style = layoutObject()->styleRef();
+    const ComputedStyle& style = layoutObject()->styleRef();
 
     return FloatPoint(floatValueForLength(style.perspectiveOriginX(), borderBox.width().toFloat()), floatValueForLength(style.perspectiveOriginY(), borderBox.height().toFloat()));
 }
 
 static inline bool isFixedPositionedContainer(DeprecatedPaintLayer* layer)
 {
     return layer->isRootLayer() || layer->hasTransformRelatedProperty();
 }
 
 DeprecatedPaintLayer* DeprecatedPaintLayer::enclosingPositionedAncestor() const
@@ skipping 568 matching lines @@
         offset.moveBy(-ancestorLayer->visualOffsetFromAncestor(paginationLayer));
     }
     return offset;
 }
 
 void DeprecatedPaintLayer::didUpdateNeedsCompositedScrolling()
 {
     updateSelfPaintingLayer();
 }
 
-void DeprecatedPaintLayer::updateReflectionInfo(const LayoutStyle* oldStyle)
+void DeprecatedPaintLayer::updateReflectionInfo(const ComputedStyle* oldStyle)
 {
     ASSERT(!oldStyle || !layoutObject()->style()->reflectionDataEquivalent(oldStyle));
     if (layoutObject()->hasReflection()) {
         if (!m_reflectionInfo)
             m_reflectionInfo = adoptPtr(new DeprecatedPaintLayerReflectionInfo(*layoutBox()));
         m_reflectionInfo->updateAfterStyleChange(oldStyle);
     } else if (m_reflectionInfo) {
         m_reflectionInfo->destroy();
         m_reflectionInfo = nullptr;
     }
@@ skipping 1178 matching lines @@
 }
 
 bool DeprecatedPaintLayer::hasVisibleBoxDecorations() const
 {
     if (!hasVisibleContent())
         return false;
 
     return hasBoxDecorationsOrBackground() || hasOverflowControls();
 }
 
-void DeprecatedPaintLayer::updateFilters(const LayoutStyle* oldStyle, const LayoutStyle& newStyle)
+void DeprecatedPaintLayer::updateFilters(const ComputedStyle* oldStyle, const ComputedStyle& newStyle)
 {
     if (!newStyle.hasFilter() && (!oldStyle || !oldStyle->hasFilter()))
         return;
 
     updateOrRemoveFilterClients();
     updateOrRemoveFilterEffectRenderer();
 }
 
-bool DeprecatedPaintLayer::attemptDirectCompositingUpdate(StyleDifference diff, const LayoutStyle* oldStyle)
+bool DeprecatedPaintLayer::attemptDirectCompositingUpdate(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     CompositingReasons oldPotentialCompositingReasonsFromStyle = m_potentialCompositingReasonsFromStyle;
     compositor()->updatePotentialCompositingReasonsFromStyle(this);
 
     // This function implements an optimization for transforms and opacity.
     // A common pattern is for a touchmove handler to update the transform
     // and/or an opacity of an element every frame while the user moves their
     // finger across the screen. The conditions below recognize when the
     // compositing state is set up to receive a direct transform or opacity
     // update.
@@ skipping 37 matching lines @@
 
     // FIXME: Consider introducing a smaller graphics layer update scope
     // that just handles transforms and opacity. GraphicsLayerUpdateLocal
     // will also program bounds, clips, and many other properties that could
     // not possibly have changed.
     m_compositedDeprecatedPaintLayerMapping->setNeedsGraphicsLayerUpdate(GraphicsLayerUpdateLocal);
     compositor()->setNeedsCompositingUpdate(CompositingUpdateAfterGeometryChange);
     return true;
 }
 
-void DeprecatedPaintLayer::styleChanged(StyleDifference diff, const LayoutStyle* oldStyle)
+void DeprecatedPaintLayer::styleChanged(StyleDifference diff, const ComputedStyle* oldStyle)
 {
     if (attemptDirectCompositingUpdate(diff, oldStyle))
         return;
 
     m_stackingNode->updateIsNormalFlowOnly();
     m_stackingNode->updateStackingNodesAfterStyleChange(oldStyle);
 
     if (m_scrollableArea)
         m_scrollableArea->updateAfterStyleChange(oldStyle);
 
@@ skipping 15 matching lines @@
 }
 
 bool DeprecatedPaintLayer::scrollsOverflow() const
 {
     if (DeprecatedPaintLayerScrollableArea* scrollableArea = this->scrollableArea())
         return scrollableArea->scrollsOverflow();
 
     return false;
 }
 
-FilterOperations DeprecatedPaintLayer::computeFilterOperations(const LayoutStyle& style)
+FilterOperations DeprecatedPaintLayer::computeFilterOperations(const ComputedStyle& style)
 {
     const FilterOperations& filters = style.filter();
     if (filters.hasReferenceFilter()) {
         for (size_t i = 0; i < filters.size(); ++i) {
             FilterOperation* filterOperation = filters.operations().at(i).get();
             if (filterOperation->type() != FilterOperation::REFERENCE)
                 continue;
             ReferenceFilterOperation* referenceOperation = toReferenceFilterOperation(filterOperation);
             // FIXME: Cache the ReferenceFilter if it didn't change.
             RefPtrWillBeRawPtr<ReferenceFilter> referenceFilter = ReferenceFilter::create(style.effectiveZoom());
@@ skipping 128 matching lines @@
     }
 }
 
 void showLayerTree(const blink::LayoutObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif