/*

* Copyright (C) 2004 Zack Rusin <zack@kde.org>

* Copyright (C) 2004-2021 Apple Inc. All rights reserved.

* Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>

* Copyright (C) 2007 Nicholas Shanks <webkit@nickshanks.com>

* Copyright (C) 2011 Sencha, Inc. All rights reserved.

* Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

* 02110-1301 USA

*/

#include "config.h"

#include "CSSComputedStyleDeclaration.h"

#include "BasicShapeFunctions.h"

#include "CSSBasicShapes.h"

#include "CSSBorderImage.h"

#include "CSSBorderImageSliceValue.h"

#include "CSSFontFeatureValue.h"

#include "CSSFontStyleValue.h"

#include "CSSFontValue.h"

#include "CSSFontVariationValue.h"

#include "CSSFunctionValue.h"

#include "CSSGridAutoRepeatValue.h"

#include "CSSLineBoxContainValue.h"

#include "CSSPrimitiveValue.h"

#include "CSSPrimitiveValueMappings.h"

#include "CSSPropertyAnimation.h"

#include "CSSPropertyNames.h"

#include "CSSPropertyParser.h"

#include "CSSRayValue.h"

#include "CSSReflectValue.h"

#include "CSSSelector.h"

#include "CSSShadowValue.h"

#include "CSSTimingFunctionValue.h"

#include "CSSValueList.h"

#include "CSSValuePool.h"

#include "ComposedTreeAncestorIterator.h"

#include "ContentData.h"

#include "CursorList.h"

#include "DeprecatedCSSOMValue.h"

#include "Document.h"

#include "DocumentTimeline.h"

#include "FontCascade.h"

#include "FontSelectionValueInlines.h"

#include "FontTaggedSettings.h"

#include "NodeRenderStyle.h"

#include "Pair.h"

#include "QuotesData.h"

#include "Rect.h"

#include "RenderBlock.h"

#include "RenderBox.h"

#include "RenderInline.h"

#include "RenderStyle.h"

#include "SVGElement.h"

#include "SVGRenderSupport.h"

#include "Settings.h"

#include "ShapeValue.h"

#include "StyleProperties.h"

#include "StylePropertyShorthand.h"

#include "StylePropertyShorthandFunctions.h"

#include "StyleResolver.h"

#include "StyleScope.h"

#include "StyleScrollSnapPoints.h"

#include "Styleable.h"

#include "TouchAction.h"

#include "WebKitFontFamilyNames.h"

#include "WillChangeData.h"

#include <wtf/IsoMallocInlines.h>

#include <wtf/NeverDestroyed.h>

#include <wtf/text/StringBuilder.h>

#include "CSSGridLineNamesValue.h"

#include "CSSGridTemplateAreasValue.h"

#include "RenderGrid.h"

namespace WebCore {

WTF_MAKE_ISO_ALLOCATED_IMPL(CSSComputedStyleDeclaration);

static CSSValueID valueForRepeatRule(NinePieceImageRule rule)

{

switch (rule) {

case NinePieceImageRule::Repeat:

return CSSValueRepeat;

case NinePieceImageRule::Round:

return CSSValueRound;

case NinePieceImageRule::Space:

return CSSValueSpace;

default:

return CSSValueStretch;

}

}

static Ref<CSSPrimitiveValue> valueForImageSliceSide(const Length& length)

{

// These values can be percentages, numbers, or while an animation of mixed types is in progress,

// a calculation that combines a percentage and a number.

if (length.isPercent())

return CSSValuePool::singleton().createValue(length.percent(), CSSUnitType::CSS_PERCENTAGE);

if (length.isAuto() || length.isFixed())

return CSSValuePool::singleton().createValue(length.value(), CSSUnitType::CSS_NUMBER);

// Calculating the actual length currently in use would require most of the code from RenderBoxModelObject::paintNinePieceImage.

// And even if we could do that, it's not clear if that's exactly what we'd want during animation.

// FIXME: For now, just return 0.

ASSERT(length.isCalculated());

return CSSValuePool::singleton().createValue(0, CSSUnitType::CSS_NUMBER);

}

static Ref<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const NinePieceImage& image)

{

auto& slices = image.imageSlices();

RefPtr<CSSPrimitiveValue> top = valueForImageSliceSide(slices.top());

RefPtr<CSSPrimitiveValue> right;

RefPtr<CSSPrimitiveValue> bottom;

RefPtr<CSSPrimitiveValue> left;

if (slices.right() == slices.top() && slices.bottom() == slices.top() && slices.left() == slices.top()) {

right = top;

bottom = top;

left = top;

} else {

right = valueForImageSliceSide(slices.right());

if (slices.bottom() == slices.top() && slices.right() == slices.left()) {

bottom = top;

left = right;

} else {

bottom = valueForImageSliceSide(slices.bottom());

if (slices.left() == slices.right())

left = right;

else

left = valueForImageSliceSide(slices.left());

}

}

auto quad = Quad::create();

quad->setTop(WTFMove(top));

quad->setRight(WTFMove(right));

quad->setBottom(WTFMove(bottom));

quad->setLeft(WTFMove(left));

return CSSBorderImageSliceValue::create(CSSValuePool::singleton().createValue(WTFMove(quad)), image.fill());

}

static Ref<CSSPrimitiveValue> valueForNinePieceImageQuad(const LengthBox& box, const RenderStyle& style)

