| Index: third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp
|
| diff --git a/third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp b/third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp
|
| index bcb26d904607fdda8ceffc27e4e0fec3704407a6..fd98dbffd850fbc4cf484b8ddcfdbc3002926729 100644
|
| --- a/third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp
|
| +++ b/third_party/WebKit/Source/core/css/ComputedStyleCSSValueMapping.cpp
|
| @@ -65,24 +65,24 @@ inline static bool isFlexOrGrid(const ComputedStyle* style)
|
| return style && style->isDisplayFlexibleOrGridBox();
|
| }
|
|
|
| -inline static RawPtr<CSSPrimitiveValue> zoomAdjustedPixelValue(double value, const ComputedStyle& style)
|
| +inline static CSSPrimitiveValue* zoomAdjustedPixelValue(double value, const ComputedStyle& style)
|
| {
|
| return cssValuePool().createValue(adjustFloatForAbsoluteZoom(value, style), CSSPrimitiveValue::UnitType::Pixels);
|
| }
|
|
|
| -inline static RawPtr<CSSPrimitiveValue> zoomAdjustedNumberValue(double value, const ComputedStyle& style)
|
| +inline static CSSPrimitiveValue* zoomAdjustedNumberValue(double value, const ComputedStyle& style)
|
| {
|
| return cssValuePool().createValue(value / style.effectiveZoom(), CSSPrimitiveValue::UnitType::Number);
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> zoomAdjustedPixelValueForLength(const Length& length, const ComputedStyle& style)
|
| +static CSSPrimitiveValue* zoomAdjustedPixelValueForLength(const Length& length, const ComputedStyle& style)
|
| {
|
| if (length.isFixed())
|
| return zoomAdjustedPixelValue(length.value(), style);
|
| return cssValuePool().createValue(length, style);
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> pixelValueForUnzoomedLength(const UnzoomedLength& unzoomedLength, const ComputedStyle& style)
|
| +static CSSPrimitiveValue* pixelValueForUnzoomedLength(const UnzoomedLength& unzoomedLength, const ComputedStyle& style)
|
| {
|
| const Length& length = unzoomedLength.length();
|
| if (length.isFixed())
|
| @@ -90,9 +90,9 @@ static RawPtr<CSSPrimitiveValue> pixelValueForUnzoomedLength(const UnzoomedLengt
|
| return cssValuePool().createValue(length, style);
|
| }
|
|
|
| -static RawPtr<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const ComputedStyle& style)
|
| +static CSSValueList* createPositionListForLayer(CSSPropertyID propertyID, const FillLayer& layer, const ComputedStyle& style)
|
| {
|
| - RawPtr<CSSValueList> positionList = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* positionList = CSSValueList::createSpaceSeparated();
|
| if (layer.isBackgroundXOriginSet()) {
|
| ASSERT_UNUSED(propertyID, propertyID == CSSPropertyBackgroundPosition || propertyID == CSSPropertyWebkitMaskPosition);
|
| positionList->append(cssValuePool().createValue(layer.backgroundXOrigin()));
|
| @@ -103,16 +103,16 @@ static RawPtr<CSSValueList> createPositionListForLayer(CSSPropertyID propertyID,
|
| positionList->append(cssValuePool().createValue(layer.backgroundYOrigin()));
|
| }
|
| positionList->append(zoomAdjustedPixelValueForLength(layer.yPosition(), style));
|
| - return positionList.release();
|
| + return positionList;
|
| }
|
|
|
| -RawPtr<CSSValue> ComputedStyleCSSValueMapping::currentColorOrValidColor(const ComputedStyle& style, const StyleColor& color)
|
| +CSSValue* ComputedStyleCSSValueMapping::currentColorOrValidColor(const ComputedStyle& style, const StyleColor& color)
|
| {
|
| // This function does NOT look at visited information, so that computed style doesn't expose that.
|
| return cssValuePool().createColorValue(color.resolve(style.color()).rgb());
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForFillSize(const FillSize& fillSize, const ComputedStyle& style)
|
| +static CSSValue* valueForFillSize(const FillSize& fillSize, const ComputedStyle& style)
|
| {
|
| if (fillSize.type == Contain)
|
| return cssValuePool().createIdentifierValue(CSSValueContain);
|
| @@ -123,13 +123,13 @@ static RawPtr<CSSValue> valueForFillSize(const FillSize& fillSize, const Compute
|
| if (fillSize.size.height().isAuto())
|
| return zoomAdjustedPixelValueForLength(fillSize.size.width(), style);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(zoomAdjustedPixelValueForLength(fillSize.size.width(), style));
|
| list->append(zoomAdjustedPixelValueForLength(fillSize.size.height(), style));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForFillRepeat(EFillRepeat xRepeat, EFillRepeat yRepeat)
|
| +static CSSValue* valueForFillRepeat(EFillRepeat xRepeat, EFillRepeat yRepeat)
|
| {
|
| // For backwards compatibility, if both values are equal, just return one of them. And
|
| // if the two values are equivalent to repeat-x or repeat-y, just return the shorthand.
|
| @@ -140,13 +140,13 @@ static RawPtr<CSSValue> valueForFillRepeat(EFillRepeat xRepeat, EFillRepeat yRep
|
| if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)
|
| return cssValuePool().createIdentifierValue(CSSValueRepeatY);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(cssValuePool().createValue(xRepeat));
|
| list->append(cssValuePool().createValue(yRepeat));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForFillSourceType(EMaskSourceType type)
|
| +static CSSValue* valueForFillSourceType(EMaskSourceType type)
|
| {
|
| switch (type) {
|
| case MaskAlpha:
|
| @@ -160,7 +160,7 @@ static RawPtr<CSSValue> valueForFillSourceType(EMaskSourceType type)
|
| return nullptr;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* layoutObject)
|
| +static CSSValue* valueForPositionOffset(const ComputedStyle& style, CSSPropertyID propertyID, const LayoutObject* layoutObject)
|
| {
|
| Length offset, opposite;
|
| switch (propertyID) {
|
| @@ -250,13 +250,13 @@ static RawPtr<CSSValue> valueForPositionOffset(const ComputedStyle& style, CSSPr
|
| return zoomAdjustedPixelValueForLength(offset, style);
|
| }
|
|
|
| -static RawPtr<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const NinePieceImage& image)
|
| +static CSSBorderImageSliceValue* valueForNinePieceImageSlice(const NinePieceImage& image)
|
| {
|
| // Create the slices.
|
| - RawPtr<CSSPrimitiveValue> top = nullptr;
|
| - RawPtr<CSSPrimitiveValue> right = nullptr;
|
| - RawPtr<CSSPrimitiveValue> bottom = nullptr;
|
| - RawPtr<CSSPrimitiveValue> left = nullptr;
|
| + CSSPrimitiveValue* top = nullptr;
|
| + CSSPrimitiveValue* right = nullptr;
|
| + CSSPrimitiveValue* bottom = nullptr;
|
| + CSSPrimitiveValue* left = nullptr;
|
|
|
| // TODO(alancutter): Make this code aware of calc lengths.
|
| if (image.imageSlices().top().hasPercent())
|
| @@ -295,16 +295,16 @@ static RawPtr<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const NinePi
|
| }
|
| }
|
|
|
| - return CSSBorderImageSliceValue::create(CSSQuadValue::create(top.release(), right.release(), bottom.release(), left.release(), CSSQuadValue::SerializeAsQuad), image.fill());
|
| + return CSSBorderImageSliceValue::create(CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsQuad), image.fill());
|
| }
|
|
|
| -static RawPtr<CSSQuadValue> valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
|
| +static CSSQuadValue* valueForNinePieceImageQuad(const BorderImageLengthBox& box, const ComputedStyle& style)
|
| {
|
| // Create the slices.
|
| - RawPtr<CSSPrimitiveValue> top = nullptr;
|
| - RawPtr<CSSPrimitiveValue> right = nullptr;
|
| - RawPtr<CSSPrimitiveValue> bottom = nullptr;
|
| - RawPtr<CSSPrimitiveValue> left = nullptr;
|
| + CSSPrimitiveValue* top = nullptr;
|
| + CSSPrimitiveValue* right = nullptr;
|
| + CSSPrimitiveValue* bottom = nullptr;
|
| + CSSPrimitiveValue* left = nullptr;
|
|
|
| if (box.top().isNumber())
|
| top = cssValuePool().createValue(box.top().number(), CSSPrimitiveValue::UnitType::Number);
|
| @@ -341,7 +341,7 @@ static RawPtr<CSSQuadValue> valueForNinePieceImageQuad(const BorderImageLengthBo
|
| }
|
| }
|
|
|
| - return CSSQuadValue::create(top.release(), right.release(), bottom.release(), left.release(), CSSQuadValue::SerializeAsQuad);
|
| + return CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsQuad);
|
| }
|
|
|
| static CSSValueID valueForRepeatRule(int rule)
|
| @@ -358,57 +358,57 @@ static CSSValueID valueForRepeatRule(int rule)
|
| }
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForNinePieceImageRepeat(const NinePieceImage& image)
|
| +static CSSValue* valueForNinePieceImageRepeat(const NinePieceImage& image)
|
| {
|
| - RawPtr<CSSPrimitiveValue> horizontalRepeat = nullptr;
|
| - RawPtr<CSSPrimitiveValue> verticalRepeat = nullptr;
|
| + CSSPrimitiveValue* horizontalRepeat = nullptr;
|
| + CSSPrimitiveValue* verticalRepeat = nullptr;
|
|
|
| horizontalRepeat = cssValuePool().createIdentifierValue(valueForRepeatRule(image.horizontalRule()));
|
| if (image.horizontalRule() == image.verticalRule())
|
| verticalRepeat = horizontalRepeat;
|
| else
|
| verticalRepeat = cssValuePool().createIdentifierValue(valueForRepeatRule(image.verticalRule()));
|
| - return CSSValuePair::create(horizontalRepeat.release(), verticalRepeat.release(), CSSValuePair::DropIdenticalValues);
|
| + return CSSValuePair::create(horizontalRepeat, verticalRepeat, CSSValuePair::DropIdenticalValues);
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForNinePieceImage(const NinePieceImage& image, const ComputedStyle& style)
|
| +static CSSValue* valueForNinePieceImage(const NinePieceImage& image, const ComputedStyle& style)
|
| {
|
| if (!image.hasImage())
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
|
|
| // Image first.
|
| - RawPtr<CSSValue> imageValue = nullptr;
|
| + CSSValue* imageValue = nullptr;
|
| if (image.image())
|
| imageValue = image.image()->computedCSSValue();
|
|
|
| // Create the image slice.
|
| - RawPtr<CSSBorderImageSliceValue> imageSlices = valueForNinePieceImageSlice(image);
|
| + CSSBorderImageSliceValue* imageSlices = valueForNinePieceImageSlice(image);
|
|
|
| // Create the border area slices.
|
| - RawPtr<CSSValue> borderSlices = valueForNinePieceImageQuad(image.borderSlices(), style);
|
| + CSSValue* borderSlices = valueForNinePieceImageQuad(image.borderSlices(), style);
|
|
|
| // Create the border outset.
|
| - RawPtr<CSSValue> outset = valueForNinePieceImageQuad(image.outset(), style);
|
| + CSSValue* outset = valueForNinePieceImageQuad(image.outset(), style);
|
|
|
| // Create the repeat rules.
|
| - RawPtr<CSSValue> repeat = valueForNinePieceImageRepeat(image);
|
| + CSSValue* repeat = valueForNinePieceImageRepeat(image);
|
|
|
| - return createBorderImageValue(imageValue.release(), imageSlices.release(), borderSlices.release(), outset.release(), repeat.release());
|
| + return createBorderImageValue(imageValue, imageSlices, borderSlices, outset, repeat);
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForReflection(const StyleReflection* reflection, const ComputedStyle& style)
|
| +static CSSValue* valueForReflection(const StyleReflection* reflection, const ComputedStyle& style)
|
| {
|
| if (!reflection)
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
|
|
| - RawPtr<CSSPrimitiveValue> offset = nullptr;
|
| + CSSPrimitiveValue* offset = nullptr;
|
| // TODO(alancutter): Make this work correctly for calc lengths.
|
| if (reflection->offset().hasPercent())
|
| offset = cssValuePool().createValue(reflection->offset().percent(), CSSPrimitiveValue::UnitType::Percentage);
|
| else
|
| offset = zoomAdjustedPixelValue(reflection->offset().value(), style);
|
|
|
| - RawPtr<CSSPrimitiveValue> direction = nullptr;
|
| + CSSPrimitiveValue* direction = nullptr;
|
| switch (reflection->direction()) {
|
| case ReflectionBelow:
|
| direction = cssValuePool().createIdentifierValue(CSSValueBelow);
|
| @@ -424,7 +424,7 @@ static RawPtr<CSSValue> valueForReflection(const StyleReflection* reflection, co
|
| break;
|
| }
|
|
|
| - return CSSReflectValue::create(direction.release(), offset.release(), valueForNinePieceImage(reflection->mask(), style));
|
| + return CSSReflectValue::create(direction, offset, valueForNinePieceImage(reflection->mask(), style));
|
| }
|
|
|
| static ItemPosition resolveAlignmentAuto(ItemPosition position, const ComputedStyle* style)
|
| @@ -438,49 +438,49 @@ static ItemPosition resolveAlignmentAuto(ItemPosition position, const ComputedSt
|
| return isFlexOrGrid(style) ? ItemPositionStretch : ItemPositionStart;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
|
| +static CSSValueList* valueForItemPositionWithOverflowAlignment(ItemPosition itemPosition, OverflowAlignment overflowAlignment, ItemPositionType positionType)
|
| {
|
| - RawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
|
| + 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();
|
| + return result;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valuesForGridShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| +static CSSValueList* valuesForGridShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
|
| + CSSValueList* list = CSSValueList::createSlashSeparated();
|
| for (size_t i = 0; i < shorthand.length(); ++i) {
|
| - RawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
|
| ASSERT(value);
|
| - list->append(value.release());
|
| + list->append(value);
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valuesForShorthandProperty(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| +static CSSValueList* valuesForShorthandProperty(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| for (size_t i = 0; i < shorthand.length(); ++i) {
|
| - RawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* value = ComputedStyleCSSValueMapping::get(shorthand.properties()[i], style, layoutObject, styledNode, allowVisitedStyle);
|
| ASSERT(value);
|
| list->append(value);
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valuesForBackgroundShorthand(const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| +static CSSValueList* valuesForBackgroundShorthand(const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| {
|
| - RawPtr<CSSValueList> ret = CSSValueList::createCommaSeparated();
|
| + CSSValueList* ret = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next()) {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
|
| - RawPtr<CSSValueList> beforeSlash = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSlashSeparated();
|
| + CSSValueList* beforeSlash = CSSValueList::createSpaceSeparated();
|
| if (!currLayer->next()) { // color only for final layer
|
| - RawPtr<CSSValue> value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* value = ComputedStyleCSSValueMapping::get(CSSPropertyBackgroundColor, style, layoutObject, styledNode, allowVisitedStyle);
|
| ASSERT(value);
|
| beforeSlash->append(value);
|
| }
|
| @@ -489,19 +489,19 @@ static RawPtr<CSSValueList> valuesForBackgroundShorthand(const ComputedStyle& st
|
| beforeSlash->append(cssValuePool().createValue(currLayer->attachment()));
|
| beforeSlash->append(createPositionListForLayer(CSSPropertyBackgroundPosition, *currLayer, style));
|
| list->append(beforeSlash);
|
| - RawPtr<CSSValueList> afterSlash = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* afterSlash = CSSValueList::createSpaceSeparated();
|
| afterSlash->append(valueForFillSize(currLayer->size(), style));
|
| afterSlash->append(cssValuePool().createValue(currLayer->origin()));
|
| afterSlash->append(cssValuePool().createValue(currLayer->clip()));
|
| list->append(afterSlash);
|
| ret->append(list);
|
| }
|
| - return ret.release();
|
| + return ret;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valueForContentPositionAndDistributionWithOverflowAlignment(const StyleContentAlignmentData& data)
|
| +static CSSValueList* valueForContentPositionAndDistributionWithOverflowAlignment(const StyleContentAlignmentData& data)
|
| {
|
| - RawPtr<CSSValueList> result = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* result = CSSValueList::createSpaceSeparated();
|
| if (data.distribution() != ContentDistributionDefault)
|
| result->append(CSSPrimitiveValue::create(data.distribution()));
|
| if (data.distribution() == ContentDistributionDefault || data.position() != ContentPositionNormal)
|
| @@ -510,10 +510,10 @@ static RawPtr<CSSValueList> valueForContentPositionAndDistributionWithOverflowAl
|
| result->append(CSSPrimitiveValue::create(data.overflow()));
|
| ASSERT(result->length() > 0);
|
| ASSERT(result->length() <= 3);
|
| - return result.release();
|
| + return result;
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> valueForLineHeight(const ComputedStyle& style)
|
| +static CSSPrimitiveValue* valueForLineHeight(const ComputedStyle& style)
|
| {
|
| Length length = style.lineHeight();
|
| if (length.isNegative())
|
| @@ -539,48 +539,48 @@ static CSSValueID identifierForFamily(const AtomicString& family)
|
| return CSSValueInvalid;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForFamily(const AtomicString& family)
|
| +static CSSValue* valueForFamily(const AtomicString& family)
|
| {
|
| if (CSSValueID familyIdentifier = identifierForFamily(family))
|
| return cssValuePool().createIdentifierValue(familyIdentifier);
|
| return cssValuePool().createFontFamilyValue(family.getString());
|
| }
|
|
|
| -static RawPtr<CSSValueList> valueForFontFamily(const ComputedStyle& style)
|
| +static CSSValueList* valueForFontFamily(const ComputedStyle& style)
|
| {
|
| const FontFamily& firstFamily = style.getFontDescription().family();
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| for (const FontFamily* family = &firstFamily; family; family = family->next())
|
| list->append(valueForFamily(family->family()));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> valueForFontSize(const ComputedStyle& style)
|
| +static CSSPrimitiveValue* valueForFontSize(const ComputedStyle& style)
|
| {
|
| return zoomAdjustedPixelValue(style.getFontDescription().computedSize(), style);
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> valueForFontStretch(const ComputedStyle& style)
|
| +static CSSPrimitiveValue* valueForFontStretch(const ComputedStyle& style)
|
| {
|
| return cssValuePool().createValue(style.getFontDescription().stretch());
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> valueForFontStyle(const ComputedStyle& style)
|
| +static CSSPrimitiveValue* valueForFontStyle(const ComputedStyle& style)
|
| {
|
| return cssValuePool().createValue(style.getFontDescription().style());
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> valueForFontVariant(const ComputedStyle& style)
|
| +static CSSPrimitiveValue* valueForFontVariant(const ComputedStyle& style)
|
| {
|
| return cssValuePool().createValue(style.getFontDescription().variant());
|
| }
|
|
|
| -static RawPtr<CSSPrimitiveValue> valueForFontWeight(const ComputedStyle& style)
|
| +static CSSPrimitiveValue* valueForFontWeight(const ComputedStyle& style)
|
| {
|
| return cssValuePool().createValue(style.getFontDescription().weight());
|
| }
|
|
|
| -static RawPtr<CSSValue> specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const ComputedStyle& style)
|
| +static CSSValue* specifiedValueForGridTrackBreadth(const GridLength& trackBreadth, const ComputedStyle& style)
|
| {
|
| if (!trackBreadth.isLength())
|
| return cssValuePool().createValue(trackBreadth.flex(), CSSPrimitiveValue::UnitType::Fraction);
|
| @@ -591,16 +591,16 @@ static RawPtr<CSSValue> specifiedValueForGridTrackBreadth(const GridLength& trac
|
| return zoomAdjustedPixelValueForLength(trackBreadthLength, style);
|
| }
|
|
|
| -static RawPtr<CSSValue> specifiedValueForGridTrackSize(const GridTrackSize& trackSize, const ComputedStyle& style)
|
| +static CSSValue* specifiedValueForGridTrackSize(const GridTrackSize& trackSize, const ComputedStyle& style)
|
| {
|
| switch (trackSize.type()) {
|
| case LengthTrackSizing:
|
| return specifiedValueForGridTrackBreadth(trackSize.length(), style);
|
| case MinMaxTrackSizing:
|
| - RawPtr<CSSFunctionValue> minMaxTrackBreadths = CSSFunctionValue::create(CSSValueMinmax);
|
| + CSSFunctionValue* minMaxTrackBreadths = CSSFunctionValue::create(CSSValueMinmax);
|
| minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.minTrackBreadth(), style));
|
| minMaxTrackBreadths->append(specifiedValueForGridTrackBreadth(trackSize.maxTrackBreadth(), style));
|
| - return minMaxTrackBreadths.release();
|
| + return minMaxTrackBreadths;
|
| }
|
| ASSERT_NOT_REACHED();
|
| return nullptr;
|
| @@ -612,13 +612,13 @@ static void addValuesForNamedGridLinesAtIndex(const OrderedNamedGridLines& order
|
| if (namedGridLines.isEmpty())
|
| return;
|
|
|
| - RawPtr<CSSGridLineNamesValue> lineNames = CSSGridLineNamesValue::create();
|
| + CSSGridLineNamesValue* lineNames = CSSGridLineNamesValue::create();
|
| for (size_t j = 0; j < namedGridLines.size(); ++j)
|
| lineNames->append(CSSCustomIdentValue::create(namedGridLines[j]));
|
| - list.append(lineNames.release());
|
| + list.append(lineNames);
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction, const LayoutObject* layoutObject, const ComputedStyle& style)
|
| +static CSSValue* valueForGridTrackList(GridTrackSizingDirection direction, const LayoutObject* layoutObject, const ComputedStyle& style)
|
| {
|
| bool isRowAxis = direction == ForColumns;
|
| const Vector<GridTrackSize>& trackSizes = isRowAxis ? style.gridTemplateColumns() : style.gridTemplateRows();
|
| @@ -641,7 +641,7 @@ static RawPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| }
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| size_t insertionIndex;
|
| if (isLayoutGrid) {
|
| const Vector<LayoutUnit>& trackPositions = direction == ForColumns ? toLayoutGrid(layoutObject)->columnPositions() : toLayoutGrid(layoutObject)->rowPositions();
|
| @@ -668,10 +668,10 @@ static RawPtr<CSSValue> valueForGridTrackList(GridTrackSizingDirection direction
|
| }
|
| // Those are the trailing <string>* allowed in the syntax.
|
| addValuesForNamedGridLinesAtIndex(orderedNamedGridLines, insertionIndex, *list);
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForGridPosition(const GridPosition& position)
|
| +static CSSValue* valueForGridPosition(const GridPosition& position)
|
| {
|
| if (position.isAuto())
|
| return cssValuePool().createIdentifierValue(CSSValueAuto);
|
| @@ -679,7 +679,7 @@ static RawPtr<CSSValue> valueForGridPosition(const GridPosition& position)
|
| if (position.isNamedGridArea())
|
| return CSSCustomIdentValue::create(position.namedGridLine());
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (position.isSpan()) {
|
| list->append(cssValuePool().createIdentifierValue(CSSValueSpan));
|
| list->append(cssValuePool().createValue(position.spanPosition(), CSSPrimitiveValue::UnitType::Number));
|
| @@ -701,10 +701,10 @@ static LayoutRect sizingBox(const LayoutObject* layoutObject)
|
| return box->style()->boxSizing() == BoxSizingBorderBox ? box->borderBoxRect() : box->computedCSSContentBoxRect();
|
| }
|
|
|
| -static RawPtr<CSSValue> renderTextDecorationFlagsToCSSValue(int textDecoration)
|
| +static CSSValue* renderTextDecorationFlagsToCSSValue(int textDecoration)
|
| {
|
| // Blink value is ignored.
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (textDecoration & TextDecorationUnderline)
|
| list->append(cssValuePool().createIdentifierValue(CSSValueUnderline));
|
| if (textDecoration & TextDecorationOverline)
|
| @@ -714,10 +714,10 @@ static RawPtr<CSSValue> renderTextDecorationFlagsToCSSValue(int textDecoration)
|
|
|
| if (!list->length())
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForTextDecorationStyle(TextDecorationStyle textDecorationStyle)
|
| +static CSSValue* valueForTextDecorationStyle(TextDecorationStyle textDecorationStyle)
|
| {
|
| switch (textDecorationStyle) {
|
| case TextDecorationStyleSolid:
|
| @@ -736,9 +736,9 @@ static RawPtr<CSSValue> valueForTextDecorationStyle(TextDecorationStyle textDeco
|
| return cssValuePool().createExplicitInitialValue();
|
| }
|
|
|
| -static RawPtr<CSSValue> touchActionFlagsToCSSValue(TouchAction touchAction)
|
| +static CSSValue* touchActionFlagsToCSSValue(TouchAction touchAction)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (touchAction == TouchActionAuto) {
|
| list->append(cssValuePool().createIdentifierValue(CSSValueAuto));
|
| } else if (touchAction == TouchActionNone) {
|
| @@ -761,12 +761,12 @@ static RawPtr<CSSValue> touchActionFlagsToCSSValue(TouchAction touchAction)
|
| list->append(cssValuePool().createIdentifierValue(CSSValuePanDown));
|
| }
|
| ASSERT(list->length());
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForWillChange(const Vector<CSSPropertyID>& willChangeProperties, bool willChangeContents, bool willChangeScrollPosition)
|
| +static CSSValue* valueForWillChange(const Vector<CSSPropertyID>& willChangeProperties, bool willChangeContents, bool willChangeScrollPosition)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| if (willChangeContents)
|
| list->append(cssValuePool().createIdentifierValue(CSSValueContents));
|
| if (willChangeScrollPosition)
|
| @@ -775,22 +775,22 @@ static RawPtr<CSSValue> valueForWillChange(const Vector<CSSPropertyID>& willChan
|
| list->append(cssValuePool().createIdentifierValue(willChangeProperties[i]));
|
| if (!list->length())
|
| list->append(cssValuePool().createIdentifierValue(CSSValueAuto));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForAnimationDelay(const CSSTimingData* timingData)
|
| +static CSSValue* valueForAnimationDelay(const CSSTimingData* timingData)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| if (timingData) {
|
| for (size_t i = 0; i < timingData->delayList().size(); ++i)
|
| list->append(cssValuePool().createValue(timingData->delayList()[i], CSSPrimitiveValue::UnitType::Seconds));
|
| } else {
|
| list->append(cssValuePool().createValue(CSSTimingData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForAnimationDirection(Timing::PlaybackDirection direction)
|
| +static CSSValue* valueForAnimationDirection(Timing::PlaybackDirection direction)
|
| {
|
| switch (direction) {
|
| case Timing::PlaybackDirectionNormal:
|
| @@ -807,19 +807,19 @@ static RawPtr<CSSValue> valueForAnimationDirection(Timing::PlaybackDirection dir
|
| }
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForAnimationDuration(const CSSTimingData* timingData)
|
| +static CSSValue* valueForAnimationDuration(const CSSTimingData* timingData)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| if (timingData) {
|
| for (size_t i = 0; i < timingData->durationList().size(); ++i)
|
| list->append(cssValuePool().createValue(timingData->durationList()[i], CSSPrimitiveValue::UnitType::Seconds));
|
| } else {
|
| list->append(cssValuePool().createValue(CSSTimingData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForAnimationFillMode(Timing::FillMode fillMode)
|
| +static CSSValue* valueForAnimationFillMode(Timing::FillMode fillMode)
|
| {
|
| switch (fillMode) {
|
| case Timing::FillModeNone:
|
| @@ -836,14 +836,14 @@ static RawPtr<CSSValue> valueForAnimationFillMode(Timing::FillMode fillMode)
|
| }
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForAnimationIterationCount(double iterationCount)
|
| +static CSSValue* valueForAnimationIterationCount(double iterationCount)
|
| {
|
| if (iterationCount == std::numeric_limits<double>::infinity())
|
| return cssValuePool().createIdentifierValue(CSSValueInfinite);
|
| return cssValuePool().createValue(iterationCount, CSSPrimitiveValue::UnitType::Number);
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForAnimationPlayState(EAnimPlayState playState)
|
| +static CSSValue* valueForAnimationPlayState(EAnimPlayState playState)
|
| {
|
| if (playState == AnimPlayStatePlaying)
|
| return cssValuePool().createIdentifierValue(CSSValueRunning);
|
| @@ -851,7 +851,7 @@ static RawPtr<CSSValue> valueForAnimationPlayState(EAnimPlayState playState)
|
| return cssValuePool().createIdentifierValue(CSSValuePaused);
|
| }
|
|
|
| -static RawPtr<CSSValue> createTimingFunctionValue(const TimingFunction* timingFunction)
|
| +static CSSValue* createTimingFunctionValue(const TimingFunction* timingFunction)
|
| {
|
| switch (timingFunction->type()) {
|
| case TimingFunction::kCubicBezierFunction:
|
| @@ -899,21 +899,21 @@ static RawPtr<CSSValue> createTimingFunctionValue(const TimingFunction* timingFu
|
| }
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForAnimationTimingFunction(const CSSTimingData* timingData)
|
| +static CSSValue* valueForAnimationTimingFunction(const CSSTimingData* timingData)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| if (timingData) {
|
| for (size_t i = 0; i < timingData->timingFunctionList().size(); ++i)
|
| list->append(createTimingFunctionValue(timingData->timingFunctionList()[i].get()));
|
| } else {
|
| list->append(createTimingFunctionValue(CSSTimingData::initialTimingFunction().get()));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valuesForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
|
| +static CSSValueList* valuesForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (radius.width().type() == Percent)
|
| list->append(cssValuePool().createValue(radius.width().percent(), CSSPrimitiveValue::UnitType::Percentage));
|
| else
|
| @@ -922,20 +922,20 @@ static RawPtr<CSSValueList> valuesForBorderRadiusCorner(LengthSize radius, const
|
| list->append(cssValuePool().createValue(radius.height().percent(), CSSPrimitiveValue::UnitType::Percentage));
|
| else
|
| list->append(zoomAdjustedPixelValueForLength(radius.height(), style));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
|
| +static CSSValue* valueForBorderRadiusCorner(LengthSize radius, const ComputedStyle& style)
|
| {
|
| - RawPtr<CSSValueList> list = valuesForBorderRadiusCorner(radius, style);
|
| + CSSValueList* list = valuesForBorderRadiusCorner(radius, style);
|
| if (list->item(0)->equals(*list->item(1)))
|
| return list->item(0);
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSFunctionValue> valueForMatrixTransform(const TransformationMatrix& transform, const ComputedStyle& style)
|
| +static CSSFunctionValue* valueForMatrixTransform(const TransformationMatrix& transform, const ComputedStyle& style)
|
| {
|
| - RawPtr<CSSFunctionValue> transformValue = nullptr;
|
| + CSSFunctionValue* transformValue = nullptr;
|
| if (transform.isAffine()) {
|
| transformValue = CSSFunctionValue::create(CSSValueMatrix);
|
|
|
| @@ -969,10 +969,10 @@ static RawPtr<CSSFunctionValue> valueForMatrixTransform(const TransformationMatr
|
| transformValue->append(cssValuePool().createValue(transform.m44(), CSSPrimitiveValue::UnitType::Number));
|
| }
|
|
|
| - return transformValue.release();
|
| + return transformValue;
|
| }
|
|
|
| -static RawPtr<CSSValue> computedTransform(const LayoutObject* layoutObject, const ComputedStyle& style)
|
| +static CSSValue* computedTransform(const LayoutObject* layoutObject, const ComputedStyle& style)
|
| {
|
| if (!layoutObject || !style.hasTransform())
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| @@ -985,13 +985,13 @@ static RawPtr<CSSValue> computedTransform(const LayoutObject* layoutObject, cons
|
| style.applyTransform(transform, LayoutSize(box.size()), ComputedStyle::ExcludeTransformOrigin, ComputedStyle::ExcludeMotionPath, ComputedStyle::ExcludeIndependentTransformProperties);
|
|
|
| // FIXME: Need to print out individual functions (https://bugs.webkit.org/show_bug.cgi?id=23924)
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(valueForMatrixTransform(transform, style));
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
|
| +static CSSValue* createTransitionPropertyValue(const CSSTransitionData::TransitionProperty& property)
|
| {
|
| if (property.propertyType == CSSTransitionData::TransitionNone)
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| @@ -1001,16 +1001,16 @@ static RawPtr<CSSValue> createTransitionPropertyValue(const CSSTransitionData::T
|
| return CSSCustomIdentValue::create(getPropertyNameString(property.unresolvedProperty));
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForTransitionProperty(const CSSTransitionData* transitionData)
|
| +static CSSValue* valueForTransitionProperty(const CSSTransitionData* transitionData)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| if (transitionData) {
|
| for (size_t i = 0; i < transitionData->propertyList().size(); ++i)
|
| list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
|
| } else {
|
| list->append(cssValuePool().createIdentifierValue(CSSValueAll));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| CSSValueID valueForQuoteType(const QuoteType quoteType)
|
| @@ -1029,20 +1029,20 @@ CSSValueID valueForQuoteType(const QuoteType quoteType)
|
| return CSSValueInvalid;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForContentData(const ComputedStyle& style)
|
| +static CSSValue* valueForContentData(const ComputedStyle& style)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| for (const ContentData* contentData = style.contentData(); contentData; contentData = contentData->next()) {
|
| if (contentData->isCounter()) {
|
| const CounterContent* counter = toCounterContentData(contentData)->counter();
|
| ASSERT(counter);
|
| - RawPtr<CSSCustomIdentValue> identifier = CSSCustomIdentValue::create(counter->identifier());
|
| - RawPtr<CSSCustomIdentValue> separator = CSSCustomIdentValue::create(counter->separator());
|
| + CSSCustomIdentValue* identifier = CSSCustomIdentValue::create(counter->identifier());
|
| + CSSCustomIdentValue* separator = CSSCustomIdentValue::create(counter->separator());
|
| CSSValueID listStyleIdent = CSSValueNone;
|
| if (counter->listStyle() != NoneListStyle)
|
| listStyleIdent = static_cast<CSSValueID>(CSSValueDisc + counter->listStyle());
|
| - RawPtr<CSSPrimitiveValue> listStyle = cssValuePool().createIdentifierValue(listStyleIdent);
|
| - list->append(CSSCounterValue::create(identifier.release(), listStyle.release(), separator.release()));
|
| + CSSPrimitiveValue* listStyle = cssValuePool().createIdentifierValue(listStyleIdent);
|
| + list->append(CSSCounterValue::create(identifier, listStyle, separator));
|
| } else if (contentData->isImage()) {
|
| const StyleImage* image = toImageContentData(contentData)->image();
|
| ASSERT(image);
|
| @@ -1056,16 +1056,16 @@ static RawPtr<CSSValue> valueForContentData(const ComputedStyle& style)
|
| ASSERT_NOT_REACHED();
|
| }
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForCounterDirectives(const ComputedStyle& style, CSSPropertyID propertyID)
|
| +static CSSValue* valueForCounterDirectives(const ComputedStyle& style, CSSPropertyID propertyID)
|
| {
|
| const CounterDirectiveMap* map = style.counterDirectives();
|
| if (!map)
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| for (const auto& item : *map) {
|
| bool isValidCounterValue = propertyID == CSSPropertyCounterIncrement ? item.value.isIncrement() : item.value.isReset();
|
| if (!isValidCounterValue)
|
| @@ -1079,10 +1079,10 @@ static RawPtr<CSSValue> valueForCounterDirectives(const ComputedStyle& style, CS
|
| if (!list->length())
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForShape(const ComputedStyle& style, ShapeValue* shapeValue)
|
| +static CSSValue* valueForShape(const ComputedStyle& style, ShapeValue* shapeValue)
|
| {
|
| if (!shapeValue)
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| @@ -1096,21 +1096,21 @@ static RawPtr<CSSValue> valueForShape(const ComputedStyle& style, ShapeValue* sh
|
|
|
| ASSERT(shapeValue->type() == ShapeValue::Shape);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(valueForBasicShape(style, shapeValue->shape()));
|
| if (shapeValue->cssBox() != BoxMissing)
|
| list->append(cssValuePool().createValue(shapeValue->cssBox()));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valuesForSidesShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| +static CSSValueList* valuesForSidesShorthand(const StylePropertyShorthand& shorthand, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| // Assume the properties are in the usual order top, right, bottom, left.
|
| - RawPtr<CSSValue> topValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[0], style, layoutObject, styledNode, allowVisitedStyle);
|
| - RawPtr<CSSValue> rightValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[1], style, layoutObject, styledNode, allowVisitedStyle);
|
| - RawPtr<CSSValue> bottomValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[2], style, layoutObject, styledNode, allowVisitedStyle);
|
| - RawPtr<CSSValue> leftValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[3], style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* topValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[0], style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* rightValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[1], style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* bottomValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[2], style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* leftValue = ComputedStyleCSSValueMapping::get(shorthand.properties()[3], style, layoutObject, styledNode, allowVisitedStyle);
|
|
|
| // All 4 properties must be specified.
|
| if (!topValue || !rightValue || !bottomValue || !leftValue)
|
| @@ -1120,20 +1120,20 @@ static RawPtr<CSSValueList> valuesForSidesShorthand(const StylePropertyShorthand
|
| bool showBottom = !compareCSSValuePtr(topValue, bottomValue) || showLeft;
|
| bool showRight = !compareCSSValuePtr(topValue, rightValue) || showBottom;
|
|
|
| - list->append(topValue.release());
|
| + list->append(topValue);
|
| if (showRight)
|
| - list->append(rightValue.release());
|
| + list->append(rightValue);
|
| if (showBottom)
|
| - list->append(bottomValue.release());
|
| + list->append(bottomValue);
|
| if (showLeft)
|
| - list->append(leftValue.release());
|
| + list->append(leftValue);
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValueList> valueForBorderRadiusShorthand(const ComputedStyle& style)
|
| +static CSSValueList* valueForBorderRadiusShorthand(const ComputedStyle& style)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSlashSeparated();
|
| + CSSValueList* list = CSSValueList::createSlashSeparated();
|
|
|
| bool showHorizontalBottomLeft = style.borderTopRightRadius().width() != style.borderBottomLeftRadius().width();
|
| bool showHorizontalBottomRight = showHorizontalBottomLeft || (style.borderBottomRightRadius().width() != style.borderTopLeftRadius().width());
|
| @@ -1143,12 +1143,12 @@ static RawPtr<CSSValueList> valueForBorderRadiusShorthand(const ComputedStyle& s
|
| bool showVerticalBottomRight = showVerticalBottomLeft || (style.borderBottomRightRadius().height() != style.borderTopLeftRadius().height());
|
| bool showVerticalTopRight = showVerticalBottomRight || (style.borderTopRightRadius().height() != style.borderTopLeftRadius().height());
|
|
|
| - RawPtr<CSSValueList> topLeftRadius = valuesForBorderRadiusCorner(style.borderTopLeftRadius(), style);
|
| - RawPtr<CSSValueList> topRightRadius = valuesForBorderRadiusCorner(style.borderTopRightRadius(), style);
|
| - RawPtr<CSSValueList> bottomRightRadius = valuesForBorderRadiusCorner(style.borderBottomRightRadius(), style);
|
| - RawPtr<CSSValueList> bottomLeftRadius = valuesForBorderRadiusCorner(style.borderBottomLeftRadius(), style);
|
| + CSSValueList* topLeftRadius = valuesForBorderRadiusCorner(style.borderTopLeftRadius(), style);
|
| + CSSValueList* topRightRadius = valuesForBorderRadiusCorner(style.borderTopRightRadius(), style);
|
| + CSSValueList* bottomRightRadius = valuesForBorderRadiusCorner(style.borderBottomRightRadius(), style);
|
| + CSSValueList* bottomLeftRadius = valuesForBorderRadiusCorner(style.borderBottomLeftRadius(), style);
|
|
|
| - RawPtr<CSSValueList> horizontalRadii = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* horizontalRadii = CSSValueList::createSpaceSeparated();
|
| horizontalRadii->append(topLeftRadius->item(0));
|
| if (showHorizontalTopRight)
|
| horizontalRadii->append(topRightRadius->item(0));
|
| @@ -1157,9 +1157,9 @@ static RawPtr<CSSValueList> valueForBorderRadiusShorthand(const ComputedStyle& s
|
| if (showHorizontalBottomLeft)
|
| horizontalRadii->append(bottomLeftRadius->item(0));
|
|
|
| - list->append(horizontalRadii.release());
|
| + list->append(horizontalRadii);
|
|
|
| - RawPtr<CSSValueList> verticalRadii = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* verticalRadii = CSSValueList::createSpaceSeparated();
|
| verticalRadii->append(topLeftRadius->item(1));
|
| if (showVerticalTopRight)
|
| verticalRadii->append(topRightRadius->item(1));
|
| @@ -1169,26 +1169,26 @@ static RawPtr<CSSValueList> valueForBorderRadiusShorthand(const ComputedStyle& s
|
| verticalRadii->append(bottomLeftRadius->item(1));
|
|
|
| if (!verticalRadii->equals(*toCSSValueList(list->item(0))))
|
| - list->append(verticalRadii.release());
|
| + list->append(verticalRadii);
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> strokeDashArrayToCSSValueList(const SVGDashArray& dashes, const ComputedStyle& style)
|
| +static CSSValue* strokeDashArrayToCSSValueList(const SVGDashArray& dashes, const ComputedStyle& style)
|
| {
|
| if (dashes.isEmpty())
|
| return CSSPrimitiveValue::createIdentifier(CSSValueNone);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| for (const Length& dashLength : dashes.vector())
|
| list->append(zoomAdjustedPixelValueForLength(dashLength, style));
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> paintOrderToCSSValueList(const SVGComputedStyle& svgStyle)
|
| +static CSSValue* paintOrderToCSSValueList(const SVGComputedStyle& svgStyle)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| for (int i = 0; i < 3; i++) {
|
| EPaintOrderType paintOrderType = svgStyle.paintOrderType(i);
|
| switch (paintOrderType) {
|
| @@ -1204,13 +1204,13 @@ static RawPtr<CSSValue> paintOrderToCSSValueList(const SVGComputedStyle& svgStyl
|
| }
|
| }
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> adjustSVGPaintForCurrentColor(SVGPaintType paintType, const String& url, const Color& color, const Color& currentColor)
|
| +static CSSValue* adjustSVGPaintForCurrentColor(SVGPaintType paintType, const String& url, const Color& color, const Color& currentColor)
|
| {
|
| if (paintType >= SVG_PAINTTYPE_URI_NONE) {
|
| - RawPtr<CSSValueList> values = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* values = CSSValueList::createSpaceSeparated();
|
| values->append(CSSURIValue::create(url));
|
| if (paintType == SVG_PAINTTYPE_URI_NONE)
|
| values->append(CSSPrimitiveValue::createIdentifier(CSSValueNone));
|
| @@ -1218,7 +1218,7 @@ static RawPtr<CSSValue> adjustSVGPaintForCurrentColor(SVGPaintType paintType, co
|
| values->append(CSSColorValue::create(currentColor.rgb()));
|
| else if (paintType == SVG_PAINTTYPE_URI_RGBCOLOR)
|
| values->append(CSSColorValue::create(color.rgb()));
|
| - return values.release();
|
| + return values;
|
| }
|
| if (paintType == SVG_PAINTTYPE_NONE)
|
| return CSSPrimitiveValue::createIdentifier(CSSValueNone);
|
| @@ -1233,37 +1233,37 @@ static inline String serializeAsFragmentIdentifier(const AtomicString& resource)
|
| return "#" + resource;
|
| }
|
|
|
| -RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForShadowData(const ShadowData& shadow, const ComputedStyle& style, bool useSpread)
|
| +CSSValue* ComputedStyleCSSValueMapping::valueForShadowData(const ShadowData& shadow, const ComputedStyle& style, bool useSpread)
|
| {
|
| - RawPtr<CSSPrimitiveValue> x = zoomAdjustedPixelValue(shadow.x(), style);
|
| - RawPtr<CSSPrimitiveValue> y = zoomAdjustedPixelValue(shadow.y(), style);
|
| - RawPtr<CSSPrimitiveValue> blur = zoomAdjustedPixelValue(shadow.blur(), style);
|
| - RawPtr<CSSPrimitiveValue> spread = useSpread ? zoomAdjustedPixelValue(shadow.spread(), style) : RawPtr<CSSPrimitiveValue>(nullptr);
|
| - RawPtr<CSSPrimitiveValue> shadowStyle = shadow.style() == Normal ? RawPtr<CSSPrimitiveValue>(nullptr) : cssValuePool().createIdentifierValue(CSSValueInset);
|
| - RawPtr<CSSValue> color = currentColorOrValidColor(style, shadow.color());
|
| - return CSSShadowValue::create(x.release(), y.release(), blur.release(), spread.release(), shadowStyle.release(), color.release());
|
| + CSSPrimitiveValue* x = zoomAdjustedPixelValue(shadow.x(), style);
|
| + CSSPrimitiveValue* y = zoomAdjustedPixelValue(shadow.y(), style);
|
| + CSSPrimitiveValue* blur = zoomAdjustedPixelValue(shadow.blur(), style);
|
| + CSSPrimitiveValue* spread = useSpread ? zoomAdjustedPixelValue(shadow.spread(), style) : nullptr;
|
| + CSSPrimitiveValue* shadowStyle = shadow.style() == Normal ? nullptr : cssValuePool().createIdentifierValue(CSSValueInset);
|
| + CSSValue* color = currentColorOrValidColor(style, shadow.color());
|
| + return CSSShadowValue::create(x, y, blur, spread, shadowStyle, color);
|
| }
|
|
|
| -RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForShadowList(const ShadowList* shadowList, const ComputedStyle& style, bool useSpread)
|
| +CSSValue* ComputedStyleCSSValueMapping::valueForShadowList(const ShadowList* shadowList, const ComputedStyle& style, bool useSpread)
|
| {
|
| if (!shadowList)
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| size_t shadowCount = shadowList->shadows().size();
|
| for (size_t i = 0; i < shadowCount; ++i)
|
| list->append(valueForShadowData(shadowList->shadows()[i], style, useSpread));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForFilter(const ComputedStyle& style, const FilterOperations& filterOperations)
|
| +CSSValue* ComputedStyleCSSValueMapping::valueForFilter(const ComputedStyle& style, const FilterOperations& filterOperations)
|
| {
|
| if (filterOperations.operations().isEmpty())
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
|
|
| - RawPtr<CSSFunctionValue> filterValue = nullptr;
|
| + CSSFunctionValue* filterValue = nullptr;
|
|
|
| for (const auto& operation : filterOperations.operations()) {
|
| FilterOperation* filterOperation = operation.get();
|
| @@ -1320,55 +1320,55 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForFilter(const ComputedStyl
|
| ASSERT_NOT_REACHED();
|
| break;
|
| }
|
| - list->append(filterValue.release());
|
| + list->append(filterValue);
|
| }
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -RawPtr<CSSValue> ComputedStyleCSSValueMapping::valueForFont(const ComputedStyle& style)
|
| +CSSValue* ComputedStyleCSSValueMapping::valueForFont(const ComputedStyle& style)
|
| {
|
| // Add a slash between size and line-height.
|
| - RawPtr<CSSValueList> sizeAndLineHeight = CSSValueList::createSlashSeparated();
|
| + CSSValueList* sizeAndLineHeight = CSSValueList::createSlashSeparated();
|
| sizeAndLineHeight->append(valueForFontSize(style));
|
| sizeAndLineHeight->append(valueForLineHeight(style));
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(valueForFontStyle(style));
|
| list->append(valueForFontVariant(style));
|
| list->append(valueForFontWeight(style));
|
| list->append(valueForFontStretch(style));
|
| - list->append(sizeAndLineHeight.release());
|
| + list->append(sizeAndLineHeight);
|
| list->append(valueForFontFamily(style));
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForScrollSnapDestination(const LengthPoint& destination, const ComputedStyle& style)
|
| +static CSSValue* valueForScrollSnapDestination(const LengthPoint& destination, const ComputedStyle& style)
|
| {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(zoomAdjustedPixelValueForLength(destination.x(), style));
|
| list->append(zoomAdjustedPixelValueForLength(destination.y(), style));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForScrollSnapPoints(const ScrollSnapPoints& points, const ComputedStyle& style)
|
| +static CSSValue* valueForScrollSnapPoints(const ScrollSnapPoints& points, const ComputedStyle& style)
|
| {
|
| if (points.hasRepeat) {
|
| - RawPtr<CSSFunctionValue> repeat = CSSFunctionValue::create(CSSValueRepeat);
|
| + CSSFunctionValue* repeat = CSSFunctionValue::create(CSSValueRepeat);
|
| repeat->append(zoomAdjustedPixelValueForLength(points.repeatOffset, style));
|
| - return repeat.release();
|
| + return repeat;
|
| }
|
|
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| }
|
|
|
| -static RawPtr<CSSValue> valueForScrollSnapCoordinate(const Vector<LengthPoint>& coordinates, const ComputedStyle& style)
|
| +static CSSValue* valueForScrollSnapCoordinate(const Vector<LengthPoint>& coordinates, const ComputedStyle& style)
|
| {
|
| if (coordinates.isEmpty())
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
|
|
| for (auto& coordinate : coordinates) {
|
| auto pair = CSSValueList::createSpaceSeparated();
|
| @@ -1377,7 +1377,7 @@ static RawPtr<CSSValue> valueForScrollSnapCoordinate(const Vector<LengthPoint>&
|
| list->append(pair);
|
| }
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| static EBreak mapToPageBreakValue(EBreak genericBreakValue)
|
| @@ -1416,7 +1416,7 @@ static EBreak mapToColumnBreakValue(EBreak genericBreakValue)
|
| }
|
| }
|
|
|
| -RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(const AtomicString customPropertyName, const ComputedStyle& style)
|
| +CSSValue* ComputedStyleCSSValueMapping::get(const AtomicString customPropertyName, const ComputedStyle& style)
|
| {
|
| StyleVariableData* variables = style.variables();
|
| if (!variables)
|
| @@ -1437,7 +1437,7 @@ const HashMap<AtomicString, RefPtr<CSSVariableData>>* ComputedStyleCSSValueMappi
|
| return nullptr;
|
| }
|
|
|
| -RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, const ComputedStyle& style, const LayoutObject* layoutObject, Node* styledNode, bool allowVisitedStyle)
|
| +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.getWritingMode());
|
| @@ -1449,7 +1449,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| return allowVisitedStyle ? cssValuePool().createColorValue(style.visitedDependentColor(CSSPropertyBackgroundColor).rgb()) : currentColorOrValidColor(style, style.backgroundColor());
|
| case CSSPropertyBackgroundImage:
|
| case CSSPropertyWebkitMaskImage: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskImage ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next()) {
|
| if (currLayer->image())
|
| @@ -1457,42 +1457,42 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| else
|
| list->append(cssValuePool().createIdentifierValue(CSSValueNone));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackgroundSize:
|
| case CSSPropertyWebkitMaskSize: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskSize ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next())
|
| list->append(valueForFillSize(currLayer->size(), style));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackgroundRepeat:
|
| case CSSPropertyWebkitMaskRepeat: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskRepeat ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next())
|
| list->append(valueForFillRepeat(currLayer->repeatX(), currLayer->repeatY()));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyMaskSourceType: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| for (const FillLayer* currLayer = &style.maskLayers(); currLayer; currLayer = currLayer->next())
|
| list->append(valueForFillSourceType(currLayer->maskSourceType()));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyWebkitMaskComposite: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskComposite ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next())
|
| list->append(cssValuePool().createValue(currLayer->composite()));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackgroundAttachment: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| for (const FillLayer* currLayer = &style.backgroundLayers(); currLayer; currLayer = currLayer->next())
|
| list->append(cssValuePool().createValue(currLayer->attachment()));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackgroundClip:
|
| case CSSPropertyBackgroundOrigin:
|
| @@ -1501,47 +1501,47 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| case CSSPropertyWebkitMaskClip:
|
| case CSSPropertyWebkitMaskOrigin: {
|
| bool isClip = propertyID == CSSPropertyBackgroundClip || propertyID == CSSPropertyWebkitBackgroundClip || propertyID == CSSPropertyWebkitMaskClip;
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = (propertyID == CSSPropertyWebkitMaskClip || propertyID == CSSPropertyWebkitMaskOrigin) ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next()) {
|
| EFillBox box = isClip ? currLayer->clip() : currLayer->origin();
|
| list->append(cssValuePool().createValue(box));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackgroundPosition:
|
| case CSSPropertyWebkitMaskPosition: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPosition ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next())
|
| list->append(createPositionListForLayer(propertyID, *currLayer, style));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackgroundPositionX:
|
| case CSSPropertyWebkitMaskPositionX: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionX ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next())
|
| list->append(zoomAdjustedPixelValueForLength(currLayer->xPosition(), style));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackgroundPositionY:
|
| case CSSPropertyWebkitMaskPositionY: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const FillLayer* currLayer = propertyID == CSSPropertyWebkitMaskPositionY ? &style.maskLayers() : &style.backgroundLayers();
|
| for (; currLayer; currLayer = currLayer->next())
|
| list->append(zoomAdjustedPixelValueForLength(currLayer->yPosition(), style));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBorderCollapse:
|
| if (style.borderCollapse())
|
| return cssValuePool().createIdentifierValue(CSSValueCollapse);
|
| return cssValuePool().createIdentifierValue(CSSValueSeparate);
|
| case CSSPropertyBorderSpacing: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(zoomAdjustedPixelValue(style.horizontalBorderSpacing(), style));
|
| list->append(zoomAdjustedPixelValue(style.verticalBorderSpacing(), style));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyWebkitBorderHorizontalSpacing:
|
| return zoomAdjustedPixelValue(style.horizontalBorderSpacing(), style);
|
| @@ -1642,7 +1642,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| return cssValuePool().createValue(
|
| style.getTabSize().getPixelSize(1.0), style.getTabSize().isSpaces() ? CSSPrimitiveValue::UnitType::Number : CSSPrimitiveValue::UnitType::Pixels);
|
| case CSSPropertyCursor: {
|
| - RawPtr<CSSValueList> list = nullptr;
|
| + CSSValueList* list = nullptr;
|
| CursorList* cursors = style.cursors();
|
| if (cursors && cursors->size() > 0) {
|
| list = CSSValueList::createCommaSeparated();
|
| @@ -1651,12 +1651,12 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| list->append(image->computedCSSValue());
|
| }
|
| }
|
| - RawPtr<CSSValue> value = cssValuePool().createValue(style.cursor());
|
| + CSSValue* value = cssValuePool().createValue(style.cursor());
|
| if (list) {
|
| - list->append(value.release());
|
| - return list.release();
|
| + list->append(value);
|
| + return list;
|
| }
|
| - return value.release();
|
| + return value;
|
| }
|
| case CSSPropertyDirection:
|
| return cssValuePool().createValue(style.direction());
|
| @@ -1721,16 +1721,16 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| const FontFeatureSettings* featureSettings = style.getFontDescription().featureSettings();
|
| if (!featureSettings || !featureSettings->size())
|
| return cssValuePool().createIdentifierValue(CSSValueNormal);
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| for (unsigned i = 0; i < featureSettings->size(); ++i) {
|
| const FontFeature& feature = featureSettings->at(i);
|
| - RawPtr<CSSFontFeatureValue> featureValue = CSSFontFeatureValue::create(feature.tag(), feature.value());
|
| - list->append(featureValue.release());
|
| + CSSFontFeatureValue* featureValue = CSSFontFeatureValue::create(feature.tag(), feature.value());
|
| + list->append(featureValue);
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyGridAutoFlow: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| switch (style.getGridAutoFlow()) {
|
| case AutoFlowRow:
|
| case AutoFlowRowDense:
|
| @@ -1754,7 +1754,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| break;
|
| }
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
| // Specs mention that getComputedStyle() should return the used value of the property instead of the computed
|
| // one for grid-definition-{rows|columns} but not for the grid-auto-{rows|columns} as things like
|
| @@ -1996,12 +1996,12 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| return nullptr;
|
| }
|
| if (style.quotes()->size()) {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| for (int i = 0; i < style.quotes()->size(); i++) {
|
| list->append(CSSStringValue::create(style.quotes()->getOpenQuote(i)));
|
| list->append(CSSStringValue::create(style.quotes()->getCloseQuote(i)));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| case CSSPropertyRight:
|
| @@ -2052,14 +2052,14 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| case TextEmphasisMarkDoubleCircle:
|
| case TextEmphasisMarkTriangle:
|
| case TextEmphasisMarkSesame: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(cssValuePool().createValue(style.getTextEmphasisFill()));
|
| list->append(cssValuePool().createValue(style.getTextEmphasisMark()));
|
| - return list.release();
|
| + return list;
|
| }
|
| }
|
| case CSSPropertyTextIndent: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(zoomAdjustedPixelValueForLength(style.textIndent(), style));
|
| if (RuntimeEnabledFeatures::css3TextEnabled() && (style.getTextIndentLine() == TextIndentEachLine || style.getTextIndentType() == TextIndentHanging)) {
|
| if (style.getTextIndentLine() == TextIndentEachLine)
|
| @@ -2067,7 +2067,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| if (style.getTextIndentType() == TextIndentHanging)
|
| list->append(cssValuePool().createIdentifierValue(CSSValueHanging));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyTextShadow:
|
| return valueForShadowList(style.textShadow(), style, false);
|
| @@ -2156,7 +2156,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| && historicalLigaturesState == FontDescription::NormalLigaturesState && contextualLigaturesState == FontDescription::NormalLigaturesState)
|
| return cssValuePool().createIdentifierValue(CSSValueNormal);
|
|
|
| - RawPtr<CSSValueList> valueList = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* valueList = CSSValueList::createSpaceSeparated();
|
| if (commonLigaturesState != FontDescription::NormalLigaturesState)
|
| valueList->append(cssValuePool().createIdentifierValue(commonLigaturesState == FontDescription::DisabledLigaturesState ? CSSValueNoCommonLigatures : CSSValueCommonLigatures));
|
| if (discretionaryLigaturesState != FontDescription::NormalLigaturesState)
|
| @@ -2182,7 +2182,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| case CSSPropertyAnimationDelay:
|
| return valueForAnimationDelay(style.animations());
|
| case CSSPropertyAnimationDirection: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const CSSAnimationData* animationData = style.animations();
|
| if (animationData) {
|
| for (size_t i = 0; i < animationData->directionList().size(); ++i)
|
| @@ -2190,12 +2190,12 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| } else {
|
| list->append(cssValuePool().createIdentifierValue(CSSValueNormal));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyAnimationDuration:
|
| return valueForAnimationDuration(style.animations());
|
| case CSSPropertyAnimationFillMode: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const CSSAnimationData* animationData = style.animations();
|
| if (animationData) {
|
| for (size_t i = 0; i < animationData->fillModeList().size(); ++i)
|
| @@ -2203,10 +2203,10 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| } else {
|
| list->append(cssValuePool().createIdentifierValue(CSSValueNone));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyAnimationIterationCount: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const CSSAnimationData* animationData = style.animations();
|
| if (animationData) {
|
| for (size_t i = 0; i < animationData->iterationCountList().size(); ++i)
|
| @@ -2214,10 +2214,10 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| } else {
|
| list->append(cssValuePool().createValue(CSSAnimationData::initialIterationCount(), CSSPrimitiveValue::UnitType::Number));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyAnimationName: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const CSSAnimationData* animationData = style.animations();
|
| if (animationData) {
|
| for (size_t i = 0; i < animationData->nameList().size(); ++i)
|
| @@ -2225,10 +2225,10 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| } else {
|
| list->append(cssValuePool().createIdentifierValue(CSSValueNone));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyAnimationPlayState: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| const CSSAnimationData* animationData = style.animations();
|
| if (animationData) {
|
| for (size_t i = 0; i < animationData->playStateList().size(); ++i)
|
| @@ -2236,16 +2236,16 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| } else {
|
| list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyAnimationTimingFunction:
|
| return valueForAnimationTimingFunction(style.animations());
|
| case CSSPropertyAnimation: {
|
| const CSSAnimationData* animationData = style.animations();
|
| if (animationData) {
|
| - RawPtr<CSSValueList> animationsList = CSSValueList::createCommaSeparated();
|
| + CSSValueList* animationsList = CSSValueList::createCommaSeparated();
|
| for (size_t i = 0; i < animationData->nameList().size(); ++i) {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(CSSCustomIdentValue::create(animationData->nameList()[i]));
|
| list->append(cssValuePool().createValue(CSSTimingData::getRepeated(animationData->durationList(), i), CSSPrimitiveValue::UnitType::Seconds));
|
| list->append(createTimingFunctionValue(CSSTimingData::getRepeated(animationData->timingFunctionList(), i).get()));
|
| @@ -2256,10 +2256,10 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| list->append(valueForAnimationPlayState(CSSTimingData::getRepeated(animationData->playStateList(), i)));
|
| animationsList->append(list);
|
| }
|
| - return animationsList.release();
|
| + return animationsList;
|
| }
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| // animation-name default value.
|
| list->append(cssValuePool().createIdentifierValue(CSSValueNone));
|
| list->append(cssValuePool().createValue(CSSAnimationData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
|
| @@ -2270,7 +2270,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| list->append(valueForAnimationFillMode(CSSAnimationData::initialFillMode()));
|
| // Initial animation-play-state.
|
| list->append(cssValuePool().createIdentifierValue(CSSValueRunning));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyWebkitAppearance:
|
| return cssValuePool().createValue(style.appearance());
|
| @@ -2314,7 +2314,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| return cssValuePool().createIdentifierValue(CSSValueNone);
|
| return zoomAdjustedPixelValue(style.perspective(), style);
|
| case CSSPropertyPerspectiveOrigin: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (layoutObject) {
|
| LayoutRect box;
|
| if (layoutObject->isBox())
|
| @@ -2326,7 +2326,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginX(), style));
|
| list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginY(), style));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyWebkitRtlOrdering:
|
| return cssValuePool().createIdentifierValue(style.rtlOrdering() ? CSSValueVisual : CSSValueLogical);
|
| @@ -2347,26 +2347,26 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| case CSSPropertyClip: {
|
| if (style.hasAutoClip())
|
| return cssValuePool().createIdentifierValue(CSSValueAuto);
|
| - RawPtr<CSSPrimitiveValue> top = style.clip().top().isAuto()
|
| + CSSPrimitiveValue* top = style.clip().top().isAuto()
|
| ? cssValuePool().createIdentifierValue(CSSValueAuto)
|
| : zoomAdjustedPixelValue(style.clip().top().value(), style);
|
| - RawPtr<CSSPrimitiveValue> right = style.clip().right().isAuto()
|
| + CSSPrimitiveValue* right = style.clip().right().isAuto()
|
| ? cssValuePool().createIdentifierValue(CSSValueAuto)
|
| : zoomAdjustedPixelValue(style.clip().right().value(), style);
|
| - RawPtr<CSSPrimitiveValue> bottom = style.clip().bottom().isAuto()
|
| + CSSPrimitiveValue* bottom = style.clip().bottom().isAuto()
|
| ? cssValuePool().createIdentifierValue(CSSValueAuto)
|
| : zoomAdjustedPixelValue(style.clip().bottom().value(), style);
|
| - RawPtr<CSSPrimitiveValue> left = style.clip().left().isAuto()
|
| + CSSPrimitiveValue* left = style.clip().left().isAuto()
|
| ? cssValuePool().createIdentifierValue(CSSValueAuto)
|
| : zoomAdjustedPixelValue(style.clip().left().value(), style);
|
| - return CSSQuadValue::create(top.release(), right.release(), bottom.release(), left.release(), CSSQuadValue::SerializeAsRect);
|
| + return CSSQuadValue::create(top, right, bottom, left, CSSQuadValue::SerializeAsRect);
|
| }
|
| case CSSPropertySpeak:
|
| return cssValuePool().createValue(style.speak());
|
| case CSSPropertyTransform:
|
| return computedTransform(layoutObject, style);
|
| case CSSPropertyTransformOrigin: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (layoutObject) {
|
| LayoutRect box;
|
| if (layoutObject->isBox())
|
| @@ -2382,7 +2382,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| if (style.transformOriginZ() != 0)
|
| list->append(zoomAdjustedPixelValue(style.transformOriginZ(), style));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyTransformStyle:
|
| return cssValuePool().createIdentifierValue((style.transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
|
| @@ -2397,25 +2397,25 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| case CSSPropertyTransition: {
|
| const CSSTransitionData* transitionData = style.transitions();
|
| if (transitionData) {
|
| - RawPtr<CSSValueList> transitionsList = CSSValueList::createCommaSeparated();
|
| + CSSValueList* transitionsList = CSSValueList::createCommaSeparated();
|
| for (size_t i = 0; i < transitionData->propertyList().size(); ++i) {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(createTransitionPropertyValue(transitionData->propertyList()[i]));
|
| list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->durationList(), i), CSSPrimitiveValue::UnitType::Seconds));
|
| list->append(createTimingFunctionValue(CSSTimingData::getRepeated(transitionData->timingFunctionList(), i).get()));
|
| list->append(cssValuePool().createValue(CSSTimingData::getRepeated(transitionData->delayList(), i), CSSPrimitiveValue::UnitType::Seconds));
|
| transitionsList->append(list);
|
| }
|
| - return transitionsList.release();
|
| + return transitionsList;
|
| }
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| // transition-property default value.
|
| list->append(cssValuePool().createIdentifierValue(CSSValueAll));
|
| list->append(cssValuePool().createValue(CSSTransitionData::initialDuration(), CSSPrimitiveValue::UnitType::Seconds));
|
| list->append(createTimingFunctionValue(CSSTransitionData::initialTimingFunction().get()));
|
| list->append(cssValuePool().createValue(CSSTransitionData::initialDelay(), CSSPrimitiveValue::UnitType::Seconds));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyPointerEvents:
|
| return cssValuePool().createValue(style.pointerEvents());
|
| @@ -2464,15 +2464,15 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| return cssValuePool().createValue(style.blendMode());
|
|
|
| case CSSPropertyBackgroundBlendMode: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
|
| + CSSValueList* list = CSSValueList::createCommaSeparated();
|
| for (const FillLayer* currLayer = &style.backgroundLayers(); currLayer; currLayer = currLayer->next())
|
| list->append(cssValuePool().createValue(currLayer->blendMode()));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyBackground:
|
| return valuesForBackgroundShorthand(style, layoutObject, styledNode, allowVisitedStyle);
|
| case CSSPropertyBorder: {
|
| - RawPtr<CSSValue> value = get(CSSPropertyBorderTop, style, layoutObject, styledNode, allowVisitedStyle);
|
| + CSSValue* value = get(CSSPropertyBorderTop, style, layoutObject, styledNode, allowVisitedStyle);
|
| const CSSPropertyID properties[] = {
|
| CSSPropertyBorderRight,
|
| CSSPropertyBorderBottom,
|
| @@ -2482,7 +2482,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| if (!compareCSSValuePtr<CSSValue>(value, get(properties[i], style, layoutObject, styledNode, allowVisitedStyle)))
|
| return nullptr;
|
| }
|
| - return value.release();
|
| + return value;
|
| }
|
| case CSSPropertyBorderBottom:
|
| return valuesForShorthandProperty(borderBottomShorthand(), style, layoutObject, styledNode, allowVisitedStyle);
|
| @@ -2531,11 +2531,11 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| return zoomAdjustedPixelValueForLength(style.motionOffset(), style);
|
|
|
| case CSSPropertyMotionRotation: {
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (style.motionRotation().type == MotionRotationAuto)
|
| list->append(cssValuePool().createIdentifierValue(CSSValueAuto));
|
| list->append(cssValuePool().createValue(style.motionRotation().angle, CSSPrimitiveValue::UnitType::Degrees));
|
| - return list.release();
|
| + return list;
|
| }
|
|
|
| // Unimplemented CSS 3 properties (including CSS3 shorthand properties).
|
| @@ -2734,7 +2734,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| if (!style.translate())
|
| return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (layoutObject && layoutObject->isBox()) {
|
| LayoutRect box = toLayoutBox(layoutObject)->borderBoxRect();
|
| list->append(zoomAdjustedPixelValue(floatValueForLength(style.translate()->x(), box.width().toFloat()), style));
|
| @@ -2753,32 +2753,32 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| if (style.translate()->z() != 0)
|
| list->append(zoomAdjustedPixelValue(style.translate()->z(), style));
|
|
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyRotate: {
|
| if (!style.rotate())
|
| return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Degrees);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(cssValuePool().createValue(style.rotate()->angle(), CSSPrimitiveValue::UnitType::Degrees));
|
| if (style.rotate()->x() != 0 || style.rotate()->y() != 0 || style.rotate()->z() != 1) {
|
| list->append(cssValuePool().createValue(style.rotate()->x(), CSSPrimitiveValue::UnitType::Number));
|
| list->append(cssValuePool().createValue(style.rotate()->y(), CSSPrimitiveValue::UnitType::Number));
|
| list->append(cssValuePool().createValue(style.rotate()->z(), CSSPrimitiveValue::UnitType::Number));
|
| }
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyScale: {
|
| if (!style.scale())
|
| return cssValuePool().createValue(1, CSSPrimitiveValue::UnitType::Number);
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(cssValuePool().createValue(style.scale()->x(), CSSPrimitiveValue::UnitType::Number));
|
| if (style.scale()->y() == 1 && style.scale()->z() == 1)
|
| - return list.release();
|
| + return list;
|
| list->append(cssValuePool().createValue(style.scale()->y(), CSSPrimitiveValue::UnitType::Number));
|
| if (style.scale()->z() != 1)
|
| list->append(cssValuePool().createValue(style.scale()->z(), CSSPrimitiveValue::UnitType::Number));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyContain: {
|
| if (!style.contain())
|
| @@ -2786,7 +2786,7 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| if (style.contain() == ContainsStrict)
|
| return cssValuePool().createIdentifierValue(CSSValueStrict);
|
|
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| if (style.containsStyle())
|
| list->append(cssValuePool().createIdentifierValue(CSSValueStyle));
|
| if (style.contain() & ContainsLayout)
|
| @@ -2794,16 +2794,16 @@ RawPtr<CSSValue> ComputedStyleCSSValueMapping::get(CSSPropertyID propertyID, con
|
| if (style.containsPaint())
|
| list->append(cssValuePool().createIdentifierValue(CSSValuePaint));
|
| ASSERT(list->length());
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertySnapHeight: {
|
| if (!style.snapHeightUnit())
|
| return cssValuePool().createValue(0, CSSPrimitiveValue::UnitType::Pixels);
|
| - RawPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
|
| + CSSValueList* list = CSSValueList::createSpaceSeparated();
|
| list->append(cssValuePool().createValue(style.snapHeightUnit(), CSSPrimitiveValue::UnitType::Pixels));
|
| if (style.snapHeightPosition())
|
| list->append(cssValuePool().createValue(style.snapHeightPosition(), CSSPrimitiveValue::UnitType::Integer));
|
| - return list.release();
|
| + return list;
|
| }
|
| case CSSPropertyVariable:
|
| // Variables are retrieved via get(AtomicString).
|
|
|
Chromium Code Reviews
Issue 1858753003:
Remove RawPtr from core/css (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master