Update renderer in core/css.

Source/core/css/ComputedStyleCSSValueMapping.cpp

 /*
  * Copyright (C) 2004 Zack Rusin <zack@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012 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) 2015 Google Inc. 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
@@ skipping 132 matching lines @@
         return cssValuePool().createValue(CSSValueAlpha);
     case MaskLuminance:
         return cssValuePool().createValue(CSSValueLuminance);
     }
 
     ASSERT_NOT_REACHED();
 
     return nullptr;
 }
 
-static PassRefPtrWillBeRawPtr<CSSValue> valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* renderer)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* layoutObject)
 {
     Length offset;
     switch (propertyID) {
     case CSSPropertyLeft:
         offset = style.left();
         break;
     case CSSPropertyRight:
         offset = style.right();
         break;
     case CSSPropertyTop:
         offset = style.top();
         break;
     case CSSPropertyBottom:
         offset = style.bottom();
         break;
     default:
         return nullptr;
     }
 
-    if (offset.isPercent() && renderer && renderer->isBox() && renderer->isPositioned()) {
+    if (offset.isPercent() && layoutObject && layoutObject->isBox() && layoutObject->isPositioned()) {
         LayoutUnit containingBlockSize = (propertyID == CSSPropertyLeft || propertyID == CSSPropertyRight) ?
-            toLayoutBox(renderer)->containingBlockLogicalWidthForContent() :
-            toLayoutBox(renderer)->containingBlockLogicalHeightForGetComputedStyle();
+            toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent() :
+            toLayoutBox(layoutObject)->containingBlockLogicalHeightForGetComputedStyle();
         return zoomAdjustedPixelValue(valueForLength(offset, containingBlockSize), style);
     }
     if (offset.isAuto()) {
         // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
         // In other words if left is auto and right is not auto, then left's computed value is negative right().
         // So we should get the opposite length unit and see if it is auto.
         return cssValuePool().createIdentifierValue(CSSValueAuto);
     }
 
     return zoomAdjustedPixelValueForLength(offset, style);
@@ skipping 202 matching lines @@
     RefPtrWillBeRawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
     if (positionType == LegacyPosition)
         result->append(CSSPrimitiveValue::createIdentifier(CSSValueLegacy));
     result->append(CSSPrimitiveValue::create(itemPosition));
     if (itemPosition >= ItemPositionCenter && overflowAlignment != OverflowAlignmentDefault)
         result->append(CSSPrimitiveValue::create(overflowAlignment));
     ASSERT(result->length() <= 2);
     return result.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSValueList> valuesForGridShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* renderer, Node* styledNode, bool allowVisitedStyle)
+static PassRefPtrWillBeRawPtr<CSSValueList> valuesForGridShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
     for (size_t i = 0; i < shorthand.length(); ++i) {
-        RefPtrWillBeRawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, renderer, styledNode, allowVisitedStyle);
+        RefPtrWillBeRawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
         ASSERT(value);
         list->append(value.release());
     }
     return list.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSValueList> valuesForShorthandProperty(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* renderer, Node* styledNode, bool allowVisitedStyle)
+static PassRefPtrWillBeRawPtr<CSSValueList> valuesForShorthandProperty(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     for (size_t i = 0; i < shorthand.length(); ++i) {
-        RefPtrWillBeRawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, renderer, styledNode, allowVisitedStyle);
+        RefPtrWillBeRawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
         ASSERT(value);
         list->append(value);
     }
     return list.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSValueList> valuesForBackgroundShorthand(const ComputedStyle& style, const LayoutObject* renderer, Node* styledNode, bool allowVisitedStyle)
+static PassRefPtrWillBeRawPtr<CSSValueList> valuesForBackgroundShorthand(const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     RefPtrWillBeRawPtr<CSSValueList> ret = CSSValueList::createCommaSeparated();
     const FillLayer* currLayer = &style.backgroundLayers();
     for (; currLayer; currLayer = currLayer->next()) {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
         RefPtrWillBeRawPtr<CSSValueList> beforeSlash = CSSValueList::createSpaceSeparated();
         if (!currLayer->next()) { // color only for final layer
-            RefPtrWillBeRawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, renderer, styledNode, allowVisitedStyle);
+            RefPtrWillBeRawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, layoutObject, styledNode, allowVisitedStyle);
             ASSERT(value);
             beforeSlash->append(value);
         }
         beforeSlash->append(currLayer->image() ? currLayer->image()->cssValue() : cssValuePool().createIdentifierValue(CSSValueNone));
         beforeSlash->append(valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
         beforeSlash->append(cssValuePool().createValue(currLayer->attachment()));
         beforeSlash->append(createPositionListForLayer(CSSPropertyBackgroundPosition, *currLayer, style));
         list->append(beforeSlash);
         RefPtrWillBeRawPtr<CSSValueList> afterSlash = CSSValueList::createSpaceSeparated();
         afterSlash->append(valueForFillSize(currLayer->size(), style));
@@ skipping 132 matching lines @@
     const Vector<String>& namedGridLines = orderedNamedGridLines.get(i);
     if (namedGridLines.isEmpty())
         return;
 
     RefPtrWillBeRawPtr<CSSGridLineNamesValue> lineNames = CSSGridLineNamesValue::create();
     for (size_t j = 0; j < namedGridLines.size(); ++j)
         lineNames->append(cssValuePool().createValue(namedGridLines[j], CSSPrimitiveValue::CSS_CUSTOM_IDENT));
     list.append(lineNames.release());
 }
 
-static PassRefPtrWillBeRawPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction, const LayoutObject* renderer, const ComputedStyle& style)
+static PassRefPtrWillBeRawPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction, const LayoutObject* layoutObject, const ComputedStyle& style)
 {
     const Vector<GridTrackSize>& trackSizes = direction == ForColumns ? style.gridTemplateColumns() : style.gridTemplateRows();
     const OrderedNamedGridLines& orderedNamedGridLines = direction == ForColumns ? style.orderedNamedGridColumnLines() : style.orderedNamedGridRowLines();
-    bool isLayoutGrid = renderer && renderer->isLayoutGrid();
+    bool isLayoutGrid = layoutObject && layoutObject->isLayoutGrid();
 
     // Handle the 'none' case.
     bool trackListIsEmpty = trackSizes.isEmpty();
     if (isLayoutGrid && trackListIsEmpty) {
         // For grids we should consider every listed track, whether implicitly or explicitly created. If we don't have
         // any explicit track and there are no children then there are no implicit tracks. We cannot simply check the
         // number of rows/columns in our internal grid representation because it's always at least 1x1 (see r143331).
-        trackListIsEmpty = !toLayoutBlock(renderer)->firstChild();
+        trackListIsEmpty = !toLayoutBlock(layoutObject)->firstChild();
     }
 
     if (trackListIsEmpty) {
         ASSERT(orderedNamedGridLines.isEmpty());
         return cssValuePool().createIdentifierValue(CSSValueNone);
     }
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     if (isLayoutGrid) {
-        const Vector<LayoutUnit>& trackPositions = direction == ForColumns ? toLayoutGrid(renderer)->columnPositions() : toLayoutGrid(renderer)->rowPositions();
+        const Vector<LayoutUnit>& trackPositions = direction == ForColumns ? toLayoutGrid(layoutObject)->columnPositions() : toLayoutGrid(layoutObject)->rowPositions();
         // There are at least #tracks + 1 grid lines (trackPositions). Apart from that, the grid container can generate implicit grid tracks,
         // so we'll have more trackPositions than trackSizes as the latter only contain the explicit grid.
         ASSERT(trackPositions.size() - 1 >= trackSizes.size());
 
         for (size_t i = 0; i < trackPositions.size() - 1; ++i) {
             addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, i, *list);
             list->append(zoomAdjustedPixelValue(trackPositions[i + 1] - trackPositions[i], style));
         }
     } else {
         for (size_t i = 0; i < trackSizes.size(); ++i) {
@@ skipping 20 matching lines @@
         list->append(cssValuePool().createValue(position.spanPosition(), CSSPrimitiveValue::CSS_NUMBER));
     } else {
         list->append(cssValuePool().createValue(position.integerPosition(), CSSPrimitiveValue::CSS_NUMBER));
     }
 
     if (!position.namedGridLine().isNull())
         list->append(cssValuePool().createValue(position.namedGridLine(), CSSPrimitiveValue::CSS_CUSTOM_IDENT));
     return list;
 }
 
-static LayoutRect sizingBox(const LayoutObject* renderer)
+static LayoutRect sizingBox(const LayoutObject* layoutObject)
 {
-    if (!renderer->isBox())
+    if (!layoutObject->isBox())
         return LayoutRect();
 
-    const LayoutBox* box = toLayoutBox(renderer);
+    const LayoutBox* box = toLayoutBox(layoutObject);
     return box->style()->boxSizing() == BORDER_BOX ? box->borderBoxRect() : box->computedCSSContentBoxRect();
 }
 
 static PassRefPtrWillBeRawPtr<CSSValue> scrollBlocksOnFlagsToCSSValue(WebScrollBlocksOn scrollBlocksOn)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 
     if (scrollBlocksOn == WebScrollBlocksOnNone)
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
@@ skipping 264 matching lines @@
 
         transformValue->append(zoomAdjustedNumberValue(transform.m41(), style));
         transformValue->append(zoomAdjustedNumberValue(transform.m42(), style));
         transformValue->append(zoomAdjustedNumberValue(transform.m43(), style));
         transformValue->append(cssValuePool().createValue(transform.m44(), CSSPrimitiveValue::CSS_NUMBER));
     }
 
     return transformValue.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSValue> computedTransform(const LayoutObject* renderer, const ComputedStyle& style)
+static PassRefPtrWillBeRawPtr<CSSValue> computedTransform(const LayoutObject* layoutObject, const ComputedStyle& style)
 {
-    if (!renderer || !renderer->hasTransformRelatedProperty() || !style.hasTransform())
+    if (!layoutObject || !layoutObject->hasTransformRelatedProperty() || !style.hasTransform())
         return cssValuePool().createIdentifierValue(CSSValueNone);
 
     IntRect box;
-    if (renderer->isBox())
-        box = pixelSnappedIntRect(toLayoutBox(renderer)->borderBoxRect());
+    if (layoutObject->isBox())
+        box = pixelSnappedIntRect(toLayoutBox(layoutObject)->borderBoxRect());
 
     TransformationMatrix transform;
     style.applyTransform(transform, LayoutSize(box.size()), ComputedStyle::ExcludeTransformOrigin, ComputedStyle::ExcludeMotionPath);
 
     // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     list->append(valueForMatrixTransform(transform, style));
 
     return list.release();
 }
@@ skipping 85 matching lines @@
 
     ASSERT(shapeValue->type() == ShapeValue::Shape);
 
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     list->append(valueForBasicShape(style, shapeValue->shape()));
     if (shapeValue->cssBox() != BoxMissing)
         list->append(cssValuePool().createValue(shapeValue->cssBox()));
     return list.release();
 }
 
-static PassRefPtrWillBeRawPtr<CSSValueList> valuesForSidesShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* renderer, Node* styledNode, bool allowVisitedStyle)
+static PassRefPtrWillBeRawPtr<CSSValueList> valuesForSidesShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
     // Assume the properties are in the usual order top, right, bottom, left.
-    RefPtrWillBeRawPtr<CSSValue> topValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[0], style, renderer, styledNode, allowVisitedStyle);
-    RefPtrWillBeRawPtr<CSSValue> rightValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[1], style, renderer, styledNode, allowVisitedStyle);
-    RefPtrWillBeRawPtr<CSSValue> bottomValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[2], style, renderer, styledNode, allowVisitedStyle);
-    RefPtrWillBeRawPtr<CSSValue> leftValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[3], style, renderer, styledNode, allowVisitedStyle);
+    RefPtrWillBeRawPtr<CSSValue> topValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[0], style, layoutObject, styledNode, allowVisitedStyle);
+    RefPtrWillBeRawPtr<CSSValue> rightValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[1], style, layoutObject, styledNode, allowVisitedStyle);
+    RefPtrWillBeRawPtr<CSSValue> bottomValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[2], style, layoutObject, styledNode, allowVisitedStyle);
+    RefPtrWillBeRawPtr<CSSValue> leftValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[3], style, layoutObject, styledNode, allowVisitedStyle);
 
     // All 4 properties must be specified.
     if (!topValue || !rightValue || !bottomValue || !leftValue)
         return nullptr;
 
     bool showLeft = !compareCSSValuePtr(rightValue, leftValue);
     bool showBottom = !compareCSSValuePtr(topValue, bottomValue) || showLeft;
     bool showRight = !compareCSSValuePtr(topValue, rightValue) || showBottom;
 
     list->append(topValue.release());
@@ skipping 211 matching lines @@
         default:
             ASSERT_NOT_REACHED();
             break;
         }
         list->append(filterValue.release());
     }
 
     return list.release();
 }
 
-PassRefPtrWillBeRawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, const ComputedStyle& style, const LayoutObject* renderer, Node* styledNode, bool allowVisitedStyle)
+PassRefPtrWillBeRawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
 {
     const SVGComputedStyle& svgStyle = style.svgStyle();
     propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style.direction(), style.writingMode());
     switch (propertyID) {
     case CSSPropertyInvalid:
         return nullptr;
 
     case CSSPropertyBackgroundColor:
         return allowVisitedStyle ? cssValuePool().createColorValue(style.visitedDependentColor(CSSPropertyBackgroundColor).rgb()) : currentColorOrValidColor(style, style.backgroundColor());
     case CSSPropertyBackgroundImage:
@@ skipping 119 matching lines @@
         return cssValuePool().createValue(style.borderLeftStyle());
     case CSSPropertyBorderTopWidth:
         return zoomAdjustedPixelValue(style.borderTopWidth(), style);
     case CSSPropertyBorderRightWidth:
         return zoomAdjustedPixelValue(style.borderRightWidth(), style);
     case CSSPropertyBorderBottomWidth:
         return zoomAdjustedPixelValue(style.borderBottomWidth(), style);
     case CSSPropertyBorderLeftWidth:
         return zoomAdjustedPixelValue(style.borderLeftWidth(), style);
     case CSSPropertyBottom:
-        return valueForPositionOffset(style, CSSPropertyBottom, renderer);
+        return valueForPositionOffset(style, CSSPropertyBottom, layoutObject);
     case CSSPropertyWebkitBoxAlign:
         return cssValuePool().createValue(style.boxAlign());
     case CSSPropertyWebkitBoxDecorationBreak:
         if (style.boxDecorationBreak() == DSLICE)
             return cssValuePool().createIdentifierValue(CSSValueSlice);
     return cssValuePool().createIdentifierValue(CSSValueClone);
     case CSSPropertyWebkitBoxDirection:
         return cssValuePool().createValue(style.boxDirection());
     case CSSPropertyWebkitBoxFlex:
         return cssValuePool().createValue(style.boxFlex(), CSSPrimitiveValue::CSS_NUMBER);
@@ skipping 74 matching lines @@
         return cssValuePool().createValue(style.display());
     case CSSPropertyEmptyCells:
         return cssValuePool().createValue(style.emptyCells());
     case CSSPropertyAlignContent:
         return valueForContentPositionAndDistributionWithOverflowAlignment(resolveContentAlignmentAuto(style.alignContentPosition(), style.alignContentDistribution(), styledNode), style.alignContentOverflowAlignment(), style.alignContentDistribution());
     case CSSPropertyAlignItems:
         return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.alignItemsPosition(), styledNode), style.alignItemsOverflowAlignment(), NonLegacyPosition);
     case CSSPropertyAlignSelf:
         return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.alignSelfPosition(), styledNode->parentNode()), style.alignSelfOverflowAlignment(), NonLegacyPosition);
     case CSSPropertyFlex:
-        return valuesForShorthandProperty(flexShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(flexShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyFlexBasis:
         return zoomAdjustedPixelValueForLength(style.flexBasis(), style);
     case CSSPropertyFlexDirection:
         return cssValuePool().createValue(style.flexDirection());
     case CSSPropertyFlexFlow:
-        return valuesForShorthandProperty(flexFlowShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(flexFlowShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyFlexGrow:
         return cssValuePool().createValue(style.flexGrow());
     case CSSPropertyFlexShrink:
         return cssValuePool().createValue(style.flexShrink());
     case CSSPropertyFlexWrap:
         return cssValuePool().createValue(style.flexWrap());
     case CSSPropertyJustifyContent:
         return valueForContentPositionAndDistributionWithOverflowAlignment(resolveContentAlignmentAuto(style.justifyContentPosition(), style.justifyContentDistribution(), styledNode), style.justifyContentOverflowAlignment(), style.justifyContentDistribution());
     case CSSPropertyOrder:
         return cssValuePool().createValue(style.order(), CSSPrimitiveValue::CSS_NUMBER);
@@ skipping 71 matching lines @@
     // one for grid-definition-{rows|columns} but not for the grid-auto-{rows|columns} as things like
     // grid-auto-columns: 2fr; cannot be resolved to a value in pixels as the '2fr' means very different things
     // depending on the size of the explicit grid or the number of implicit tracks added to the grid. See
     // http://lists.w3.org/Archives/Public/www-style/2013Nov/0014.html
     case CSSPropertyGridAutoColumns:
         return specifiedValueForGridTrackSize(style.gridAutoColumns(), style);
     case CSSPropertyGridAutoRows:
         return specifiedValueForGridTrackSize(style.gridAutoRows(), style);
 
     case CSSPropertyGridTemplateColumns:
-        return valueForGridTrackList(ForColumns, renderer, style);
+        return valueForGridTrackList(ForColumns, layoutObject, style);
     case CSSPropertyGridTemplateRows:
-        return valueForGridTrackList(ForRows, renderer, style);
+        return valueForGridTrackList(ForRows, layoutObject, style);
 
     case CSSPropertyGridColumnStart:
         return valueForGridPosition(style.gridColumnStart());
     case CSSPropertyGridColumnEnd:
         return valueForGridPosition(style.gridColumnEnd());
     case CSSPropertyGridRowStart:
         return valueForGridPosition(style.gridRowStart());
     case CSSPropertyGridRowEnd:
         return valueForGridPosition(style.gridRowEnd());
     case CSSPropertyGridColumn:
-        return valuesForGridShorthand(gridColumnShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForGridShorthand(gridColumnShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGridRow:
-        return valuesForGridShorthand(gridRowShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForGridShorthand(gridRowShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGridArea:
-        return valuesForGridShorthand(gridAreaShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForGridShorthand(gridAreaShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGridTemplate:
-        return valuesForGridShorthand(gridTemplateShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForGridShorthand(gridTemplateShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGrid:
-        return valuesForGridShorthand(gridShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForGridShorthand(gridShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyGridTemplateAreas:
         if (!style.namedGridAreaRowCount()) {
             ASSERT(!style.namedGridAreaColumnCount());
             return cssValuePool().createIdentifierValue(CSSValueNone);
         }
 
         return CSSGridTemplateAreasValue::create(style.namedGridArea(), style.namedGridAreaRowCount(), style.namedGridAreaColumnCount());
 
     case CSSPropertyHeight:
-        if (renderer) {
+        if (layoutObject) {
             // According to http://www.w3.org/TR/CSS2/visudet.html#the-height-property,
             // the "height" property does not apply for non-replaced inline elements.
-            if (!renderer->isReplaced() && renderer->isInline())
+            if (!layoutObject->isReplaced() && layoutObject->isInline())
                 return cssValuePool().createIdentifierValue(CSSValueAuto);
-            return zoomAdjustedPixelValue(sizingBox(renderer).height(), style);
+            return zoomAdjustedPixelValue(sizingBox(layoutObject).height(), style);
         }
         return zoomAdjustedPixelValueForLength(style.height(), style);
     case CSSPropertyWebkitHighlight:
         if (style.highlight() == nullAtom)
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return cssValuePool().createValue(style.highlight(), CSSPrimitiveValue::CSS_STRING);
     case CSSPropertyWebkitHyphenateCharacter:
         if (style.hyphenationString().isNull())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
         return cssValuePool().createValue(style.hyphenationString(), CSSPrimitiveValue::CSS_STRING);
     case CSSPropertyImageRendering:
         return CSSPrimitiveValue::create(style.imageRendering());
     case CSSPropertyIsolation:
         return cssValuePool().createValue(style.isolation());
     case CSSPropertyJustifyItems:
         return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.justifyItemsPosition(), styledNode), style.justifyItemsOverflowAlignment(), style.justifyItemsPositionType());
     case CSSPropertyJustifySelf:
         return valueForItemPositionWithOverflowAlignment(resolveAlignmentAuto(style.justifySelfPosition(), styledNode->parentNode()), style.justifySelfOverflowAlignment(), NonLegacyPosition);
     case CSSPropertyLeft:
-        return valueForPositionOffset(style, CSSPropertyLeft, renderer);
+        return valueForPositionOffset(style, CSSPropertyLeft, layoutObject);
     case CSSPropertyLetterSpacing:
         if (!style.letterSpacing())
             return cssValuePool().createIdentifierValue(CSSValueNormal);
         return zoomAdjustedPixelValue(style.letterSpacing(), style);
     case CSSPropertyWebkitLineClamp:
         if (style.lineClamp().isNone())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return cssValuePool().createValue(style.lineClamp().value(), style.lineClamp().isPercentage() ? CSSPrimitiveValue::CSS_PERCENTAGE : CSSPrimitiveValue::CSS_NUMBER);
     case CSSPropertyLineHeight:
         return valueForLineHeight(style);
     case CSSPropertyListStyleImage:
         if (style.listStyleImage())
             return style.listStyleImage()->cssValue();
         return cssValuePool().createIdentifierValue(CSSValueNone);
     case CSSPropertyListStylePosition:
         return cssValuePool().createValue(style.listStylePosition());
     case CSSPropertyListStyleType:
         return cssValuePool().createValue(style.listStyleType());
     case CSSPropertyWebkitLocale:
         if (style.locale().isNull())
             return cssValuePool().createIdentifierValue(CSSValueAuto);
         return cssValuePool().createValue(style.locale(), CSSPrimitiveValue::CSS_STRING);
     case CSSPropertyMarginTop: {
         Length marginTop = style.marginTop();
-        if (marginTop.isFixed() || !renderer || !renderer->isBox())
+        if (marginTop.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginTop, style);
-        return zoomAdjustedPixelValue(toLayoutBox(renderer)->marginTop(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginTop(), style);
     }
     case CSSPropertyMarginRight: {
         Length marginRight = style.marginRight();
-        if (marginRight.isFixed() || !renderer || !renderer->isBox())
+        if (marginRight.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginRight, style);
         float value;
         if (marginRight.isPercent()) {
             // LayoutBox gives a marginRight() that is the distance between the right-edge of the child box
             // and the right-edge of the containing box, when display == BLOCK. Let's calculate the absolute
             // value of the specified margin-right % instead of relying on LayoutBox's marginRight() value.
-            value = minimumValueForLength(marginRight, toLayoutBox(renderer)->containingBlockLogicalWidthForContent()).toFloat();
+            value = minimumValueForLength(marginRight, toLayoutBox(layoutObject)->containingBlockLogicalWidthForContent()).toFloat();
         } else {
-            value = toLayoutBox(renderer)->marginRight().toFloat();
+            value = toLayoutBox(layoutObject)->marginRight().toFloat();
         }
         return zoomAdjustedPixelValue(value, style);
     }
     case CSSPropertyMarginBottom: {
         Length marginBottom = style.marginBottom();
-        if (marginBottom.isFixed() || !renderer || !renderer->isBox())
+        if (marginBottom.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginBottom, style);
-        return zoomAdjustedPixelValue(toLayoutBox(renderer)->marginBottom(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginBottom(), style);
     }
     case CSSPropertyMarginLeft: {
         Length marginLeft = style.marginLeft();
-        if (marginLeft.isFixed() || !renderer || !renderer->isBox())
+        if (marginLeft.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(marginLeft, style);
-        return zoomAdjustedPixelValue(toLayoutBox(renderer)->marginLeft(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->marginLeft(), style);
     }
     case CSSPropertyWebkitUserModify:
         return cssValuePool().createValue(style.userModify());
     case CSSPropertyMaxHeight: {
         const Length& maxHeight = style.maxHeight();
         if (maxHeight.isMaxSizeNone())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return zoomAdjustedPixelValueForLength(maxHeight, style);
     }
     case CSSPropertyMaxWidth: {
@@ skipping 39 matching lines @@
     case CSSPropertyOverflow:
         return cssValuePool().createValue(max(style.overflowX(), style.overflowY()));
     case CSSPropertyOverflowWrap:
         return cssValuePool().createValue(style.overflowWrap());
     case CSSPropertyOverflowX:
         return cssValuePool().createValue(style.overflowX());
     case CSSPropertyOverflowY:
         return cssValuePool().createValue(style.overflowY());
     case CSSPropertyPaddingTop: {
         Length paddingTop = style.paddingTop();
-        if (paddingTop.isFixed() || !renderer || !renderer->isBox())
+        if (paddingTop.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingTop, style);
-        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingTop(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingTop(), style);
     }
     case CSSPropertyPaddingRight: {
         Length paddingRight = style.paddingRight();
-        if (paddingRight.isFixed() || !renderer || !renderer->isBox())
+        if (paddingRight.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingRight, style);
-        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingRight(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingRight(), style);
     }
     case CSSPropertyPaddingBottom: {
         Length paddingBottom = style.paddingBottom();
-        if (paddingBottom.isFixed() || !renderer || !renderer->isBox())
+        if (paddingBottom.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingBottom, style);
-        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingBottom(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingBottom(), style);
     }
     case CSSPropertyPaddingLeft: {
         Length paddingLeft = style.paddingLeft();
-        if (paddingLeft.isFixed() || !renderer || !renderer->isBox())
+        if (paddingLeft.isFixed() || !layoutObject || !layoutObject->isBox())
             return zoomAdjustedPixelValueForLength(paddingLeft, style);
-        return zoomAdjustedPixelValue(toLayoutBox(renderer)->computedCSSPaddingLeft(), style);
+        return zoomAdjustedPixelValue(toLayoutBox(layoutObject)->computedCSSPaddingLeft(), style);
     }
     case CSSPropertyPageBreakAfter:
         return cssValuePool().createValue(style.pageBreakAfter());
     case CSSPropertyPageBreakBefore:
         return cssValuePool().createValue(style.pageBreakBefore());
     case CSSPropertyPageBreakInside: {
         EPageBreak pageBreak = style.pageBreakInside();
         ASSERT(pageBreak != PBALWAYS);
         if (pageBreak == PBALWAYS)
             return nullptr;
         return cssValuePool().createValue(style.pageBreakInside());
     }
     case CSSPropertyPosition:
         return cssValuePool().createValue(style.position());
     case CSSPropertyRight:
-        return valueForPositionOffset(style, CSSPropertyRight, renderer);
+        return valueForPositionOffset(style, CSSPropertyRight, layoutObject);
     case CSSPropertyWebkitRubyPosition:
         return cssValuePool().createValue(style.rubyPosition());
     case CSSPropertyScrollBehavior:
         return cssValuePool().createValue(style.scrollBehavior());
     case CSSPropertyScrollBlocksOn:
         return scrollBlocksOnFlagsToCSSValue(style.scrollBlocksOn());
     case CSSPropertyTableLayout:
         return cssValuePool().createValue(style.tableLayout());
     case CSSPropertyTextAlign:
         return cssValuePool().createValue(style.textAlign());
     case CSSPropertyTextAlignLast:
         return cssValuePool().createValue(style.textAlignLast());
     case CSSPropertyTextDecoration:
         if (RuntimeEnabledFeatures::css3TextDecorationsEnabled())
-            return valuesForShorthandProperty(textDecorationShorthand(), style, renderer, styledNode, allowVisitedStyle);
+            return valuesForShorthandProperty(textDecorationShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
         // Fall through.
     case CSSPropertyTextDecorationLine:
         return renderTextDecorationFlagsToCSSValue(style.textDecoration());
     case CSSPropertyTextDecorationStyle:
         return valueForTextDecorationStyle(style.textDecorationStyle());
     case CSSPropertyTextDecorationColor:
         return currentColorOrValidColor(style, style.textDecorationColor());
     case CSSPropertyTextJustify:
         return cssValuePool().createValue(style.textJustify());
     case CSSPropertyTextUnderlinePosition:
@@ skipping 47 matching lines @@
         return cssValuePool().createIdentifierValue(CSSValueClip);
     case CSSPropertyWebkitTextSecurity:
         return cssValuePool().createValue(style.textSecurity());
     case CSSPropertyWebkitTextStrokeColor:
         return currentColorOrValidColor(style, style.textStrokeColor());
     case CSSPropertyWebkitTextStrokeWidth:
         return zoomAdjustedPixelValue(style.textStrokeWidth(), style);
     case CSSPropertyTextTransform:
         return cssValuePool().createValue(style.textTransform());
     case CSSPropertyTop:
-        return valueForPositionOffset(style, CSSPropertyTop, renderer);
+        return valueForPositionOffset(style, CSSPropertyTop, layoutObject);
     case CSSPropertyTouchAction:
         return touchActionFlagsToCSSValue(style.touchAction());
     case CSSPropertyUnicodeBidi:
         return cssValuePool().createValue(style.unicodeBidi());
     case CSSPropertyVerticalAlign:
         switch (style.verticalAlign()) {
         case BASELINE:
             return cssValuePool().createIdentifierValue(CSSValueBaseline);
         case MIDDLE:
             return cssValuePool().createIdentifierValue(CSSValueMiddle);
@@ skipping 16 matching lines @@
         }
         ASSERT_NOT_REACHED();
         return nullptr;
     case CSSPropertyVisibility:
         return cssValuePool().createValue(style.visibility());
     case CSSPropertyWhiteSpace:
         return cssValuePool().createValue(style.whiteSpace());
     case CSSPropertyWidows:
         return cssValuePool().createValue(style.widows(), CSSPrimitiveValue::CSS_NUMBER);
     case CSSPropertyWidth:
-        if (renderer) {
+        if (layoutObject) {
             // According to http://www.w3.org/TR/CSS2/visudet.html#the-width-property,
             // the "width" property does not apply for non-replaced inline elements.
-            if (!renderer->isReplaced() && renderer->isInline())
+            if (!layoutObject->isReplaced() && layoutObject->isInline())
                 return cssValuePool().createIdentifierValue(CSSValueAuto);
-            return zoomAdjustedPixelValue(sizingBox(renderer).width(), style);
+            return zoomAdjustedPixelValue(sizingBox(layoutObject).width(), style);
         }
         return zoomAdjustedPixelValueForLength(style.width(), style);
     case CSSPropertyWillChange:
         return valueForWillChange(style.willChangeProperties(), style.willChangeContents(), style.willChangeScrollPosition());
     case CSSPropertyWordBreak:
         return cssValuePool().createValue(style.wordBreak());
     case CSSPropertyWordSpacing:
         return zoomAdjustedPixelValue(style.wordSpacing(), style);
     case CSSPropertyWordWrap:
         return cssValuePool().createValue(style.overflowWrap());
@@ skipping 166 matching lines @@
         return cssValuePool().createValue(style.marginAfterCollapse());
     case CSSPropertyWebkitMarginTopCollapse:
     case CSSPropertyWebkitMarginBeforeCollapse:
         return cssValuePool().createValue(style.marginBeforeCollapse());
     case CSSPropertyPerspective:
         if (!style.hasPerspective())
             return cssValuePool().createIdentifierValue(CSSValueNone);
         return zoomAdjustedPixelValue(style.perspective(), style);
     case CSSPropertyPerspectiveOrigin: {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-        if (renderer) {
+        if (layoutObject) {
             LayoutRect box;
-            if (renderer->isBox())
-                box = toLayoutBox(renderer)->borderBoxRect();
+            if (layoutObject->isBox())
+                box = toLayoutBox(layoutObject)->borderBoxRect();
 
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginX(), box.width()), style));
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginY(), box.height()), style));
         } else {
             list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginX(), style));
             list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginY(), style));
         }
         return list.release();
     }
     case CSSPropertyWebkitRtlOrdering:
@@ skipping 18 matching lines @@
         RefPtrWillBeRawPtr<Rect> rect = Rect::create();
         rect->setTop(zoomAdjustedPixelValue(style.clip().top().value(), style));
         rect->setRight(zoomAdjustedPixelValue(style.clip().right().value(), style));
         rect->setBottom(zoomAdjustedPixelValue(style.clip().bottom().value(), style));
         rect->setLeft(zoomAdjustedPixelValue(style.clip().left().value(), style));
         return cssValuePool().createValue(rect.release());
     }
     case CSSPropertySpeak:
         return cssValuePool().createValue(style.speak());
     case CSSPropertyTransform:
-        return computedTransform(renderer, style);
+        return computedTransform(layoutObject, style);
     case CSSPropertyTransformOrigin: {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
-        if (renderer) {
+        if (layoutObject) {
             LayoutRect box;
-            if (renderer->isBox())
-                box = toLayoutBox(renderer)->borderBoxRect();
+            if (layoutObject->isBox())
+                box = toLayoutBox(layoutObject)->borderBoxRect();
 
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginX(), box.width()), style));
             list->append(zoomAdjustedPixelValue(minimumValueForLength(style.transformOriginY(), box.height()), style));
             if (style.transformOriginZ() != 0)
                 list->append(zoomAdjustedPixelValue(style.transformOriginZ(), style));
         } else {
             list->append(zoomAdjustedPixelValueForLength(style.transformOriginX(), style));
             list->append(zoomAdjustedPixelValueForLength(style.transformOriginY(), style));
             if (style.transformOriginZ() != 0)
                 list->append(zoomAdjustedPixelValue(style.transformOriginZ(), style));
@@ skipping 68 matching lines @@
     case CSSPropertyMixBlendMode:
         return cssValuePool().createValue(style.blendMode());
 
     case CSSPropertyBackgroundBlendMode: {
         RefPtrWillBeRawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
         for (const FillLayer* currLayer = &style.backgroundLayers(); currLayer; currLayer = currLayer->next())
             list->append(cssValuePool().createValue(currLayer->blendMode()));
         return list.release();
     }
     case CSSPropertyBackground:
-        return valuesForBackgroundShorthand(style, renderer, styledNode, allowVisitedStyle);
+        return valuesForBackgroundShorthand(style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorder: {
-        RefPtrWillBeRawPtr<CSSValue> value = get(CSSPropertyBorderTop, style, renderer, styledNode, allowVisitedStyle);
+        RefPtrWillBeRawPtr<CSSValue> value = get(CSSPropertyBorderTop, style, layoutObject, styledNode, allowVisitedStyle);
         const CSSPropertyID properties[] = {
             CSSPropertyBorderRight,
             CSSPropertyBorderBottom,
             CSSPropertyBorderLeft
         };
         for (size_t i = 0; i < WTF_ARRAY_LENGTH(properties); ++i) {
-            if (!compareCSSValuePtr<CSSValue>(value, get(properties[i], style, renderer, styledNode, allowVisitedStyle)))
+            if (!compareCSSValuePtr<CSSValue>(value, get(properties[i], style, layoutObject, styledNode, allowVisitedStyle)))
                 return nullptr;
         }
         return value.release();
     }
     case CSSPropertyBorderBottom:
-        return valuesForShorthandProperty(borderBottomShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(borderBottomShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderColor:
-        return valuesForSidesShorthand(borderColorShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForSidesShorthand(borderColorShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderLeft:
-        return valuesForShorthandProperty(borderLeftShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(borderLeftShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderImage:
         return valueForNinePieceImage(style.borderImage(), style);
     case CSSPropertyBorderRadius:
         return valueForBorderRadiusShorthand(style);
     case CSSPropertyBorderRight:
-        return valuesForShorthandProperty(borderRightShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(borderRightShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderStyle:
-        return valuesForSidesShorthand(borderStyleShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForSidesShorthand(borderStyleShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderTop:
-        return valuesForShorthandProperty(borderTopShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(borderTopShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyBorderWidth:
-        return valuesForSidesShorthand(borderWidthShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForSidesShorthand(borderWidthShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyWebkitColumnRule:
-        return valuesForShorthandProperty(webkitColumnRuleShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(webkitColumnRuleShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyWebkitColumns:
-        return valuesForShorthandProperty(webkitColumnsShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(webkitColumnsShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyListStyle:
-        return valuesForShorthandProperty(listStyleShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(listStyleShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyMargin:
-        return valuesForSidesShorthand(marginShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForSidesShorthand(marginShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyOutline:
-        return valuesForShorthandProperty(outlineShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(outlineShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     case CSSPropertyPadding:
-        return valuesForSidesShorthand(paddingShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForSidesShorthand(paddingShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
     // Individual properties not part of the spec.
     case CSSPropertyBackgroundRepeatX:
     case CSSPropertyBackgroundRepeatY:
         return nullptr;
 
     case CSSPropertyMotion:
         ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());
-        return valuesForShorthandProperty(motionShorthand(), style, renderer, styledNode, allowVisitedStyle);
+        return valuesForShorthandProperty(motionShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
 
     case CSSPropertyMotionPath: {
         ASSERT(RuntimeEnabledFeatures::cssMotionPathEnabled());
         const StyleMotionPath* styleMotionPath = style.motionPath();
         if (!styleMotionPath)
             return cssValuePool().createIdentifierValue(CSSValueNone);
 
         ASSERT(styleMotionPath->isPathStyleMotionPath());
         return CSSPathValue::create(toPathStyleMotionPath(styleMotionPath)->pathString());
     }
@@ skipping 206 matching lines @@
     case CSSPropertyAll:
         return nullptr;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 }