{

RefPtr<CSSPrimitiveValue> top;

RefPtr<CSSPrimitiveValue> right;

RefPtr<CSSPrimitiveValue> bottom;

RefPtr<CSSPrimitiveValue> left;

auto& cssValuePool = CSSValuePool::singleton();

if (box.top().isRelative())

top = cssValuePool.createValue(box.top().value(), CSSUnitType::CSS_NUMBER);

else

top = cssValuePool.createValue(box.top(), style);

if (box.right() == box.top() && box.bottom() == box.top() && box.left() == box.top()) {

right = top;

bottom = top;

left = top;

} else {

if (box.right().isRelative())

right = cssValuePool.createValue(box.right().value(), CSSUnitType::CSS_NUMBER);

else

right = cssValuePool.createValue(box.right(), style);

if (box.bottom() == box.top() && box.right() == box.left()) {

bottom = top;

left = right;

} else {

if (box.bottom().isRelative())

bottom = cssValuePool.createValue(box.bottom().value(), CSSUnitType::CSS_NUMBER);

else

bottom = cssValuePool.createValue(box.bottom(), style);

if (box.left() == box.right())

left = right;

else {

if (box.left().isRelative())

left = cssValuePool.createValue(box.left().value(), CSSUnitType::CSS_NUMBER);

else

left = cssValuePool.createValue(box.left(), style);

}

}

}

auto quad = Quad::create();

quad->setTop(WTFMove(top));

quad->setRight(WTFMove(right));

quad->setBottom(WTFMove(bottom));

quad->setLeft(WTFMove(left));

return cssValuePool.createValue(WTFMove(quad));

}

static Ref<CSSValue> valueForNinePieceImageRepeat(const NinePieceImage& image)

{

auto& cssValuePool = CSSValuePool::singleton();

auto horizontalRepeat = cssValuePool.createIdentifierValue(valueForRepeatRule(image.horizontalRule()));

RefPtr<CSSPrimitiveValue> verticalRepeat;

if (image.horizontalRule() == image.verticalRule())

verticalRepeat = horizontalRepeat.copyRef();

else

verticalRepeat = cssValuePool.createIdentifierValue(valueForRepeatRule(image.verticalRule()));

return cssValuePool.createValue(Pair::create(WTFMove(horizontalRepeat), WTFMove(verticalRepeat)));

}

static Ref<CSSValue> valueForNinePieceImage(const NinePieceImage& image, const RenderStyle& style)

{

if (!image.hasImage())

return CSSValuePool::singleton().createIdentifierValue(CSSValueNone);

RefPtr<CSSValue> imageValue;

if (image.image())

imageValue = image.image()->cssValue();

auto imageSlices = valueForNinePieceImageSlice(image);

auto borderSlices = valueForNinePieceImageQuad(image.borderSlices(), style);

auto outset = valueForNinePieceImageQuad(image.outset(), style);

auto repeat = valueForNinePieceImageRepeat(image);

return createBorderImageValue(WTFMove(imageValue), WTFMove(imageSlices), WTFMove(borderSlices), WTFMove(outset), WTFMove(repeat));

}

inline static Ref<CSSPrimitiveValue> zoomAdjustedPixelValue(double value, const RenderStyle& style)

{

return CSSValuePool::singleton().createValue(adjustFloatForAbsoluteZoom(value, style), CSSUnitType::CSS_PX);

}

inline static Ref<CSSPrimitiveValue> zoomAdjustedNumberValue(double value, const RenderStyle& style)

{

return CSSValuePool::singleton().createValue(value / style.effectiveZoom(), CSSUnitType::CSS_NUMBER);

}

static Ref<CSSPrimitiveValue> zoomAdjustedPixelValueForLength(const Length& length, const RenderStyle& style)

{

if (length.isFixed())

return zoomAdjustedPixelValue(length.value(), style);

return CSSValuePool::singleton().createValue(length, style);

}

static Ref<CSSValue> valueForReflection(const StyleReflection* reflection, const RenderStyle& style)

{

if (!reflection)

return CSSValuePool::singleton().createIdentifierValue(CSSValueNone);

RefPtr<CSSPrimitiveValue> offset;

if (reflection->offset().isPercentOrCalculated())

offset = CSSValuePool::singleton().createValue(reflection->offset().percent(), CSSUnitType::CSS_PERCENTAGE);

else

offset = zoomAdjustedPixelValue(reflection->offset().value(), style);

RefPtr<CSSPrimitiveValue> direction;

switch (reflection->direction()) {

case ReflectionDirection::Below:

direction = CSSValuePool::singleton().createIdentifierValue(CSSValueBelow);

break;

case ReflectionDirection::Above:

direction = CSSValuePool::singleton().createIdentifierValue(CSSValueAbove);

break;

case ReflectionDirection::Left:

direction = CSSValuePool::singleton().createIdentifierValue(CSSValueLeft);

break;

case ReflectionDirection::Right:

direction = CSSValuePool::singleton().createIdentifierValue(CSSValueRight);

break;

}

return CSSReflectValue::create(direction.releaseNonNull(), offset.releaseNonNull(), valueForNinePieceImage(reflection->mask(), style));

}

static Ref<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const RenderStyle& style)

{

auto list = CSSValueList::createSpaceSeparated();

if (layer.isBackgroundXOriginSet() && layer.backgroundXOrigin() != Edge::Left) {

ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyMaskPosition || propertyID == CSSPropertyWebkitMaskPosition);

list->append(CSSValuePool::singleton().createValue(layer.backgroundXOrigin()));

}

list->append(zoomAdjustedPixelValueForLength(layer.xPosition(), style));

if (layer.isBackgroundYOriginSet() && layer.backgroundYOrigin() != Edge::Top) {

ASSERT(propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyMaskPosition || propertyID == CSSPropertyWebkitMaskPosition);

list->append(CSSValuePool::singleton().createValue(layer.backgroundYOrigin()));

}

list->append(zoomAdjustedPixelValueForLength(layer.yPosition(), style));

return list;

}

static Ref<CSSValue> createSingleAxisPositionValueForLayer(CSSPropertyID propertyID, const FillLayer& layer, const RenderStyle& style)

{

if (propertyID == CSSPropertyBackgroundPositionX || propertyID == CSSPropertyWebkitMaskPositionX) {

if (!layer.isBackgroundXOriginSet() || layer.backgroundXOrigin() == Edge::Left)

return zoomAdjustedPixelValueForLength(layer.xPosition(), style);

auto list = CSSValueList::createSpaceSeparated();

list->append(CSSValuePool::singleton().createValue(layer.backgroundXOrigin()));

list->append(zoomAdjustedPixelValueForLength(layer.xPosition(), style));

return list;

}

if (!layer.isBackgroundYOriginSet() || layer.backgroundYOrigin() == Edge::Top)

return zoomAdjustedPixelValueForLength(layer.yPosition(), style);

auto list = CSSValueList::createSpaceSeparated();

list->append(CSSValuePool::singleton().createValue(layer.backgroundYOrigin()));

list->append(zoomAdjustedPixelValueForLength(layer.yPosition(), style));

return list;

}

static Length getOffsetComputedLength(const RenderStyle& style, CSSPropertyID propertyID)

{

// If specified as a length, the corresponding absolute length; if specified as

// a percentage, the specified value; otherwise, 'auto'. Hence, we can just

// return the value in the style.

//

// See http://www.w3.org/TR/CSS21/cascade.html#computed-value

switch (propertyID) {

case CSSPropertyLeft:

return style.left();

case CSSPropertyRight:

return style.right();

case CSSPropertyTop:

return style.top();

case CSSPropertyBottom:

return style.bottom();

default:

ASSERT_NOT_REACHED();

}

return { };

}

static LayoutUnit getOffsetUsedStyleRelative(RenderBox& box, CSSPropertyID propertyID)

{

// For relatively positioned boxes, the offset is with respect to the top edges

// of the box itself. This ties together top/bottom and left/right to be

// opposites of each other.

//

// See http://www.w3.org/TR/CSS2/visuren.html#relative-positioning

//

// Specifically;

// Since boxes are not split or stretched as a result of 'left' or

// 'right', the used values are always: left = -right.

// and

// Since boxes are not split or stretched as a result of 'top' or

// 'bottom', the used values are always: top = -bottom.

switch (propertyID) {

case CSSPropertyTop:

return box.relativePositionOffset().height();

case CSSPropertyBottom:

return -(box.relativePositionOffset().height());

case CSSPropertyLeft:

return box.relativePositionOffset().width();

case CSSPropertyRight:

return -(box.relativePositionOffset().width());

default:

ASSERT_NOT_REACHED();

}

return 0;

}

static LayoutUnit getOffsetUsedStyleOutOfFlowPositioned(RenderBlock& container, RenderBox& box, CSSPropertyID propertyID)

{

// For out-of-flow positioned boxes, the offset is how far an box's margin

// edge is offset below the edge of the box's containing block.

// See http://www.w3.org/TR/CSS2/visuren.html#position-props

// Margins are included in offsetTop/offsetLeft so we need to remove them here.

switch (propertyID) {

case CSSPropertyTop:

return box.offsetTop() - box.marginTop();

case CSSPropertyBottom:

return container.clientHeight() - (box.offsetTop() + box.offsetHeight()) - box.marginBottom();

case CSSPropertyLeft:

return box.offsetLeft() - box.marginLeft();

case CSSPropertyRight:

return container.clientWidth() - (box.offsetLeft() + box.offsetWidth()) - box.marginRight();

default:

ASSERT_NOT_REACHED();

}

return 0;

}

static RefPtr<CSSValue> positionOffsetValue(const RenderStyle& style, CSSPropertyID propertyID, RenderObject* renderer)

{

auto offset = getOffsetComputedLength(style, propertyID);

// If the element is not displayed; return the "computed value".

if (!renderer || !renderer->isBox())

return zoomAdjustedPixelValueForLength(offset, style);

auto& box = downcast<RenderBox>(*renderer);

auto* containingBlock = box.containingBlock();

// Resolve a "computed value" percentage if the element is positioned.

if (containingBlock && offset.isPercentOrCalculated() && box.isPositioned()) {

bool isVerticalProperty;

if (propertyID == CSSPropertyTop || propertyID == CSSPropertyBottom)

isVerticalProperty = true;

else {

ASSERT(propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight);

isVerticalProperty = false;

}

LayoutUnit containingBlockSize;

if (box.isStickilyPositioned()) {

auto& enclosingClippingBox = box.enclosingClippingBoxForStickyPosition().first;

if (isVerticalProperty == enclosingClippingBox.isHorizontalWritingMode())

containingBlockSize = enclosingClippingBox.contentLogicalHeight();

else

containingBlockSize = enclosingClippingBox.contentLogicalWidth();

} else {

if (isVerticalProperty == containingBlock->isHorizontalWritingMode()) {

containingBlockSize = box.isOutOfFlowPositioned()

? box.containingBlockLogicalHeightForPositioned(*containingBlock, false)

: box.containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);

} else {

containingBlockSize = box.isOutOfFlowPositioned()

? box.containingBlockLogicalWidthForPositioned(*containingBlock, nullptr, false)

: box.containingBlockLogicalWidthForContent();

}

}

return zoomAdjustedPixelValue(floatValueForLength(offset, containingBlockSize), style);

}

// Return a "computed value" length.

if (!offset.isAuto())

return zoomAdjustedPixelValueForLength(offset, style);

// The property won't be overconstrained if its computed value is "auto", so the "used value" can be returned.

if (box.isRelativelyPositioned())

return zoomAdjustedPixelValue(getOffsetUsedStyleRelative(box, propertyID), style);

if (containingBlock && box.isOutOfFlowPositioned())

return zoomAdjustedPixelValue(getOffsetUsedStyleOutOfFlowPositioned(*containingBlock, box, propertyID), style);

return CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);

}

Ref<CSSPrimitiveValue> ComputedStyleExtractor::currentColorOrValidColor(const RenderStyle* style, const Color& color) const

{

// This function does NOT look at visited information, so that computed style doesn't expose that.

if (!color.isValid())

return CSSValuePool::singleton().createColorValue(style->color());

return CSSValuePool::singleton().createColorValue(color);

}

static Ref<CSSPrimitiveValue> percentageOrZoomAdjustedValue(Length length, const RenderStyle& style)

{

if (length.isPercent())

return CSSValuePool::singleton().createValue(length.percent(), CSSUnitType::CSS_PERCENTAGE);

return zoomAdjustedPixelValueForLength(length, style);

}

static Ref<CSSPrimitiveValue> autoOrZoomAdjustedValue(Length length, const RenderStyle& style)

{

if (length.isAuto())

return CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);

return zoomAdjustedPixelValueForLength(length, style);

}

static Ref<CSSValueList> borderRadiusCornerValues(const LengthSize& radius, const RenderStyle& style)

{

auto list = CSSValueList::createSpaceSeparated();

list->append(percentageOrZoomAdjustedValue(radius.width, style));

list->append(percentageOrZoomAdjustedValue(radius.height, style));

return list;

}

static Ref<CSSValue> valueForQuotes(const QuotesData* quotes)

{

if (!quotes)

return CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);

unsigned size = quotes->size();

if (!size)

return CSSValuePool::singleton().createIdentifierValue(CSSValueNone);

auto list = CSSValueList::createSpaceSeparated();

for (unsigned i = 0; i < size; ++i) {

list->append(CSSValuePool::singleton().createValue(quotes->openQuote(i), CSSUnitType::CSS_STRING));

list->append(CSSValuePool::singleton().createValue(quotes->closeQuote(i), CSSUnitType::CSS_STRING));

}

return list;

}

static Ref<CSSValue> borderRadiusCornerValue(const LengthSize& radius, const RenderStyle& style)

{

if (radius.width == radius.height)

return percentageOrZoomAdjustedValue(radius.width, style);

return borderRadiusCornerValues(radius, style);

}

static Ref<CSSValueList> borderRadiusShorthandValue(const RenderStyle& style)

{

auto list = CSSValueList::createSlashSeparated();

bool showHorizontalBottomLeft = style.borderTopRightRadius().width != style.borderBottomLeftRadius().width;

bool showHorizontalBottomRight = showHorizontalBottomLeft || (style.borderBottomRightRadius().width != style.borderTopLeftRadius().width);

bool showHorizontalTopRight = showHorizontalBottomRight || (style.borderTopRightRadius().width != style.borderTopLeftRadius().width);

bool showVerticalBottomLeft = style.borderTopRightRadius().height != style.borderBottomLeftRadius().height;

bool showVerticalBottomRight = showVerticalBottomLeft || (style.borderBottomRightRadius().height != style.borderTopLeftRadius().height);

bool showVerticalTopRight = showVerticalBottomRight || (style.borderTopRightRadius().height != style.borderTopLeftRadius().height);

auto topLeftRadius = borderRadiusCornerValues(style.borderTopLeftRadius(), style);

auto topRightRadius = borderRadiusCornerValues(style.borderTopRightRadius(), style);

auto bottomRightRadius = borderRadiusCornerValues(style.borderBottomRightRadius(), style);

auto bottomLeftRadius = borderRadiusCornerValues(style.borderBottomLeftRadius(), style);

auto horizontalRadii = CSSValueList::createSpaceSeparated();

horizontalRadii->append(*topLeftRadius->item(0));

if (showHorizontalTopRight)

horizontalRadii->append(*topRightRadius->item(0));

if (showHorizontalBottomRight)

horizontalRadii->append(*bottomRightRadius->item(0));

if (showHorizontalBottomLeft)

horizontalRadii->append(*bottomLeftRadius->item(0));

list->append(WTFMove(horizontalRadii));

auto verticalRadiiList = CSSValueList::createSpaceSeparated();

verticalRadiiList->append(*topLeftRadius->item(1));

if (showVerticalTopRight)

verticalRadiiList->append(*topRightRadius->item(1));

if (showVerticalBottomRight)

verticalRadiiList->append(*bottomRightRadius->item(1));

if (showVerticalBottomLeft)

verticalRadiiList->append(*bottomLeftRadius->item(1));

if (!verticalRadiiList->equals(downcast<CSSValueList>(*list->item(0))))

list->append(WTFMove(verticalRadiiList));

return list;

}

static LayoutRect sizingBox(RenderObject& renderer)

{

if (!is<RenderBox>(renderer))

return LayoutRect();

auto& box = downcast<RenderBox>(renderer);

return box.style().boxSizing() == BoxSizing::BorderBox ? box.borderBoxRect() : box.computedCSSContentBoxRect();

}

static FloatRect transformReferenceBox(const RenderStyle& style, const RenderElement& renderer)

{

if (is<RenderBox>(renderer))

return downcast<RenderBox>(renderer).referenceBox(transformBoxToCSSBoxType(style.transformBox()));

if (is<SVGElement>(renderer.element()))

return SVGRenderSupport::transformReferenceBox(renderer, downcast<SVGElement>(*renderer.element()), style);

return { };

}

static Ref<CSSFunctionValue> matrixTransformValue(const TransformationMatrix& transform, const RenderStyle& style)

{

RefPtr<CSSFunctionValue> transformValue;

auto& cssValuePool = CSSValuePool::singleton();

if (transform.isAffine()) {

transformValue = CSSFunctionValue::create(CSSValueMatrix);

transformValue->append(cssValuePool.createValue(transform.a(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.b(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.c(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.d(), CSSUnitType::CSS_NUMBER));

transformValue->append(zoomAdjustedNumberValue(transform.e(), style));

transformValue->append(zoomAdjustedNumberValue(transform.f(), style));

} else {

transformValue = CSSFunctionValue::create(CSSValueMatrix3d);

transformValue->append(cssValuePool.createValue(transform.m11(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m12(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m13(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m14(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m21(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m22(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m23(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m24(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m31(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m32(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m33(), CSSUnitType::CSS_NUMBER));

transformValue->append(cssValuePool.createValue(transform.m34(), CSSUnitType::CSS_NUMBER));

transformValue->append(zoomAdjustedNumberValue(transform.m41(), style));

transformValue->append(zoomAdjustedNumberValue(transform.m42(), style));

transformValue->append(zoomAdjustedNumberValue(transform.m43(), style));

transformValue->append(cssValuePool.createValue(transform.m44(), CSSUnitType::CSS_NUMBER));

}

return transformValue.releaseNonNull();

}

static bool rendererCanBeTransformed(RenderObject* renderer)

{

// Inline renderers do not support transforms.

return renderer && !is<RenderInline>(*renderer);

}

static Ref<CSSValue> computedTransform(RenderElement* renderer, const RenderStyle& style)

{

if (!rendererCanBeTransformed(renderer) || !style.hasTransform())

return CSSValuePool::singleton().createIdentifierValue(CSSValueNone);

TransformationMatrix transform;

style.applyTransform(transform, transformReferenceBox(style, *renderer), { });

// Note that this does not flatten to an affine transform if ENABLE(3D_TRANSFORMS) is off, by design.

// FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)

auto list = CSSValueList::createSpaceSeparated();

list->append(matrixTransformValue(transform, style));

return list;

}

// https://drafts.csswg.org/css-transforms-2/#propdef-translate

// Computed value: the keyword none or a pair of computed <length-percentage> values and an absolute length

static Ref<CSSValue> computedTranslate(RenderObject* renderer, const RenderStyle& style)

{

auto* translate = style.translate();

if (!translate || !rendererCanBeTransformed(renderer) || translate->isIdentity())

return CSSValuePool::singleton().createIdentifierValue(CSSValueNone);

auto list = CSSValueList::createSpaceSeparated();

list->append(zoomAdjustedPixelValueForLength(translate->x(), style));

if (!translate->y().isZero() || !translate->z().isZero())

list->append(zoomAdjustedPixelValueForLength(translate->y(), style));

if (!translate->z().isZero())

list->append(zoomAdjustedPixelValueForLength(translate->z(), style));

return list;

}

static Ref<CSSValue> computedScale(RenderObject* renderer, const RenderStyle& style)

{

auto* scale = style.scale();

auto& cssValuePool = CSSValuePool::singleton();

if (!scale || !rendererCanBeTransformed(renderer) || scale->isIdentity())

return cssValuePool.createIdentifierValue(CSSValueNone);

auto list = CSSValueList::createSpaceSeparated();

list->append(cssValuePool.createValue(scale->x(), CSSUnitType::CSS_NUMBER));

if (scale->z() != 1) {

list->append(cssValuePool.createValue(scale->y(), CSSUnitType::CSS_NUMBER));

list->append(cssValuePool.createValue(scale->z(), CSSUnitType::CSS_NUMBER));

} else if (scale->x() != scale->y())

list->append(cssValuePool.createValue(scale->y(), CSSUnitType::CSS_NUMBER));

return list;

}

static Ref<CSSValue> computedRotate(RenderObject* renderer, const RenderStyle& style)

{

auto* rotate = style.rotate();

auto& cssValuePool = CSSValuePool::singleton();

if (!rotate || !rendererCanBeTransformed(renderer) || rotate->isIdentity())

return cssValuePool.createIdentifierValue(CSSValueNone);

if (!rotate->is3DOperation() || (!rotate->x() && !rotate->y() && rotate->z()))

return cssValuePool.createValue(rotate->angle(), CSSUnitType::CSS_DEG);

auto list = CSSValueList::createSpaceSeparated();

if (rotate->x() && !rotate->y() && !rotate->z())

list->append(cssValuePool.createIdentifierValue(CSSValueX));

else if (!rotate->x() && rotate->y() && !rotate->z())

list->append(cssValuePool.createIdentifierValue(CSSValueY));

else {

list->append(cssValuePool.createValue(rotate->x(), CSSUnitType::CSS_NUMBER));

list->append(cssValuePool.createValue(rotate->y(), CSSUnitType::CSS_NUMBER));

list->append(cssValuePool.createValue(rotate->z(), CSSUnitType::CSS_NUMBER));

}

list->append(cssValuePool.createValue(rotate->angle(), CSSUnitType::CSS_DEG));

return list;

}

static inline Ref<CSSPrimitiveValue> adjustLengthForZoom(double length, const RenderStyle& style, AdjustPixelValuesForComputedStyle adjust)

{

return adjust == AdjustPixelValues ? zoomAdjustedPixelValue(length, style) : CSSValuePool::singleton().createValue(length, CSSUnitType::CSS_PX);

}

static inline Ref<CSSPrimitiveValue> adjustLengthForZoom(const Length& length, const RenderStyle& style, AdjustPixelValuesForComputedStyle adjust)

{

return adjust == AdjustPixelValues ? zoomAdjustedPixelValue(length.value(), style) : CSSValuePool::singleton().createValue(length);

}

Ref<CSSValue> ComputedStyleExtractor::valueForShadow(const ShadowData* shadow, CSSPropertyID propertyID, const RenderStyle& style, AdjustPixelValuesForComputedStyle adjust)

{

auto& cssValuePool = CSSValuePool::singleton();

if (!shadow)

return cssValuePool.createIdentifierValue(CSSValueNone);

auto list = CSSValueList::createCommaSeparated();

for (const ShadowData* currShadowData = shadow; currShadowData; currShadowData = currShadowData->next()) {

auto x = adjustLengthForZoom(currShadowData->x(), style, adjust);

auto y = adjustLengthForZoom(currShadowData->y(), style, adjust);

auto blur = adjustLengthForZoom(currShadowData->radius(), style, adjust);

auto spread = propertyID == CSSPropertyTextShadow ? RefPtr<CSSPrimitiveValue>() : adjustLengthForZoom(currShadowData->spread(), style, adjust);

auto style = propertyID == CSSPropertyTextShadow || currShadowData->style() == ShadowStyle::Normal ? RefPtr<CSSPrimitiveValue>() : cssValuePool.createIdentifierValue(CSSValueInset);

auto color = cssValuePool.createColorValue(currShadowData->color());

list->prepend(CSSShadowValue::create(WTFMove(x), WTFMove(y), WTFMove(blur), WTFMove(spread), WTFMove(style), WTFMove(color)));

}

return list;

}

Ref<CSSValue> ComputedStyleExtractor::valueForFilter(const RenderStyle& style, const FilterOperations& filterOperations, AdjustPixelValuesForComputedStyle adjust)

{

auto& cssValuePool = CSSValuePool::singleton();

if (filterOperations.operations().isEmpty())

return cssValuePool.createIdentifierValue(CSSValueNone);

auto list = CSSValueList::createSpaceSeparated();

Vector<RefPtr<FilterOperation>>::const_iterator end = filterOperations.operations().end();

for (Vector<RefPtr<FilterOperation>>::const_iterator it = filterOperations.operations().begin(); it != end; ++it) {

FilterOperation& filterOperation = **it;

if (filterOperation.type() == FilterOperation::REFERENCE) {

ReferenceFilterOperation& referenceOperation = downcast<ReferenceFilterOperation>(filterOperation);

list->append(cssValuePool.createValue(referenceOperation.url(), CSSUnitType::CSS_URI));

} else {

RefPtr<CSSFunctionValue> filterValue;

switch (filterOperation.type()) {

case FilterOperation::GRAYSCALE: {

filterValue = CSSFunctionValue::create(CSSValueGrayscale);

filterValue->append(cssValuePool.createValue(downcast<BasicColorMatrixFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_NUMBER));

break;

}

case FilterOperation::SEPIA: {

filterValue = CSSFunctionValue::create(CSSValueSepia);

filterValue->append(cssValuePool.createValue(downcast<BasicColorMatrixFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_NUMBER));

break;

}

case FilterOperation::SATURATE: {

filterValue = CSSFunctionValue::create(CSSValueSaturate);

filterValue->append(cssValuePool.createValue(downcast<BasicColorMatrixFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_NUMBER));

break;

}

case FilterOperation::HUE_ROTATE: {

filterValue = CSSFunctionValue::create(CSSValueHueRotate);

filterValue->append(cssValuePool.createValue(downcast<BasicColorMatrixFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_DEG));

break;

}

case FilterOperation::INVERT: {

filterValue = CSSFunctionValue::create(CSSValueInvert);

filterValue->append(cssValuePool.createValue(downcast<BasicComponentTransferFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_NUMBER));

break;

}

case FilterOperation::APPLE_INVERT_LIGHTNESS: {

filterValue = CSSFunctionValue::create(CSSValueAppleInvertLightness);

break;

}

case FilterOperation::OPACITY: {

filterValue = CSSFunctionValue::create(CSSValueOpacity);

filterValue->append(cssValuePool.createValue(downcast<BasicComponentTransferFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_NUMBER));

break;

}

case FilterOperation::BRIGHTNESS: {

filterValue = CSSFunctionValue::create(CSSValueBrightness);

filterValue->append(cssValuePool.createValue(downcast<BasicComponentTransferFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_NUMBER));

break;

}

case FilterOperation::CONTRAST: {

filterValue = CSSFunctionValue::create(CSSValueContrast);

filterValue->append(cssValuePool.createValue(downcast<BasicComponentTransferFilterOperation>(filterOperation).amount(), CSSUnitType::CSS_NUMBER));

break;

}

case FilterOperation::BLUR: {

filterValue = CSSFunctionValue::create(CSSValueBlur);

filterValue->append(adjustLengthForZoom(downcast<BlurFilterOperation>(filterOperation).stdDeviation(), style, adjust));

break;

}

case FilterOperation::DROP_SHADOW: {

DropShadowFilterOperation& dropShadowOperation = downcast<DropShadowFilterOperation>(filterOperation);

filterValue = CSSFunctionValue::create(CSSValueDropShadow);

// We want our computed style to look like that of a text shadow (has neither spread nor inset style).

ShadowData shadowData = ShadowData({ Length(dropShadowOperation.location().x(), LengthType::Fixed), Length(dropShadowOperation.location().y(), LengthType::Fixed) }, Length(dropShadowOperation.stdDeviation(), LengthType::Fixed), Length(0, LengthType::Fixed), ShadowStyle::Normal, false, dropShadowOperation.color());

filterValue->append(valueForShadow(&shadowData, CSSPropertyTextShadow, style, adjust));

break;

}

default:

ASSERT_NOT_REACHED();

filterValue = CSSFunctionValue::create(CSSValueInvalid);

break;

}

list->append(filterValue.releaseNonNull());

}

}

return list;

}

static Ref<CSSValue> specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const RenderStyle& style)

{

if (!trackBreadth.isLength())

return CSSValuePool::singleton().createValue(trackBreadth.flex(), CSSUnitType::CSS_FR);

const Length& trackBreadthLength = trackBreadth.length();

if (trackBreadthLength.isAuto())

return CSSValuePool::singleton().createIdentifierValue(CSSValueAuto);

return zoomAdjustedPixelValueForLength(trackBreadthLength, style);

}

static Ref<CSSValue> specifiedValueForGridTrackSize(const GridTrackSize& trackSize, const RenderStyle& style)

{

switch (trackSize.type()) {

case LengthTrackSizing:

return specifiedValueForGridTrackBreadth(trackSize.minTrackBreadth(), style);

case FitContentTrackSizing: {

auto fitContentTrackSize = CSSFunctionValue::create(CSSValueFitContent);

fitContentTrackSize->append(zoomAdjustedPixelValueForLength(trackSize.fitContentTrackBreadth().length(), style));

return fitContentTrackSize;

}

default:

ASSERT(trackSize.type() == MinMaxTrackSizing);

if (trackSize.minTrackBreadth().isAuto() && trackSize.maxTrackBreadth().isFlex())

return CSSValuePool::singleton().createValue(trackSize.maxTrackBreadth().flex(), CSSUnitType::CSS_FR);

auto minMaxTrackBreadths = CSSFunctionValue::create(CSSValueMinmax);

minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.minTrackBreadth(), style));

minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.maxTrackBreadth(), style));

return minMaxTrackBreadths;

}

}

class OrderedNamedLinesCollector {

WTF_MAKE_NONCOPYABLE(OrderedNamedLinesCollector);

public:

OrderedNamedLinesCollector(const RenderStyle& style, bool isRowAxis)

: m_orderedNamedGridLines(isRowAxis ? style.orderedNamedGridColumnLines() : style.orderedNamedGridRowLines())

, m_orderedNamedAutoRepeatGridLines(isRowAxis ? style.autoRepeatOrderedNamedGridColumnLines() : style.autoRepeatOrderedNamedGridRowLines())

{

}

virtual ~OrderedNamedLinesCollector() = default;

bool isEmpty() const { return m_orderedNamedGridLines.isEmpty() && m_orderedNamedAutoRepeatGridLines.isEmpty(); }

virtual void collectLineNamesForIndex(CSSGridLineNamesValue&, unsigned index) const;

protected:

enum NamedLinesType { NamedLines, AutoRepeatNamedLines };

void appendLines(CSSGridLineNamesValue&, unsigned index, NamedLinesType) const;

const OrderedNamedGridLinesMap& m_orderedNamedGridLines;

const OrderedNamedGridLinesMap& m_orderedNamedAutoRepeatGridLines;

};

class OrderedNamedLinesCollectorInsideRepeat : public OrderedNamedLinesCollector {

public:

OrderedNamedLinesCollectorInsideRepeat(const RenderStyle& style, bool isRowAxis)

: OrderedNamedLinesCollector(style, isRowAxis)

{

}

void collectLineNamesForIndex(CSSGridLineNamesValue&, unsigned index) const override;

};

class OrderedNamedLinesCollectorInGridLayout : public OrderedNamedLinesCollector {

public:

OrderedNamedLinesCollectorInGridLayout(const RenderStyle& style, bool isRowAxis, unsigned autoRepeatTracksCount, unsigned autoRepeatTrackListLength)

: OrderedNamedLinesCollector(style, isRowAxis)

, m_insertionPoint(isRowAxis ? style.gridAutoRepeatColumnsInsertionPoint() : style.gridAutoRepeatRowsInsertionPoint())

, m_autoRepeatTotalTracks(autoRepeatTracksCount)

, m_autoRepeatTrackListLength(autoRepeatTrackListLength)

{

}

void collectLineNamesForIndex(CSSGridLineNamesValue&, unsigned index) const override;

private:

unsigned m_insertionPoint;

unsigned m_autoRepeatTotalTracks;

unsigned m_autoRepeatTrackListLength;

};

void OrderedNamedLinesCollector::appendLines(CSSGridLineNamesValue& lineNamesValue, unsigned index, NamedLinesType type) const

{

auto iter = type == NamedLines ? m_orderedNamedGridLines.find(index) : m_orderedNamedAutoRepeatGridLines.find(index);

auto endIter = type == NamedLines ? m_orderedNamedGridLines.end() : m_orderedNamedAutoRepeatGridLines.end();

if (iter == endIter)

return;

auto& cssValuePool = CSSValuePool::singleton();

for (const auto& lineName : iter->value)

lineNamesValue.append(cssValuePool.createCustomIdent(lineName));

}

void OrderedNamedLinesCollector::collectLineNamesForIndex(CSSGridLineNamesValue& lineNamesValue, unsigned i) const

{

ASSERT(!isEmpty());

appendLines(lineNamesValue, i, NamedLines);

}

void OrderedNamedLinesCollectorInsideRepeat::collectLineNamesForIndex(CSSGridLineNamesValue& lineNamesValue, unsigned i) const

{

ASSERT(!isEmpty());

appendLines(lineNamesValue, i, AutoRepeatNamedLines);

}

void OrderedNamedLinesCollectorInGridLayout::collectLineNamesForIndex(CSSGridLineNamesValue& lineNamesValue, unsigned i) const

{

ASSERT(!isEmpty());

if (!m_autoRepeatTrackListLength || i < m_insertionPoint) {

appendLines(lineNamesValue, i, NamedLines);

return;

}

ASSERT(m_autoRepeatTotalTracks);

if (i > m_insertionPoint + m_autoRepeatTotalTracks) {

appendLines(lineNamesValue, i - (m_autoRepeatTotalTracks - 1), NamedLines);

return;

}

if (i == m_insertionPoint) {

appendLines(lineNamesValue, i, NamedLines);

appendLines(lineNamesValue, 0, AutoRepeatNamedLines);

return;

}

if (i == m_insertionPoint + m_autoRepeatTotalTracks) {

appendLines(lineNamesValue, m_autoRepeatTrackListLength, AutoRepeatNamedLines);

appendLines(lineNamesValue, m_insertionPoint + 1, NamedLines);

return;

}

unsigned autoRepeatIndexInFirstRepetition = (i - m_insertionPoint) % m_autoRepeatTrackListLength;

if (!autoRepeatIndexInFirstRepetition && i > m_insertionPoint)

appendLines(lineNamesValue, m_autoRepeatTrackListLength, AutoRepeatNamedLines);

appendLines(lineNamesValue, autoRepeatIndexInFirstRepetition, AutoRepeatNamedLines);

}

static void addValuesForNamedGridLinesAtIndex(OrderedNamedLinesCollector& collector, unsigned i, CSSValueList& list)

{

if (collector.isEmpty())

return;

auto lineNames = CSSGridLineNamesValue::create();

collector.collectLineNamesForIndex(lineNames.get(), i);

if (lineNames->length())

list.append(WTFMove(lineNames));

}

static Ref<CSSValueList> valueForGridTrackSizeList(GridTrackSizingDirection direction, const RenderStyle& style)

{

auto& autoTrackSizes = direction == ForColumns ? style.gridAutoColumns() : style.gridAutoRows();

auto list = CSSValueList::createSpaceSeparated();

for (auto& trackSize : autoTrackSizes)

list->append(specifiedValueForGridTrackSize(trackSize, style));

return list;

}

template <typename T, typename F>

void populateGridTrackList(CSSValueList& list, OrderedNamedLinesCollector& collector, const Vector<T>& tracks, F getTrackSize, int start, int end, int offset = 0)

{

ASSERT(0 <= start);

ASSERT(start <= end);

ASSERT(static_cast<unsigned>(end) <= tracks.size());

for (int i = start; i < end; ++i) {

if (i + offset >= 0)

addValuesForNamedGridLinesAtIndex(collector, i + offset, list);

list.append(getTrackSize(tracks[i]));

}

if (end + offset >= 0)

addValuesForNamedGridLinesAtIndex(collector, end + offset, list);

}

template <typename T, typename F>

void populateGridTrackList(CSSValueList& list, OrderedNamedLinesCollector& collector, const Vector<T>& tracks, F getTrackSize, int offset = 0)

{

populateGridTrackList<T>(list, collector, tracks, getTrackSize, 0, tracks.size(), offset);

}

static Ref<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction, RenderObject* renderer, const RenderStyle& style)

{

bool isRowAxis = direction == ForColumns;

bool isRenderGrid = is<RenderGrid>(renderer);