Modernize RenderStyleConstants.h - Part 1
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 21 May 2018 16:55:45 +0000 (16:55 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Mon, 21 May 2018 16:55:45 +0000 (16:55 +0000)
https://bugs.webkit.org/show_bug.cgi?id=185809

Patch by Sam Weinig <sam@webkit.org> on 2018-05-21
Reviewed by Yusuke Suzuki.
Source/WebCore:

Modernized the first set of enums in RenderStyleConstants.h by:
    - Converting them to enum classes
    - Renaming them to remove unnecessary prefix 'E's
    - Renaming values to take advantage of enum class scoping (e.g. StyleDifferenceEqual -> StyleDifference::Equal)
    - Renaming to match modern conventions (e.g BNONE -> None)
    - Reformatting them so that each value is on its own line.

Modernizes the following enums:
    PrintColorAdjust
    StyleDifference
    StyleDifferenceContextSensitiveProperty
    ColumnFill
    ColumnSpan
    BorderCollapse (renamed from EBorderCollapse)
    BorderStyle (renamed from EBorderStyle)
    BorderPrecedence (renamed from EBorderPrecedence)
    OutlineIsAuto
    PositionType (renamed from EPosition)
    Float (renamed from EFloat)
    MarginCollapse (renamed from EMarginCollapse)
    BoxDecorationBreak (renamed from EBoxDecorationBreak)
    BoxSizing (renamed from EBoxSizing)
    Overflow (renamed from EOverflow)
    VerticalAlign (renamed from EVerticalAlign)
    Clear (renamed from EClear)
    TableLayoutType (renamed from ETableLayout)
    TextCombine
    FillAttachment (renamed from EFillAttachment)
    FillBox (renamed from EFillBox)
    FillRepeat (renamed from EFillRepeat)
    FillLayerType (renamed from EFillLayerType)
    FillSizeType (renamed from EFillSizeType)
    MaskSourceType (renamed from EMaskSourceType)
    BoxPack (renamed from EBoxPack)
    BoxAlignment (renamed from EBoxAlignment)
    BoxOrient (renamed from EBoxOrient)
    BoxLines (renamed from EBoxLines)
    BoxDirection (renamed from EBoxDirection)
    AlignContent (renamed from EAlignContent)
    FlexDirection (renamed from EFlexDirection)
    FlexWrap (renamed from EFlexWrap)
    ItemPosition
    OverflowAlignment
    ItemPositionType
    ContentPosition
    ContentDistribution (renamed from ContentDistributionType)
    TextSecurity (renamed from ETextSecurity)
    UserModify (renamed from EUserModify)
    UserDrag (renamed from EUserDrag)
    UserSelect (renamed from EUserSelect)
    ObjectFit
    AspectRatioType
    WordBreak (renamed from EWordBreak)
    OverflowWrap (renamed from EOverflowWrap)
    NBSPMode (renamed from ENBSPMode)
    LineBreak
    Resize (renamed from EResize)
    QuoteType
    TransformStyle3D (renamed from ETransformStyle3D)
    BackfaceVisibility (renamed from EBackfaceVisibility)
    LineClamp (renamed from ELineClamp)
    TextOverflow
    ImageRendering (renamed from EImageRendering)
    TextIndentLine
    TextIndentType
    Isolation

* accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
(AXAttributeStringSetStyle):
* css/BasicShapeFunctions.cpp:
(WebCore::valueForCenterCoordinate):
(WebCore::valueForBasicShape):
* css/CSSComputedStyleDeclaration.cpp:
(WebCore::sizingBox):
(WebCore::fillRepeatToCSSValue):
(WebCore::fillSourceTypeToCSSValue):
(WebCore::fillSizeToCSSValue):
(WebCore::valueForItemPositionWithOverflowAlignment):
(WebCore::valueForContentPositionAndDistributionWithOverflowAlignment):
(WebCore::ComputedStyleExtractor::valueForPropertyinStyle):
* css/CSSPrimitiveValueMappings.h:
(WebCore::CSSPrimitiveValue::operator LineClampValue const):
(WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
(WebCore::CSSPrimitiveValue::operator ColumnFill const):
(WebCore::CSSPrimitiveValue::operator ColumnSpan const):
(WebCore::CSSPrimitiveValue::operator PrintColorAdjust const):
(WebCore::CSSPrimitiveValue::operator BorderStyle const):
(WebCore::CSSPrimitiveValue::operator OutlineIsAuto const):
(WebCore::CSSPrimitiveValue::operator BackfaceVisibility const):
(WebCore::CSSPrimitiveValue::operator FillAttachment const):
(WebCore::CSSPrimitiveValue::operator FillBox const):
(WebCore::CSSPrimitiveValue::operator FillRepeat const):
(WebCore::CSSPrimitiveValue::operator BoxPack const):
(WebCore::CSSPrimitiveValue::operator BoxAlignment const):
(WebCore::CSSPrimitiveValue::operator BoxDecorationBreak const):
(WebCore::CSSPrimitiveValue::operator BoxSizing const):
(WebCore::CSSPrimitiveValue::operator BoxDirection const):
(WebCore::CSSPrimitiveValue::operator BoxLines const):
(WebCore::CSSPrimitiveValue::operator BoxOrient const):
(WebCore::CSSPrimitiveValue::operator Clear const):
(WebCore::CSSPrimitiveValue::operator FlexDirection const):
(WebCore::CSSPrimitiveValue::operator AlignContent const):
(WebCore::CSSPrimitiveValue::operator FlexWrap const):
(WebCore::CSSPrimitiveValue::operator Float const):
(WebCore::CSSPrimitiveValue::operator LineBreak const):
(WebCore::CSSPrimitiveValue::operator MarginCollapse const):
(WebCore::CSSPrimitiveValue::operator NBSPMode const):
(WebCore::CSSPrimitiveValue::operator Overflow const):
(WebCore::CSSPrimitiveValue::operator PositionType const):
(WebCore::CSSPrimitiveValue::operator Resize const):
(WebCore::CSSPrimitiveValue::operator TableLayoutType const):
(WebCore::CSSPrimitiveValue::operator TextSecurity const):
(WebCore::CSSPrimitiveValue::operator UserDrag const):
(WebCore::CSSPrimitiveValue::operator UserModify const):
(WebCore::CSSPrimitiveValue::operator UserSelect const):
(WebCore::CSSPrimitiveValue::operator VerticalAlign const):
(WebCore::CSSPrimitiveValue::operator WordBreak const):
(WebCore::CSSPrimitiveValue::operator OverflowWrap const):
(WebCore::CSSPrimitiveValue::operator TextCombine const):
(WebCore::CSSPrimitiveValue::operator TextOverflow const):
(WebCore::CSSPrimitiveValue::operator ObjectFit const):
(WebCore::CSSPrimitiveValue::operator Isolation const):
(WebCore::CSSPrimitiveValue::operator BorderCollapse const):
(WebCore::CSSPrimitiveValue::operator ImageRendering const):
(WebCore::CSSPrimitiveValue::operator TransformStyle3D const):
(WebCore::CSSPrimitiveValue::operator ItemPosition const):
(WebCore::CSSPrimitiveValue::operator OverflowAlignment const):
(WebCore::CSSPrimitiveValue::operator ContentPosition const):
(WebCore::CSSPrimitiveValue::operator ContentDistribution const):
(WebCore::CSSPrimitiveValue::operator EBorderStyle const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBackfaceVisibility const): Deleted.
(WebCore::CSSPrimitiveValue::operator EFillAttachment const): Deleted.
(WebCore::CSSPrimitiveValue::operator EFillBox const): Deleted.
(WebCore::CSSPrimitiveValue::operator EFillRepeat const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBoxPack const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBoxAlignment const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBoxDecorationBreak const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBoxSizing const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBoxDirection const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBoxLines const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBoxOrient const): Deleted.
(WebCore::CSSPrimitiveValue::operator EClear const): Deleted.
(WebCore::CSSPrimitiveValue::operator EFlexDirection const): Deleted.
(WebCore::CSSPrimitiveValue::operator EAlignContent const): Deleted.
(WebCore::CSSPrimitiveValue::operator EFlexWrap const): Deleted.
(WebCore::CSSPrimitiveValue::operator EFloat const): Deleted.
(WebCore::CSSPrimitiveValue::operator EMarginCollapse const): Deleted.
(WebCore::CSSPrimitiveValue::operator ENBSPMode const): Deleted.
(WebCore::CSSPrimitiveValue::operator EOverflow const): Deleted.
(WebCore::CSSPrimitiveValue::operator EPosition const): Deleted.
(WebCore::CSSPrimitiveValue::operator EResize const): Deleted.
(WebCore::CSSPrimitiveValue::operator ETableLayout const): Deleted.
(WebCore::CSSPrimitiveValue::operator ETextSecurity const): Deleted.
(WebCore::CSSPrimitiveValue::operator EUserDrag const): Deleted.
(WebCore::CSSPrimitiveValue::operator EUserModify const): Deleted.
(WebCore::CSSPrimitiveValue::operator EUserSelect const): Deleted.
(WebCore::CSSPrimitiveValue::operator EVerticalAlign const): Deleted.
(WebCore::CSSPrimitiveValue::operator EWordBreak const): Deleted.
(WebCore::CSSPrimitiveValue::operator EOverflowWrap const): Deleted.
(WebCore::CSSPrimitiveValue::operator EBorderCollapse const): Deleted.
(WebCore::CSSPrimitiveValue::operator EImageRendering const): Deleted.
(WebCore::CSSPrimitiveValue::operator ETransformStyle3D const): Deleted.
(WebCore::CSSPrimitiveValue::operator ContentDistributionType const): Deleted.
* css/CSSProperties.json:
* css/CSSToStyleMap.cpp:
(WebCore::CSSToStyleMap::mapFillAttachment):
(WebCore::CSSToStyleMap::mapFillSize):
(WebCore::CSSToStyleMap::mapFillMaskSourceType):
* css/CSSValueKeywords.in:
* css/StyleBuilderConverter.h:
(WebCore::StyleBuilderConverter::convertResize):
(WebCore::StyleBuilderConverter::convertSelfOrDefaultAlignmentData):
* css/StyleBuilderCustom.h:
(WebCore::StyleBuilderCustom::applyValueTextIndent):
(WebCore::StyleBuilderCustom::applyInheritWebkitAspectRatio):
(WebCore::StyleBuilderCustom::applyValueWebkitAspectRatio):
(WebCore::StyleBuilderCustom::applyValueContent):
* css/StyleResolver.cpp:
(WebCore::isScrollableOverflow):
(WebCore::StyleResolver::adjustRenderStyle):
* css/StyleResolver.h:
* css/makeprop.pl:
(getFillLayerType):
* dom/Element.h:
* dom/Node.cpp:
(WebCore::computeEditabilityFromComputedStyle):
(WebCore::Node::canStartSelection const):
* dom/Position.cpp:
(WebCore::Position::nodeIsUserSelectNone):
(WebCore::Position::nodeIsUserSelectAll):
* dom/Range.cpp:
(WebCore::Range::collectSelectionRectsWithoutUnionInteriorLines const):
* editing/ApplyBlockElementCommand.cpp:
(WebCore::ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded):
* editing/DeleteSelectionCommand.cpp:
(WebCore::DeleteSelectionCommand::doApply):
* editing/Editing.cpp:
(WebCore::isSpecialHTMLElement):
* editing/EditorCommand.cpp:
(WebCore::verticalScrollDistance):
* editing/ReplaceSelectionCommand.cpp:
(WebCore::ReplaceSelectionCommand::doApply):
* editing/SimplifyMarkupCommand.cpp:
(WebCore::SimplifyMarkupCommand::doApply):
* editing/VisibleUnits.cpp:
(WebCore::backwardSearchForBoundaryWithTextIterator):
(WebCore::forwardSearchForBoundaryWithTextIterator):
* editing/cocoa/EditorCocoa.mm:
(WebCore::Editor::fontAttributesForSelectionStart const):
* editing/cocoa/HTMLConverter.mm:
(WebCore::editingAttributedStringFromRange):
* html/HTMLInputElement.cpp:
(WebCore::HTMLInputElement::shouldTruncateText const):
(WebCore::HTMLInputElement::createInnerTextStyle):
* html/HTMLTextFormControlElement.cpp:
(WebCore::HTMLTextFormControlElement::adjustInnerTextStyle const):
* html/shadow/SliderThumbElement.cpp:
(WebCore::RenderSliderContainer::layout):
* html/shadow/TextControlInnerElements.cpp:
(WebCore::TextControlInnerContainer::resolveCustomStyle):
(WebCore::TextControlInnerElement::resolveCustomStyle):
(WebCore::TextControlPlaceholderElement::resolveCustomStyle):
* layout/displaytree/DisplayBox.cpp:
(WebCore::Display::Box::borderBox const):
(WebCore::Display::Box::contentBox const):
* layout/displaytree/DisplayBox.h:
* layout/layouttree/LayoutBox.cpp:
(WebCore::Layout::Box::isRelativelyPositioned const):
(WebCore::Layout::Box::isStickyPositioned const):
(WebCore::Layout::Box::isAbsolutelyPositioned const):
(WebCore::Layout::Box::isFixedPositioned const):
(WebCore::Layout::Box::isFloatingPositioned const):
(WebCore::Layout::Box::isOverflowVisible const):
* page/DragController.cpp:
(WebCore::DragController::draggableElement const):
* page/Frame.cpp:
(WebCore::Frame::rangeForPoint):
* page/FrameView.cpp:
(WebCore::paginationModeForRenderStyle):
(WebCore::FrameView::applyOverflowToViewport):
(WebCore::FrameView::applyPaginationToViewport):
(WebCore::FrameView::calculateScrollbarModesForLayout):
(WebCore::FrameView::calculateExtendedBackgroundMode const):
(WebCore::FrameView::adjustScrollStepForFixedContent):
* page/SpatialNavigation.cpp:
(WebCore::canScrollInDirection):
(WebCore::canBeScrolledIntoView):
* page/ios/FrameIOS.mm:
(WebCore::Frame::nodeRespondingToScrollWheelEvents):
* page/mac/EventHandlerMac.mm:
(WebCore::scrolledToEdgeInDominantDirection):
* rendering/BorderEdge.cpp:
(WebCore::BorderEdge::BorderEdge):
(WebCore::BorderEdge::obscuresBackgroundEdge const):
(WebCore::BorderEdge::obscuresBackground const):
* rendering/BorderEdge.h:
(WebCore::BorderEdge::style const):
(WebCore::BorderEdge::hasVisibleColorAndStyle const):
* rendering/FlexibleBoxAlgorithm.h:
(WebCore::FlexLayoutAlgorithm::isMultiline const):
* rendering/FloatingObjects.cpp:
(WebCore::FloatingObject::FloatingObject):
* rendering/GridTrackSizingAlgorithm.cpp:
(WebCore::GridTrackSizingAlgorithmStrategy::minSizeForChild const):
(WebCore::GridTrackSizingAlgorithm::stretchAutoTracks):
* rendering/HitTestResult.cpp:
(WebCore::HitTestResult::innerTextIfTruncated const):
* rendering/ImageQualityController.cpp:
(WebCore::ImageQualityController::interpolationQualityFromStyle):
* rendering/InlineBox.h:
(WebCore::InlineBox::verticalAlign const):
* rendering/InlineFlowBox.cpp:
(WebCore::InlineFlowBox::addToLine):
(WebCore::InlineFlowBox::determineSpacingForFlowBoxes):
(WebCore::InlineFlowBox::adjustMaxAscentAndDescent):
(WebCore::InlineFlowBox::computeLogicalBoxHeights):
(WebCore::InlineFlowBox::placeBoxesInBlockDirection):
(WebCore::InlineFlowBox::paintFillLayer):
* rendering/LogicalSelectionOffsetCaches.h:
(WebCore::LogicalSelectionOffsetCaches::containingBlockInfo const):
* rendering/RenderBlock.cpp:
(WebCore::RenderBlock::removePositionedObjectsIfNeeded):
(WebCore::RenderBlock::styleDidChange):
(WebCore::RenderBlock::isSelfCollapsingBlock const):
(WebCore::RenderBlock::addOverflowFromPositionedObjects):
(WebCore::RenderBlock::markFixedPositionObjectForLayoutIfNeeded):
(WebCore::RenderBlock::isSelectionRoot const):
(WebCore::RenderBlock::selectionGaps):
(WebCore::RenderBlock::computeBlockPreferredLogicalWidths const):
(WebCore::RenderBlock::adjustBorderBoxLogicalHeightForBoxSizing const):
(WebCore::RenderBlock::adjustContentBoxLogicalHeightForBoxSizing const):
* rendering/RenderBlockFlow.cpp:
(WebCore::RenderBlockFlow::MarginInfo::MarginInfo):
(WebCore::RenderBlockFlow::willCreateColumns const):
(WebCore::RenderBlockFlow::marginOffsetForSelfCollapsingBlock):
(WebCore::RenderBlockFlow::clearFloatsIfNeeded):
(WebCore::RenderBlockFlow::marginBeforeEstimateForChild const):
(WebCore::RenderBlockFlow::setMustDiscardMarginBefore):
(WebCore::RenderBlockFlow::setMustDiscardMarginAfter):
(WebCore::RenderBlockFlow::mustDiscardMarginBefore const):
(WebCore::RenderBlockFlow::mustDiscardMarginAfter const):
(WebCore::RenderBlockFlow::mustDiscardMarginBeforeForChild const):
(WebCore::RenderBlockFlow::mustDiscardMarginAfterForChild const):
(WebCore::RenderBlockFlow::mustSeparateMarginBeforeForChild const):
(WebCore::RenderBlockFlow::mustSeparateMarginAfterForChild const):
(WebCore::RenderBlockFlow::styleDidChange):
(WebCore::RenderBlockFlow::styleWillChange):
(WebCore::RenderBlockFlow::computeLogicalLocationForFloat):
(WebCore::RenderBlockFlow::positionNewFloats):
(WebCore::RenderBlockFlow::clearFloats):
(WebCore::RenderBlockFlow::getClearDelta):
(WebCore::RenderBlockFlow::inlineBlockBaseline const):
(WebCore::RenderBlockFlow::computeInlinePreferredLogicalWidths const):
* rendering/RenderBlockFlow.h:
* rendering/RenderBlockLineLayout.cpp:
(WebCore::expansionBehaviorForInlineTextBox):
(WebCore::isCollapsibleSpace):
(WebCore::RenderBlockFlow::layoutRunsAndFloats):
(WebCore::RenderBlockFlow::layoutLineBoxes):
* rendering/RenderBox.cpp:
(WebCore::RenderBox::styleWillChange):
(WebCore::RenderBox::styleDidChange):
(WebCore::RenderBox::updateFromStyle):
(WebCore::RenderBox::includeVerticalScrollbarSize const):
(WebCore::RenderBox::includeHorizontalScrollbarSize const):
(WebCore::RenderBox::intrinsicScrollbarLogicalWidth const):
(WebCore::RenderBox::hasVerticalScrollbarWithAutoBehavior const):
(WebCore::RenderBox::hasHorizontalScrollbarWithAutoBehavior const):
(WebCore::RenderBox::adjustBorderBoxLogicalWidthForBoxSizing const):
(WebCore::RenderBox::adjustBorderBoxLogicalHeightForBoxSizing const):
(WebCore::RenderBox::adjustContentBoxLogicalWidthForBoxSizing const):
(WebCore::RenderBox::adjustContentBoxLogicalHeightForBoxSizing const):
(WebCore::RenderBox::backgroundIsKnownToBeOpaqueInRect const):
(WebCore::isCandidateForOpaquenessTest):
(WebCore::RenderBox::foregroundIsKnownToBeOpaqueInRect const):
(WebCore::RenderBox::backgroundHasOpaqueTopLayer const):
(WebCore::RenderBox::computeRectForRepaint const):
(WebCore::RenderBox::computeLogicalWidthInFragment const):
(WebCore::RenderBox::columnFlexItemHasStretchAlignment const):
(WebCore::RenderBox::isStretchingColumnFlexItem const):
(WebCore::RenderBox::hasStretchedLogicalWidth const):
(WebCore::RenderBox::sizesLogicalWidthToFitContent const):
(WebCore::RenderBox::computeLogicalHeight const):
(WebCore::RenderBox::computeIntrinsicLogicalContentHeightUsing const):
(WebCore::RenderBox::createsNewFormattingContext const):
* rendering/RenderBox.h:
(WebCore::RenderBox::scrollsOverflowX const):
(WebCore::RenderBox::scrollsOverflowY const):
(WebCore::RenderBox::selfAlignmentNormalBehavior const):
* rendering/RenderBoxModelObject.cpp:
(WebCore::RenderBoxModelObject::paintFillLayerExtended):
(WebCore::RenderBoxModelObject::calculateFillTileSize const):
(WebCore::RenderBoxModelObject::calculateBackgroundImageGeometry const):
(WebCore::styleRequiresClipPolygon):
(WebCore::borderStyleFillsBorderArea):
(WebCore::borderStyleHasInnerDetail):
(WebCore::borderStyleIsDottedOrDashed):
(WebCore::borderStyleHasUnmatchedColorsAtCorner):
(WebCore::borderStylesRequireMitre):
(WebCore::RenderBoxModelObject::paintBorder):
(WebCore::RenderBoxModelObject::drawBoxSideFromPath):
(WebCore::RenderBoxModelObject::boxShadowShouldBeAppliedToBackground const):
* rendering/RenderBoxModelObject.h:
* rendering/RenderDeprecatedFlexibleBox.cpp:
(WebCore::FlexBoxIterator::FlexBoxIterator):
(WebCore::RenderDeprecatedFlexibleBox::layoutBlock):
(WebCore::RenderDeprecatedFlexibleBox::layoutHorizontalBox):
(WebCore::RenderDeprecatedFlexibleBox::layoutVerticalBox):
* rendering/RenderDeprecatedFlexibleBox.h:
* rendering/RenderElement.cpp:
(WebCore::RenderElement::adjustStyleDifference const):
(WebCore::RenderElement::shouldRepaintForStyleDifference const):
(WebCore::RenderElement::initializeStyle):
(WebCore::RenderElement::setStyle):
(WebCore::RenderElement::didAttachChild):
(WebCore::RenderElement::propagateStyleToAnonymousChildren):
(WebCore::RenderElement::styleWillChange):
(WebCore::RenderElement::styleDidChange):
(WebCore::mustRepaintFillLayers):
(WebCore::RenderElement::selectionColor const):
(WebCore::RenderElement::selectionBackgroundColor const):
(WebCore::RenderElement::drawLineForBoxSide const):
(WebCore::RenderElement::paintFocusRing):
(WebCore::RenderElement::paintOutline):
(WebCore::RenderElement::updateOutlineAutoAncestor):
(WebCore::includeNonFixedHeight):
* rendering/RenderElement.h:
(WebCore::RenderElement::hasHiddenBackface const):
(WebCore::RenderElement::canContainAbsolutelyPositionedObjects const):
* rendering/RenderFlexibleBox.cpp:
(WebCore::RenderFlexibleBox::firstLineBaseline const):
(WebCore::contentAlignmentNormalBehavior):
(WebCore::RenderFlexibleBox::styleDidChange):
(WebCore::RenderFlexibleBox::repositionLogicalHeightDependentFlexItems):
(WebCore::RenderFlexibleBox::isLeftToRightFlow const):
(WebCore::RenderFlexibleBox::isMultiline const):
(WebCore::RenderFlexibleBox::adjustChildSizeForMinAndMax):
(WebCore::RenderFlexibleBox::crossSizeForPercentageResolution):
(WebCore::initialJustifyContentOffset):
(WebCore::justifyContentSpaceBetweenChildren):
(WebCore::alignmentOffset):
(WebCore::RenderFlexibleBox::staticMainAxisPositionForPositionedChild):
(WebCore::RenderFlexibleBox::staticCrossAxisPositionForPositionedChild):
(WebCore::RenderFlexibleBox::alignmentForChild const):
(WebCore::RenderFlexibleBox::needToStretchChildLogicalHeight const):
(WebCore::RenderFlexibleBox::mainAxisOverflowForChild const):
(WebCore::RenderFlexibleBox::crossAxisOverflowForChild const):
(WebCore::RenderFlexibleBox::layoutAndPlaceChildren):
(WebCore::RenderFlexibleBox::layoutColumnReverse):
(WebCore::initialAlignContentOffset):
(WebCore::alignContentSpaceBetweenChildren):
(WebCore::RenderFlexibleBox::alignFlexLines):
(WebCore::RenderFlexibleBox::alignChildren):
* rendering/RenderFlexibleBox.h:
* rendering/RenderFragmentContainer.cpp:
(WebCore::RenderFragmentContainer::overflowRectForFragmentedFlowPortion):
* rendering/RenderFullScreen.cpp:
(WebCore::createFullScreenStyle):
* rendering/RenderFullScreen.h:
* rendering/RenderGrid.cpp:
(WebCore::RenderGrid::selfAlignmentChangedToStretch const):
(WebCore::RenderGrid::selfAlignmentChangedFromStretch const):
(WebCore::RenderGrid::styleDidChange):
(WebCore::contentAlignmentNormalBehaviorGrid):
(WebCore::computeOverflowAlignmentOffset):
(WebCore::RenderGrid::isInlineBaselineAlignedChild const):
(WebCore::RenderGrid::columnAxisPositionForChild const):
(WebCore::RenderGrid::rowAxisPositionForChild const):
(WebCore::RenderGrid::resolveAutoStartGridPosition const):
(WebCore::RenderGrid::resolveAutoEndGridPosition const):
(WebCore::resolveContentDistributionFallback):
(WebCore::contentDistributionOffset):
(WebCore::RenderGrid::computeContentPositionAndDistributionOffset const):
* rendering/RenderGrid.h:
* rendering/RenderIFrame.cpp:
(WebCore::RenderIFrame::requiresLayer const):
* rendering/RenderImage.cpp:
(WebCore::RenderImage::styleDidChange):
(WebCore::RenderImage::foregroundIsKnownToBeOpaqueInRect const):
* rendering/RenderInline.cpp:
(WebCore::RenderInline::styleWillChange):
(WebCore::RenderInline::updateAlwaysCreateLineBoxes):
(WebCore::RenderInline::paintOutline):
(WebCore::RenderInline::paintOutlineForLine):
* rendering/RenderLayer.cpp:
(WebCore::isContainerForPositioned):
(WebCore::RenderLayer::enclosingAncestorForPosition const):
(WebCore::accumulateOffsetTowardsAncestor):
(WebCore::RenderLayer::canResize const):
(WebCore::RenderLayer::resize):
(WebCore::RenderLayer::scrollCornerRect const):
(WebCore::resizerCornerRect):
(WebCore::RenderLayer::hasOverflowControls const):
(WebCore::styleRequiresScrollbar):
(WebCore::styleDefinesAutomaticScrollbar):
(WebCore::RenderLayer::updateScrollbarsAfterLayout):
(WebCore::RenderLayer::paintResizer):
(WebCore::RenderLayer::hitTestOverflowControls):
(WebCore::RenderLayer::hitTestLayer):
(WebCore::RenderLayer::calculateClipRects const):
* rendering/RenderLayer.h:
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::updateGeometry):
(WebCore::canDirectlyCompositeBackgroundBackgroundImage):
(WebCore::RenderLayerBacking::isSimpleContainerCompositingLayer const):
(WebCore::backgroundRectForBox):
* rendering/RenderLayerCompositor.cpp:
(WebCore::isScrollableOverflow):
(WebCore::styleChangeRequiresLayerRebuild):
(WebCore::RenderLayerCompositor::layerStyleChanged):
(WebCore::RenderLayerCompositor::reasonsForCompositing const):
(WebCore::RenderLayerCompositor::requiresCompositingForBackfaceVisibility const):
(WebCore::RenderLayerCompositor::requiresCompositingForIndirectReason const):
(WebCore::RenderLayerCompositor::isViewportConstrainedFixedOrStickyLayer const):
(WebCore::RenderLayerCompositor::requiresCompositingForPosition const):
(WebCore::RenderLayerCompositor::layerHas3DContent const):
(WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):
* rendering/RenderLayerModelObject.cpp:
(WebCore::RenderLayerModelObject::styleWillChange):
* rendering/RenderMenuList.cpp:
(WebCore::RenderMenuList::adjustInnerStyle):
* rendering/RenderMultiColumnFlow.cpp:
(WebCore::RenderMultiColumnFlow::isColumnSpanningDescendant const):
* rendering/RenderMultiColumnSet.cpp:
(WebCore::RenderMultiColumnSet::requiresBalancing const):
(WebCore::RenderMultiColumnSet::paintColumnRules):
* rendering/RenderMultiColumnSpannerPlaceholder.cpp:
(WebCore::RenderMultiColumnSpannerPlaceholder::createAnonymous):
* rendering/RenderObject.cpp:
(WebCore::RenderObject::propagateRepaintToParentWithOutlineAutoIfNeeded const):
(WebCore::containerForElement):
(WebCore::RenderObject::calculateBorderStyleColor):
* rendering/RenderObject.h:
(WebCore::RenderObject::isFixedPositioned const):
(WebCore::RenderObject::isAbsolutelyPositioned const):
(WebCore::RenderObject::setPositionState):
(WebCore::RenderObject::RenderObjectBitfields::setPositionedState):
(WebCore::RenderObject::RenderObjectBitfields::clearPositionedState):
* rendering/RenderQuote.cpp:
(WebCore::RenderQuote::styleDidChange):
(WebCore::RenderQuote::computeText const):
(WebCore::RenderQuote::isOpen const):
* rendering/RenderReplaced.cpp:
(WebCore::RenderReplaced::layout):
(WebCore::RenderReplaced::setNeedsLayoutIfNeededAfterIntrinsicSizeChange):
(WebCore::RenderReplaced::replacedContentRect const):
* rendering/RenderScrollbarPart.cpp:
(WebCore::RenderScrollbarPart::styleDidChange):
* rendering/RenderTable.cpp:
(WebCore::RenderTable::styleDidChange):
(WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):
(WebCore::RenderTable::convertStyleLogicalHeightToComputedHeight):
(WebCore::RenderTable::calcBorderStart const):
(WebCore::RenderTable::calcBorderEnd const):
(WebCore::RenderTable::outerBorderBefore const):
(WebCore::RenderTable::outerBorderAfter const):
(WebCore::RenderTable::outerBorderStart const):
(WebCore::RenderTable::outerBorderEnd const):
* rendering/RenderTable.h:
(WebCore::RenderTable::collapseBorders const):
* rendering/RenderTableCell.cpp:
(WebCore::RenderTableCell::computeIntrinsicPadding):
(WebCore::RenderTableCell::styleDidChange):
(WebCore::compareBorders):
(WebCore::chooseBorder):
(WebCore::emptyBorder):
(WebCore::RenderTableCell::computeCollapsedStartBorder const):
(WebCore::RenderTableCell::computeCollapsedEndBorder const):
(WebCore::RenderTableCell::computeCollapsedBeforeBorder const):
(WebCore::RenderTableCell::computeCollapsedAfterBorder const):
(WebCore::CollapsedBorders::addBorder):
(WebCore::RenderTableCell::paintCollapsedBorders):
(WebCore::RenderTableCell::scrollbarsChanged):
* rendering/RenderTableCell.h:
(WebCore::RenderTableCell::logicalHeightForRowSizing const):
(WebCore::RenderTableCell::isBaselineAligned const):
* rendering/RenderTableRow.cpp:
(WebCore::RenderTableRow::styleDidChange):
* rendering/RenderTableSection.cpp:
(WebCore::RenderTableSection::calcOuterBorderBefore const):
(WebCore::RenderTableSection::calcOuterBorderAfter const):
(WebCore::RenderTableSection::calcOuterBorderStart const):
(WebCore::RenderTableSection::calcOuterBorderEnd const):
(WebCore::RenderTableSection::paintRowGroupBorder):
(WebCore::RenderTableSection::paintRowGroupBorderIfRequired):
(WebCore::RenderTableSection::cachedCollapsedBorder):
* rendering/RenderTableSection.h:
* rendering/RenderText.cpp:
(WebCore::RenderText::styleDidChange):
(WebCore::RenderText::absoluteQuadsClippedToEllipsis const):
(WebCore::isSpaceAccordingToStyle):
(WebCore::mapLineBreakToIteratorMode):
(WebCore::RenderText::computePreferredLogicalWidths):
(WebCore::RenderText::setRenderedText):
(WebCore::RenderText::textWithoutConvertingBackslashToYenSymbol const):
(WebCore::RenderText::momentarilyRevealLastTypedCharacter):
* rendering/RenderTextControl.cpp:
(WebCore::RenderTextControl::computeLogicalHeight const):
* rendering/RenderTextControlSingleLine.cpp:
(WebCore::RenderTextControlSingleLine::styleDidChange):
* rendering/RenderTheme.cpp:
(WebCore::RenderTheme::extractControlStatesForRenderer const):
* rendering/RenderThemeIOS.mm:
(WebCore::adjustInputElementButtonStyle):
* rendering/RenderThemeMac.mm:
(WebCore::RenderThemeMac::updateFocusedState):
(WebCore::RenderThemeMac::paintCellAndSetFocusedElementNeedsRepaintIfNecessary):
(WebCore::RenderThemeMac::adjustSearchFieldStyle const):
* rendering/RenderTreeAsText.cpp:
(WebCore::printBorderStyle):
* rendering/RenderVideo.cpp:
(WebCore::RenderVideo::updatePlayer):
* rendering/RenderView.cpp:
(WebCore::RenderView::RenderView):
(WebCore::rendererObscuresBackground):
* rendering/RootInlineBox.cpp:
(WebCore::RootInlineBox::verticalPositionForBox):
* rendering/SimpleLineLayout.cpp:
(WebCore::SimpleLineLayout::canUseForStyle):
(WebCore::SimpleLineLayout::canUseForWithReason):
* rendering/SimpleLineLayoutTextFragmentIterator.cpp:
(WebCore::SimpleLineLayout::TextFragmentIterator::Style::Style):
* rendering/TextPaintStyle.cpp:
(WebCore::computeTextPaintStyle):
* rendering/line/BreakingContext.h:
(WebCore::BreakingContext::handleBR):
(WebCore::shouldAddBorderPaddingMargin):
(WebCore::BreakingContext::handleText):
(WebCore::BreakingContext::optimalLineBreakLocationForTrailingWord):
* rendering/line/LineBreaker.cpp:
(WebCore::LineBreaker::reset):
* rendering/line/LineBreaker.h:
(WebCore::LineBreaker::clear):
* rendering/line/LineInlineHeaders.h:
(WebCore::skipNonBreakingSpace):
* rendering/line/LineWidth.cpp:
(WebCore::requiresIndent):
* rendering/style/BorderData.h:
(WebCore::BorderData::borderLeftWidth const):
(WebCore::BorderData::borderRightWidth const):
(WebCore::BorderData::borderTopWidth const):
(WebCore::BorderData::borderBottomWidth const):
* rendering/style/BorderValue.h:
(WebCore::BorderValue::BorderValue):
(WebCore::BorderValue::nonZero const):
(WebCore::BorderValue::isVisible const):
(WebCore::BorderValue::style const):
* rendering/style/CollapsedBorderValue.h:
(WebCore::CollapsedBorderValue::CollapsedBorderValue):
(WebCore::CollapsedBorderValue::width const):
(WebCore::CollapsedBorderValue::style const):
(WebCore::CollapsedBorderValue::exists const):
(WebCore::CollapsedBorderValue::precedence const):
* rendering/style/FillLayer.cpp:
(WebCore::FillLayer::FillLayer):
(WebCore::clipMax):
(WebCore::FillLayer::computeClipMax const):
(WebCore::FillLayer::hasRepeatXY const):
(WebCore::FillLayer::hasFixedImage const):
* rendering/style/FillLayer.h:
(WebCore::FillSize::FillSize):
(WebCore::FillLayer::attachment const):
(WebCore::FillLayer::clip const):
(WebCore::FillLayer::origin const):
(WebCore::FillLayer::repeatX const):
(WebCore::FillLayer::repeatY const):
(WebCore::FillLayer::sizeType const):
(WebCore::FillLayer::size const):
(WebCore::FillLayer::maskSourceType const):
(WebCore::FillLayer::isSizeSet const):
(WebCore::FillLayer::setAttachment):
(WebCore::FillLayer::setClip):
(WebCore::FillLayer::setOrigin):
(WebCore::FillLayer::setRepeatX):
(WebCore::FillLayer::setRepeatY):
(WebCore::FillLayer::setComposite):
(WebCore::FillLayer::setBlendMode):
(WebCore::FillLayer::setSizeType):
(WebCore::FillLayer::setSize):
(WebCore::FillLayer::setMaskSourceType):
(WebCore::FillLayer::clearSize):
(WebCore::FillLayer::type const):
(WebCore::FillLayer::initialFillAttachment):
(WebCore::FillLayer::initialFillClip):
(WebCore::FillLayer::initialFillOrigin):
(WebCore::FillLayer::initialFillRepeatX):
(WebCore::FillLayer::initialFillRepeatY):
(WebCore::FillLayer::initialFillComposite):
(WebCore::FillLayer::initialFillBlendMode):
(WebCore::FillLayer::initialFillSize):
(WebCore::FillLayer::initialFillXPosition):
(WebCore::FillLayer::initialFillYPosition):
(WebCore::FillLayer::initialFillImage):
(WebCore::FillLayer::initialFillMaskSourceType):
* rendering/style/LineClampValue.h:
(WebCore::LineClampValue::LineClampValue):
(WebCore::LineClampValue::isPercentage const):
* rendering/style/RenderStyle.cpp:
(WebCore::RenderStyle::RenderStyle):
(WebCore::resolvedSelfAlignment):
(WebCore::RenderStyle::resolvedAlignSelf const):
(WebCore::RenderStyle::resolvedJustifySelf const):
(WebCore::resolvedContentAlignment):
(WebCore::resolvedContentAlignmentPosition):
(WebCore::resolvedContentAlignmentDistribution):
(WebCore::RenderStyle::resolvedJustifyContentDistribution const):
(WebCore::RenderStyle::resolvedAlignContentDistribution const):
(WebCore::RenderStyle::changeRequiresLayout const):
(WebCore::RenderStyle::changeRequiresPositionedLayoutOnly const):
(WebCore::RenderStyle::changeRequiresLayerRepaint const):
(WebCore::RenderStyle::changeRequiresRepaint const):
(WebCore::RenderStyle::changeRequiresRepaintIfTextOrBorderOrOutline const):
(WebCore::RenderStyle::changeRequiresRecompositeLayer const):
(WebCore::RenderStyle::diff const):
(WebCore::RenderStyle::diffRequiresLayerRepaint const):
(WebCore::allLayersAreFixed):
(WebCore::RenderStyle::colorIncludingFallback const):
(WebCore::RenderStyle::setColumnStylesFromPaginationMode):
(WebCore::RenderStyle::outlineWidth const):
(WebCore::RenderStyle::outlineOffset const):
* rendering/style/RenderStyle.h:
(WebCore::RenderStyle::isFloating const):
(WebCore::RenderStyle::position const):
(WebCore::RenderStyle::hasOutOfFlowPosition const):
(WebCore::RenderStyle::hasInFlowPosition const):
(WebCore::RenderStyle::hasViewportConstrainedPosition const):
(WebCore::RenderStyle::floating const):
(WebCore::RenderStyle::borderLeftStyle const):
(WebCore::RenderStyle::borderRightStyle const):
(WebCore::RenderStyle::borderTopStyle const):
(WebCore::RenderStyle::borderBottomStyle const):
(WebCore::RenderStyle::hasOutline const):
(WebCore::RenderStyle::outlineStyle const):
(WebCore::RenderStyle::overflowX const):
(WebCore::RenderStyle::overflowY const):
(WebCore::RenderStyle::overflowInlineDirection const):
(WebCore::RenderStyle::overflowBlockDirection const):
(WebCore::RenderStyle::verticalAlign const):
(WebCore::RenderStyle::clear const):
(WebCore::RenderStyle::tableLayout const):
(WebCore::RenderStyle::backgroundRepeatX const):
(WebCore::RenderStyle::backgroundRepeatY const):
(WebCore::RenderStyle::backgroundAttachment const):
(WebCore::RenderStyle::backgroundClip const):
(WebCore::RenderStyle::backgroundOrigin const):
(WebCore::RenderStyle::backgroundSizeType const):
(WebCore::RenderStyle::maskRepeatX const):
(WebCore::RenderStyle::maskRepeatY const):
(WebCore::RenderStyle::maskClip const):
(WebCore::RenderStyle::maskOrigin const):
(WebCore::RenderStyle::maskSizeType const):
(WebCore::RenderStyle::borderCollapse const):
(WebCore::RenderStyle::boxAlign const):
(WebCore::RenderStyle::boxDirection const):
(WebCore::RenderStyle::boxLines const):
(WebCore::RenderStyle::boxOrient const):
(WebCore::RenderStyle::boxPack const):
(WebCore::RenderStyle::flexDirection const):
(WebCore::RenderStyle::isColumnFlexDirection const):
(WebCore::RenderStyle::isReverseFlexDirection const):
(WebCore::RenderStyle::flexWrap const):
(WebCore::RenderStyle::boxDecorationBreak const):
(WebCore::RenderStyle::boxSizing const):
(WebCore::RenderStyle::userModify const):
(WebCore::RenderStyle::userDrag const):
(WebCore::RenderStyle::userSelect const):
(WebCore::RenderStyle::marginBeforeCollapse const):
(WebCore::RenderStyle::marginAfterCollapse const):
(WebCore::RenderStyle::wordBreak const):
(WebCore::RenderStyle::overflowWrap const):
(WebCore::RenderStyle::nbspMode const):
(WebCore::RenderStyle::resize const):
(WebCore::RenderStyle::columnRuleStyle const):
(WebCore::RenderStyle::hasTextCombine const):
(WebCore::RenderStyle::transformStyle3D const):
(WebCore::RenderStyle::preserves3D const):
(WebCore::RenderStyle::backfaceVisibility const):
(WebCore::RenderStyle::textSecurity const):
(WebCore::RenderStyle::imageRendering const):
(WebCore::RenderStyle::setIsolation):
(WebCore::RenderStyle::hasIsolation const):
(WebCore::RenderStyle::isolation const):
(WebCore::RenderStyle::setPosition):
(WebCore::RenderStyle::setFloating):
(WebCore::RenderStyle::setBackgroundSize):
(WebCore::RenderStyle::setBorderLeftStyle):
(WebCore::RenderStyle::setBorderRightStyle):
(WebCore::RenderStyle::setBorderTopStyle):
(WebCore::RenderStyle::setBorderBottomStyle):
(WebCore::RenderStyle::setOutlineStyleIsAuto):
(WebCore::RenderStyle::setOutlineStyle):
(WebCore::RenderStyle::setOverflowX):
(WebCore::RenderStyle::setOverflowY):
(WebCore::RenderStyle::setVerticalAlign):
(WebCore::RenderStyle::setVerticalAlignLength):
(WebCore::RenderStyle::setClear):
(WebCore::RenderStyle::setTableLayout):
(WebCore::RenderStyle::setImageRendering):
(WebCore::RenderStyle::clearBackgroundLayers):
(WebCore::RenderStyle::clearMaskLayers):
(WebCore::RenderStyle::setBorderCollapse):
(WebCore::RenderStyle::setAspectRatioType):
(WebCore::RenderStyle::setPrintColorAdjust):
(WebCore::RenderStyle::setBoxAlign):
(WebCore::RenderStyle::setBoxDirection):
(WebCore::RenderStyle::setBoxLines):
(WebCore::RenderStyle::setBoxOrient):
(WebCore::RenderStyle::setBoxPack):
(WebCore::RenderStyle::setBoxSizing):
(WebCore::RenderStyle::setFlexDirection):
(WebCore::RenderStyle::setFlexWrap):
(WebCore::RenderStyle::setBoxDecorationBreak):
(WebCore::RenderStyle::setUserModify):
(WebCore::RenderStyle::setUserDrag):
(WebCore::RenderStyle::setUserSelect):
(WebCore::RenderStyle::setTextOverflow):
(WebCore::RenderStyle::setMarginBeforeCollapse):
(WebCore::RenderStyle::setMarginAfterCollapse):
(WebCore::RenderStyle::setWordBreak):
(WebCore::RenderStyle::setOverflowWrap):
(WebCore::RenderStyle::setNBSPMode):
(WebCore::RenderStyle::setLineBreak):
(WebCore::RenderStyle::setResize):
(WebCore::RenderStyle::setColumnFill):
(WebCore::RenderStyle::setColumnRuleStyle):
(WebCore::RenderStyle::setColumnSpan):
(WebCore::RenderStyle::setTextCombine):
(WebCore::RenderStyle::setObjectFit):
(WebCore::RenderStyle::setTransformStyle3D):
(WebCore::RenderStyle::setBackfaceVisibility):
(WebCore::RenderStyle::setTextSecurity):
(WebCore::RenderStyle::initialOverflowX):
(WebCore::RenderStyle::initialOverflowY):
(WebCore::RenderStyle::initialClear):
(WebCore::RenderStyle::initialPosition):
(WebCore::RenderStyle::initialVerticalAlign):
(WebCore::RenderStyle::initialFloating):
(WebCore::RenderStyle::initialTableLayout):
(WebCore::RenderStyle::initialBorderCollapse):
(WebCore::RenderStyle::initialBorderStyle):
(WebCore::RenderStyle::initialOutlineStyleIsAuto):
(WebCore::RenderStyle::initialTextCombine):
(WebCore::RenderStyle::initialObjectFit):
(WebCore::RenderStyle::initialBoxAlign):
(WebCore::RenderStyle::initialBoxDecorationBreak):
(WebCore::RenderStyle::initialBoxDirection):
(WebCore::RenderStyle::initialBoxLines):
(WebCore::RenderStyle::initialBoxOrient):
(WebCore::RenderStyle::initialBoxPack):
(WebCore::RenderStyle::initialBoxSizing):
(WebCore::RenderStyle::initialJustifyItems):
(WebCore::RenderStyle::initialSelfAlignment):
(WebCore::RenderStyle::initialDefaultAlignment):
(WebCore::RenderStyle::initialContentAlignment):
(WebCore::RenderStyle::initialFlexDirection):
(WebCore::RenderStyle::initialFlexWrap):
(WebCore::RenderStyle::initialUserModify):
(WebCore::RenderStyle::initialUserDrag):
(WebCore::RenderStyle::initialUserSelect):
(WebCore::RenderStyle::initialTextOverflow):
(WebCore::RenderStyle::initialMarginBeforeCollapse):
(WebCore::RenderStyle::initialMarginAfterCollapse):
(WebCore::RenderStyle::initialWordBreak):
(WebCore::RenderStyle::initialOverflowWrap):
(WebCore::RenderStyle::initialNBSPMode):
(WebCore::RenderStyle::initialLineBreak):
(WebCore::RenderStyle::initialResize):
(WebCore::RenderStyle::initialAspectRatioType):
(WebCore::RenderStyle::initialColumnFill):
(WebCore::RenderStyle::initialColumnSpan):
(WebCore::RenderStyle::initialTransformStyle3D):
(WebCore::RenderStyle::initialBackfaceVisibility):
(WebCore::RenderStyle::initialImageRendering):
(WebCore::RenderStyle::initialPrintColorAdjust):
(WebCore::RenderStyle::initialTextIndentLine):
(WebCore::RenderStyle::initialTextIndentType):
(WebCore::RenderStyle::initialTextSecurity):
(WebCore::RenderStyle::initialIsolation):
(WebCore::collapsedBorderStyle):
(WebCore::RenderStyle::breakOnlyAfterWhiteSpace const):
(WebCore::RenderStyle::breakWords const):
(WebCore::RenderStyle::setTextOrientation):
* rendering/style/RenderStyleConstants.cpp:
(WebCore::operator<<):
* rendering/style/RenderStyleConstants.h:
(WebCore::operator|):
(WebCore::operator|=):
(WebCore::operator| ): Deleted.
(WebCore::operator|= ): Deleted.
* rendering/style/SVGRenderStyle.cpp:
(WebCore::SVGRenderStyle::diff const):
* rendering/style/StyleBackgroundData.cpp:
(WebCore::StyleBackgroundData::StyleBackgroundData):
* rendering/style/StyleBoxData.cpp:
(WebCore::StyleBoxData::StyleBoxData):
* rendering/style/StyleBoxData.h:
(WebCore::StyleBoxData::boxSizing const):
(WebCore::StyleBoxData::boxDecorationBreak const):
* rendering/style/StyleContentAlignmentData.h:
(WebCore::StyleContentAlignmentData::StyleContentAlignmentData):
(WebCore::StyleContentAlignmentData::setPosition):
(WebCore::StyleContentAlignmentData::setDistribution):
(WebCore::StyleContentAlignmentData::setOverflow):
(WebCore::StyleContentAlignmentData::distribution const):
* rendering/style/StyleDeprecatedFlexibleBoxData.cpp:
(WebCore::StyleDeprecatedFlexibleBoxData::StyleDeprecatedFlexibleBoxData):
* rendering/style/StyleDeprecatedFlexibleBoxData.h:
* rendering/style/StyleFlexibleBoxData.cpp:
(WebCore::StyleFlexibleBoxData::StyleFlexibleBoxData):
* rendering/style/StyleFlexibleBoxData.h:
* rendering/style/StyleMultiColData.cpp:
(WebCore::StyleMultiColData::StyleMultiColData):
* rendering/style/StyleMultiColData.h:
(WebCore::StyleMultiColData::ruleWidth const):
* rendering/style/StyleRareInheritedData.cpp:
(WebCore::StyleRareInheritedData::StyleRareInheritedData):
* rendering/style/StyleRareInheritedData.h:
* rendering/style/StyleRareNonInheritedData.cpp:
(WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
* rendering/style/StyleRareNonInheritedData.h:
* rendering/style/StyleSelfAlignmentData.h:
(WebCore::StyleSelfAlignmentData::StyleSelfAlignmentData):
(WebCore::StyleSelfAlignmentData::setPosition):
(WebCore::StyleSelfAlignmentData::setPositionType):
(WebCore::StyleSelfAlignmentData::setOverflow):
* rendering/svg/RenderSVGBlock.cpp:
(WebCore::RenderSVGBlock::styleDidChange):
* rendering/svg/RenderSVGGradientStop.cpp:
(WebCore::RenderSVGGradientStop::styleDidChange):
* rendering/svg/RenderSVGInline.cpp:
(WebCore::RenderSVGInline::styleDidChange):
* rendering/svg/RenderSVGInlineText.cpp:
(WebCore::RenderSVGInlineText::styleDidChange):
* rendering/svg/RenderSVGModelObject.cpp:
(WebCore::RenderSVGModelObject::styleDidChange):
* rendering/svg/RenderSVGResourceContainer.cpp:
(WebCore::RenderSVGResourceContainer::registerResource):
* rendering/svg/RenderSVGResourceFilterPrimitive.cpp:
(WebCore::RenderSVGResourceFilterPrimitive::styleDidChange):
* rendering/svg/RenderSVGRoot.cpp:
(WebCore::RenderSVGRoot::layout):
(WebCore::RenderSVGRoot::shouldApplyViewportClip const):
(WebCore::RenderSVGRoot::styleDidChange):
* rendering/svg/SVGInlineTextBox.cpp:
(WebCore::SVGInlineTextBox::paintText):
* rendering/svg/SVGRenderSupport.cpp:
(WebCore::SVGRenderSupport::isOverflowHidden):
* rendering/svg/SVGResourcesCache.cpp:
(WebCore::SVGResourcesCache::clientStyleChanged):
* rendering/updating/RenderTreeBuilder.cpp:
(WebCore::RenderTreeBuilder::attachToRenderElementInternal):
* rendering/updating/RenderTreeBuilderBlock.cpp:
(WebCore::RenderTreeBuilder::Block::insertChildToContinuation):
* rendering/updating/RenderTreeBuilderFirstLetter.cpp:
(WebCore::styleForFirstLetter):
* rendering/updating/RenderTreeBuilderMultiColumn.cpp:
(WebCore::isValidColumnSpanner):
(WebCore::RenderTreeBuilder::MultiColumn::resolveMovedChild):
(WebCore::RenderTreeBuilder::MultiColumn::multiColumnRelativeWillBeRemoved):
* rendering/updating/RenderTreeUpdater.cpp:
(WebCore::RenderTreeUpdater::updateElementRenderer):
* style/StyleResolveForDocument.cpp:
(WebCore::Style::resolveForDocument):

Source/WebKit:

* WebProcess/WebPage/ios/WebPageIOS.mm:
(WebKit::WebPage::rangeForWebSelectionAtPosition):
(WebKit::WebPage::getPositionInformation):
Update for new enum names.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@232018 268f45cc-cd09-0410-ab3c-d52691b4dbfc

156 files changed:
Source/WebCore/ChangeLog
Source/WebCore/accessibility/atk/WebKitAccessibleInterfaceText.cpp
Source/WebCore/accessibility/mac/WebAccessibilityObjectWrapperMac.mm
Source/WebCore/css/BasicShapeFunctions.cpp
Source/WebCore/css/CSSComputedStyleDeclaration.cpp
Source/WebCore/css/CSSPrimitiveValueMappings.h
Source/WebCore/css/CSSProperties.json
Source/WebCore/css/CSSToStyleMap.cpp
Source/WebCore/css/CSSValueKeywords.in
Source/WebCore/css/StyleBuilderConverter.h
Source/WebCore/css/StyleBuilderCustom.h
Source/WebCore/css/StyleResolver.cpp
Source/WebCore/css/StyleResolver.h
Source/WebCore/css/makeprop.pl
Source/WebCore/dom/Element.h
Source/WebCore/dom/Node.cpp
Source/WebCore/dom/Position.cpp
Source/WebCore/dom/Range.cpp
Source/WebCore/editing/ApplyBlockElementCommand.cpp
Source/WebCore/editing/DeleteSelectionCommand.cpp
Source/WebCore/editing/Editing.cpp
Source/WebCore/editing/EditorCommand.cpp
Source/WebCore/editing/ReplaceSelectionCommand.cpp
Source/WebCore/editing/SimplifyMarkupCommand.cpp
Source/WebCore/editing/VisibleUnits.cpp
Source/WebCore/editing/cocoa/EditorCocoa.mm
Source/WebCore/editing/cocoa/HTMLConverter.mm
Source/WebCore/html/HTMLInputElement.cpp
Source/WebCore/html/HTMLTextFormControlElement.cpp
Source/WebCore/html/shadow/SliderThumbElement.cpp
Source/WebCore/html/shadow/TextControlInnerElements.cpp
Source/WebCore/layout/displaytree/DisplayBox.cpp
Source/WebCore/layout/displaytree/DisplayBox.h
Source/WebCore/layout/layouttree/LayoutBox.cpp
Source/WebCore/page/DragController.cpp
Source/WebCore/page/Frame.cpp
Source/WebCore/page/FrameView.cpp
Source/WebCore/page/SpatialNavigation.cpp
Source/WebCore/page/ios/FrameIOS.mm
Source/WebCore/page/mac/EventHandlerMac.mm
Source/WebCore/rendering/BorderEdge.cpp
Source/WebCore/rendering/BorderEdge.h
Source/WebCore/rendering/FlexibleBoxAlgorithm.h
Source/WebCore/rendering/FloatingObjects.cpp
Source/WebCore/rendering/GridTrackSizingAlgorithm.cpp
Source/WebCore/rendering/HitTestResult.cpp
Source/WebCore/rendering/ImageQualityController.cpp
Source/WebCore/rendering/InlineBox.h
Source/WebCore/rendering/InlineFlowBox.cpp
Source/WebCore/rendering/LogicalSelectionOffsetCaches.h
Source/WebCore/rendering/RenderBlock.cpp
Source/WebCore/rendering/RenderBlockFlow.cpp
Source/WebCore/rendering/RenderBlockFlow.h
Source/WebCore/rendering/RenderBlockLineLayout.cpp
Source/WebCore/rendering/RenderBox.cpp
Source/WebCore/rendering/RenderBox.h
Source/WebCore/rendering/RenderBoxModelObject.cpp
Source/WebCore/rendering/RenderBoxModelObject.h
Source/WebCore/rendering/RenderDeprecatedFlexibleBox.cpp
Source/WebCore/rendering/RenderDeprecatedFlexibleBox.h
Source/WebCore/rendering/RenderElement.cpp
Source/WebCore/rendering/RenderElement.h
Source/WebCore/rendering/RenderFlexibleBox.cpp
Source/WebCore/rendering/RenderFlexibleBox.h
Source/WebCore/rendering/RenderFragmentContainer.cpp
Source/WebCore/rendering/RenderFullScreen.cpp
Source/WebCore/rendering/RenderFullScreen.h
Source/WebCore/rendering/RenderGrid.cpp
Source/WebCore/rendering/RenderGrid.h
Source/WebCore/rendering/RenderIFrame.cpp
Source/WebCore/rendering/RenderImage.cpp
Source/WebCore/rendering/RenderInline.cpp
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayer.h
Source/WebCore/rendering/RenderLayerBacking.cpp
Source/WebCore/rendering/RenderLayerCompositor.cpp
Source/WebCore/rendering/RenderLayerModelObject.cpp
Source/WebCore/rendering/RenderMenuList.cpp
Source/WebCore/rendering/RenderMultiColumnFlow.cpp
Source/WebCore/rendering/RenderMultiColumnSet.cpp
Source/WebCore/rendering/RenderMultiColumnSpannerPlaceholder.cpp
Source/WebCore/rendering/RenderObject.cpp
Source/WebCore/rendering/RenderObject.h
Source/WebCore/rendering/RenderQuote.cpp
Source/WebCore/rendering/RenderReplaced.cpp
Source/WebCore/rendering/RenderScrollbarPart.cpp
Source/WebCore/rendering/RenderTable.cpp
Source/WebCore/rendering/RenderTable.h
Source/WebCore/rendering/RenderTableCell.cpp
Source/WebCore/rendering/RenderTableCell.h
Source/WebCore/rendering/RenderTableRow.cpp
Source/WebCore/rendering/RenderTableSection.cpp
Source/WebCore/rendering/RenderTableSection.h
Source/WebCore/rendering/RenderText.cpp
Source/WebCore/rendering/RenderTextControl.cpp
Source/WebCore/rendering/RenderTextControlSingleLine.cpp
Source/WebCore/rendering/RenderTheme.cpp
Source/WebCore/rendering/RenderThemeIOS.mm
Source/WebCore/rendering/RenderThemeMac.mm
Source/WebCore/rendering/RenderTreeAsText.cpp
Source/WebCore/rendering/RenderVideo.cpp
Source/WebCore/rendering/RenderView.cpp
Source/WebCore/rendering/RootInlineBox.cpp
Source/WebCore/rendering/SimpleLineLayout.cpp
Source/WebCore/rendering/SimpleLineLayoutTextFragmentIterator.cpp
Source/WebCore/rendering/TextPaintStyle.cpp
Source/WebCore/rendering/line/BreakingContext.h
Source/WebCore/rendering/line/LineBreaker.cpp
Source/WebCore/rendering/line/LineBreaker.h
Source/WebCore/rendering/line/LineInlineHeaders.h
Source/WebCore/rendering/line/LineWidth.cpp
Source/WebCore/rendering/style/BorderData.h
Source/WebCore/rendering/style/BorderValue.h
Source/WebCore/rendering/style/CollapsedBorderValue.h
Source/WebCore/rendering/style/FillLayer.cpp
Source/WebCore/rendering/style/FillLayer.h
Source/WebCore/rendering/style/LineClampValue.h
Source/WebCore/rendering/style/RenderStyle.cpp
Source/WebCore/rendering/style/RenderStyle.h
Source/WebCore/rendering/style/RenderStyleConstants.cpp
Source/WebCore/rendering/style/RenderStyleConstants.h
Source/WebCore/rendering/style/SVGRenderStyle.cpp
Source/WebCore/rendering/style/StyleBackgroundData.cpp
Source/WebCore/rendering/style/StyleBoxData.cpp
Source/WebCore/rendering/style/StyleBoxData.h
Source/WebCore/rendering/style/StyleContentAlignmentData.h
Source/WebCore/rendering/style/StyleDeprecatedFlexibleBoxData.cpp
Source/WebCore/rendering/style/StyleDeprecatedFlexibleBoxData.h
Source/WebCore/rendering/style/StyleFlexibleBoxData.cpp
Source/WebCore/rendering/style/StyleFlexibleBoxData.h
Source/WebCore/rendering/style/StyleMultiColData.cpp
Source/WebCore/rendering/style/StyleMultiColData.h
Source/WebCore/rendering/style/StyleRareInheritedData.cpp
Source/WebCore/rendering/style/StyleRareInheritedData.h
Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp
Source/WebCore/rendering/style/StyleRareNonInheritedData.h
Source/WebCore/rendering/style/StyleSelfAlignmentData.h
Source/WebCore/rendering/svg/RenderSVGBlock.cpp
Source/WebCore/rendering/svg/RenderSVGGradientStop.cpp
Source/WebCore/rendering/svg/RenderSVGInline.cpp
Source/WebCore/rendering/svg/RenderSVGInlineText.cpp
Source/WebCore/rendering/svg/RenderSVGModelObject.cpp
Source/WebCore/rendering/svg/RenderSVGResourceContainer.cpp
Source/WebCore/rendering/svg/RenderSVGResourceFilterPrimitive.cpp
Source/WebCore/rendering/svg/RenderSVGRoot.cpp
Source/WebCore/rendering/svg/SVGInlineTextBox.cpp
Source/WebCore/rendering/svg/SVGRenderSupport.cpp
Source/WebCore/rendering/svg/SVGResourcesCache.cpp
Source/WebCore/rendering/updating/RenderTreeBuilder.cpp
Source/WebCore/rendering/updating/RenderTreeBuilderBlock.cpp
Source/WebCore/rendering/updating/RenderTreeBuilderFirstLetter.cpp
Source/WebCore/rendering/updating/RenderTreeBuilderMultiColumn.cpp
Source/WebCore/rendering/updating/RenderTreeUpdater.cpp
Source/WebCore/style/StyleResolveForDocument.cpp
Source/WebKit/ChangeLog
Source/WebKit/WebProcess/WebPage/ios/WebPageIOS.mm

index 43ab552..2ced559 100644 (file)
@@ -1,3 +1,934 @@
+2018-05-21  Sam Weinig  <sam@webkit.org>
+
+        Modernize RenderStyleConstants.h - Part 1
+        https://bugs.webkit.org/show_bug.cgi?id=185809
+
+        Reviewed by Yusuke Suzuki.
+            
+        Modernized the first set of enums in RenderStyleConstants.h by:
+            - Converting them to enum classes
+            - Renaming them to remove unnecessary prefix 'E's
+            - Renaming values to take advantage of enum class scoping (e.g. StyleDifferenceEqual -> StyleDifference::Equal)
+            - Renaming to match modern conventions (e.g BNONE -> None)
+            - Reformatting them so that each value is on its own line.
+
+        Modernizes the following enums:
+            PrintColorAdjust
+            StyleDifference
+            StyleDifferenceContextSensitiveProperty
+            ColumnFill
+            ColumnSpan
+            BorderCollapse (renamed from EBorderCollapse)
+            BorderStyle (renamed from EBorderStyle)
+            BorderPrecedence (renamed from EBorderPrecedence)
+            OutlineIsAuto
+            PositionType (renamed from EPosition)
+            Float (renamed from EFloat)
+            MarginCollapse (renamed from EMarginCollapse)
+            BoxDecorationBreak (renamed from EBoxDecorationBreak)
+            BoxSizing (renamed from EBoxSizing)
+            Overflow (renamed from EOverflow)
+            VerticalAlign (renamed from EVerticalAlign)
+            Clear (renamed from EClear)
+            TableLayoutType (renamed from ETableLayout)
+            TextCombine
+            FillAttachment (renamed from EFillAttachment)
+            FillBox (renamed from EFillBox)
+            FillRepeat (renamed from EFillRepeat)
+            FillLayerType (renamed from EFillLayerType)
+            FillSizeType (renamed from EFillSizeType)
+            MaskSourceType (renamed from EMaskSourceType)
+            BoxPack (renamed from EBoxPack)
+            BoxAlignment (renamed from EBoxAlignment)
+            BoxOrient (renamed from EBoxOrient)
+            BoxLines (renamed from EBoxLines)
+            BoxDirection (renamed from EBoxDirection)
+            AlignContent (renamed from EAlignContent)
+            FlexDirection (renamed from EFlexDirection)
+            FlexWrap (renamed from EFlexWrap)
+            ItemPosition
+            OverflowAlignment
+            ItemPositionType
+            ContentPosition
+            ContentDistribution (renamed from ContentDistributionType)
+            TextSecurity (renamed from ETextSecurity)
+            UserModify (renamed from EUserModify)
+            UserDrag (renamed from EUserDrag)
+            UserSelect (renamed from EUserSelect)
+            ObjectFit
+            AspectRatioType
+            WordBreak (renamed from EWordBreak)
+            OverflowWrap (renamed from EOverflowWrap)
+            NBSPMode (renamed from ENBSPMode)
+            LineBreak
+            Resize (renamed from EResize)
+            QuoteType
+            TransformStyle3D (renamed from ETransformStyle3D)
+            BackfaceVisibility (renamed from EBackfaceVisibility)
+            LineClamp (renamed from ELineClamp)
+            TextOverflow
+            ImageRendering (renamed from EImageRendering)
+            TextIndentLine
+            TextIndentType
+            Isolation
+
+        * accessibility/mac/WebAccessibilityObjectWrapperMac.mm:
+        (AXAttributeStringSetStyle):
+        * css/BasicShapeFunctions.cpp:
+        (WebCore::valueForCenterCoordinate):
+        (WebCore::valueForBasicShape):
+        * css/CSSComputedStyleDeclaration.cpp:
+        (WebCore::sizingBox):
+        (WebCore::fillRepeatToCSSValue):
+        (WebCore::fillSourceTypeToCSSValue):
+        (WebCore::fillSizeToCSSValue):
+        (WebCore::valueForItemPositionWithOverflowAlignment):
+        (WebCore::valueForContentPositionAndDistributionWithOverflowAlignment):
+        (WebCore::ComputedStyleExtractor::valueForPropertyinStyle):
+        * css/CSSPrimitiveValueMappings.h:
+        (WebCore::CSSPrimitiveValue::operator LineClampValue const):
+        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
+        (WebCore::CSSPrimitiveValue::operator ColumnFill const):
+        (WebCore::CSSPrimitiveValue::operator ColumnSpan const):
+        (WebCore::CSSPrimitiveValue::operator PrintColorAdjust const):
+        (WebCore::CSSPrimitiveValue::operator BorderStyle const):
+        (WebCore::CSSPrimitiveValue::operator OutlineIsAuto const):
+        (WebCore::CSSPrimitiveValue::operator BackfaceVisibility const):
+        (WebCore::CSSPrimitiveValue::operator FillAttachment const):
+        (WebCore::CSSPrimitiveValue::operator FillBox const):
+        (WebCore::CSSPrimitiveValue::operator FillRepeat const):
+        (WebCore::CSSPrimitiveValue::operator BoxPack const):
+        (WebCore::CSSPrimitiveValue::operator BoxAlignment const):
+        (WebCore::CSSPrimitiveValue::operator BoxDecorationBreak const):
+        (WebCore::CSSPrimitiveValue::operator BoxSizing const):
+        (WebCore::CSSPrimitiveValue::operator BoxDirection const):
+        (WebCore::CSSPrimitiveValue::operator BoxLines const):
+        (WebCore::CSSPrimitiveValue::operator BoxOrient const):
+        (WebCore::CSSPrimitiveValue::operator Clear const):
+        (WebCore::CSSPrimitiveValue::operator FlexDirection const):
+        (WebCore::CSSPrimitiveValue::operator AlignContent const):
+        (WebCore::CSSPrimitiveValue::operator FlexWrap const):
+        (WebCore::CSSPrimitiveValue::operator Float const):
+        (WebCore::CSSPrimitiveValue::operator LineBreak const):
+        (WebCore::CSSPrimitiveValue::operator MarginCollapse const):
+        (WebCore::CSSPrimitiveValue::operator NBSPMode const):
+        (WebCore::CSSPrimitiveValue::operator Overflow const):
+        (WebCore::CSSPrimitiveValue::operator PositionType const):
+        (WebCore::CSSPrimitiveValue::operator Resize const):
+        (WebCore::CSSPrimitiveValue::operator TableLayoutType const):
+        (WebCore::CSSPrimitiveValue::operator TextSecurity const):
+        (WebCore::CSSPrimitiveValue::operator UserDrag const):
+        (WebCore::CSSPrimitiveValue::operator UserModify const):
+        (WebCore::CSSPrimitiveValue::operator UserSelect const):
+        (WebCore::CSSPrimitiveValue::operator VerticalAlign const):
+        (WebCore::CSSPrimitiveValue::operator WordBreak const):
+        (WebCore::CSSPrimitiveValue::operator OverflowWrap const):
+        (WebCore::CSSPrimitiveValue::operator TextCombine const):
+        (WebCore::CSSPrimitiveValue::operator TextOverflow const):
+        (WebCore::CSSPrimitiveValue::operator ObjectFit const):
+        (WebCore::CSSPrimitiveValue::operator Isolation const):
+        (WebCore::CSSPrimitiveValue::operator BorderCollapse const):
+        (WebCore::CSSPrimitiveValue::operator ImageRendering const):
+        (WebCore::CSSPrimitiveValue::operator TransformStyle3D const):
+        (WebCore::CSSPrimitiveValue::operator ItemPosition const):
+        (WebCore::CSSPrimitiveValue::operator OverflowAlignment const):
+        (WebCore::CSSPrimitiveValue::operator ContentPosition const):
+        (WebCore::CSSPrimitiveValue::operator ContentDistribution const):
+        (WebCore::CSSPrimitiveValue::operator EBorderStyle const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBackfaceVisibility const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EFillAttachment const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EFillBox const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EFillRepeat const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBoxPack const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBoxAlignment const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBoxDecorationBreak const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBoxSizing const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBoxDirection const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBoxLines const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBoxOrient const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EClear const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EFlexDirection const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EAlignContent const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EFlexWrap const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EFloat const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EMarginCollapse const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator ENBSPMode const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EOverflow const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EPosition const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EResize const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator ETableLayout const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator ETextSecurity const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EUserDrag const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EUserModify const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EUserSelect const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EVerticalAlign const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EWordBreak const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EOverflowWrap const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EBorderCollapse const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator EImageRendering const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator ETransformStyle3D const): Deleted.
+        (WebCore::CSSPrimitiveValue::operator ContentDistributionType const): Deleted.
+        * css/CSSProperties.json:
+        * css/CSSToStyleMap.cpp:
+        (WebCore::CSSToStyleMap::mapFillAttachment):
+        (WebCore::CSSToStyleMap::mapFillSize):
+        (WebCore::CSSToStyleMap::mapFillMaskSourceType):
+        * css/CSSValueKeywords.in:
+        * css/StyleBuilderConverter.h:
+        (WebCore::StyleBuilderConverter::convertResize):
+        (WebCore::StyleBuilderConverter::convertSelfOrDefaultAlignmentData):
+        * css/StyleBuilderCustom.h:
+        (WebCore::StyleBuilderCustom::applyValueTextIndent):
+        (WebCore::StyleBuilderCustom::applyInheritWebkitAspectRatio):
+        (WebCore::StyleBuilderCustom::applyValueWebkitAspectRatio):
+        (WebCore::StyleBuilderCustom::applyValueContent):
+        * css/StyleResolver.cpp:
+        (WebCore::isScrollableOverflow):
+        (WebCore::StyleResolver::adjustRenderStyle):
+        * css/StyleResolver.h:
+        * css/makeprop.pl:
+        (getFillLayerType):
+        * dom/Element.h:
+        * dom/Node.cpp:
+        (WebCore::computeEditabilityFromComputedStyle):
+        (WebCore::Node::canStartSelection const):
+        * dom/Position.cpp:
+        (WebCore::Position::nodeIsUserSelectNone):
+        (WebCore::Position::nodeIsUserSelectAll):
+        * dom/Range.cpp:
+        (WebCore::Range::collectSelectionRectsWithoutUnionInteriorLines const):
+        * editing/ApplyBlockElementCommand.cpp:
+        (WebCore::ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded):
+        * editing/DeleteSelectionCommand.cpp:
+        (WebCore::DeleteSelectionCommand::doApply):
+        * editing/Editing.cpp:
+        (WebCore::isSpecialHTMLElement):
+        * editing/EditorCommand.cpp:
+        (WebCore::verticalScrollDistance):
+        * editing/ReplaceSelectionCommand.cpp:
+        (WebCore::ReplaceSelectionCommand::doApply):
+        * editing/SimplifyMarkupCommand.cpp:
+        (WebCore::SimplifyMarkupCommand::doApply):
+        * editing/VisibleUnits.cpp:
+        (WebCore::backwardSearchForBoundaryWithTextIterator):
+        (WebCore::forwardSearchForBoundaryWithTextIterator):
+        * editing/cocoa/EditorCocoa.mm:
+        (WebCore::Editor::fontAttributesForSelectionStart const):
+        * editing/cocoa/HTMLConverter.mm:
+        (WebCore::editingAttributedStringFromRange):
+        * html/HTMLInputElement.cpp:
+        (WebCore::HTMLInputElement::shouldTruncateText const):
+        (WebCore::HTMLInputElement::createInnerTextStyle):
+        * html/HTMLTextFormControlElement.cpp:
+        (WebCore::HTMLTextFormControlElement::adjustInnerTextStyle const):
+        * html/shadow/SliderThumbElement.cpp:
+        (WebCore::RenderSliderContainer::layout):
+        * html/shadow/TextControlInnerElements.cpp:
+        (WebCore::TextControlInnerContainer::resolveCustomStyle):
+        (WebCore::TextControlInnerElement::resolveCustomStyle):
+        (WebCore::TextControlPlaceholderElement::resolveCustomStyle):
+        * layout/displaytree/DisplayBox.cpp:
+        (WebCore::Display::Box::borderBox const):
+        (WebCore::Display::Box::contentBox const):
+        * layout/displaytree/DisplayBox.h:
+        * layout/layouttree/LayoutBox.cpp:
+        (WebCore::Layout::Box::isRelativelyPositioned const):
+        (WebCore::Layout::Box::isStickyPositioned const):
+        (WebCore::Layout::Box::isAbsolutelyPositioned const):
+        (WebCore::Layout::Box::isFixedPositioned const):
+        (WebCore::Layout::Box::isFloatingPositioned const):
+        (WebCore::Layout::Box::isOverflowVisible const):
+        * page/DragController.cpp:
+        (WebCore::DragController::draggableElement const):
+        * page/Frame.cpp:
+        (WebCore::Frame::rangeForPoint):
+        * page/FrameView.cpp:
+        (WebCore::paginationModeForRenderStyle):
+        (WebCore::FrameView::applyOverflowToViewport):
+        (WebCore::FrameView::applyPaginationToViewport):
+        (WebCore::FrameView::calculateScrollbarModesForLayout):
+        (WebCore::FrameView::calculateExtendedBackgroundMode const):
+        (WebCore::FrameView::adjustScrollStepForFixedContent):
+        * page/SpatialNavigation.cpp:
+        (WebCore::canScrollInDirection):
+        (WebCore::canBeScrolledIntoView):
+        * page/ios/FrameIOS.mm:
+        (WebCore::Frame::nodeRespondingToScrollWheelEvents):
+        * page/mac/EventHandlerMac.mm:
+        (WebCore::scrolledToEdgeInDominantDirection):
+        * rendering/BorderEdge.cpp:
+        (WebCore::BorderEdge::BorderEdge):
+        (WebCore::BorderEdge::obscuresBackgroundEdge const):
+        (WebCore::BorderEdge::obscuresBackground const):
+        * rendering/BorderEdge.h:
+        (WebCore::BorderEdge::style const):
+        (WebCore::BorderEdge::hasVisibleColorAndStyle const):
+        * rendering/FlexibleBoxAlgorithm.h:
+        (WebCore::FlexLayoutAlgorithm::isMultiline const):
+        * rendering/FloatingObjects.cpp:
+        (WebCore::FloatingObject::FloatingObject):
+        * rendering/GridTrackSizingAlgorithm.cpp:
+        (WebCore::GridTrackSizingAlgorithmStrategy::minSizeForChild const):
+        (WebCore::GridTrackSizingAlgorithm::stretchAutoTracks):
+        * rendering/HitTestResult.cpp:
+        (WebCore::HitTestResult::innerTextIfTruncated const):
+        * rendering/ImageQualityController.cpp:
+        (WebCore::ImageQualityController::interpolationQualityFromStyle):
+        * rendering/InlineBox.h:
+        (WebCore::InlineBox::verticalAlign const):
+        * rendering/InlineFlowBox.cpp:
+        (WebCore::InlineFlowBox::addToLine):
+        (WebCore::InlineFlowBox::determineSpacingForFlowBoxes):
+        (WebCore::InlineFlowBox::adjustMaxAscentAndDescent):
+        (WebCore::InlineFlowBox::computeLogicalBoxHeights):
+        (WebCore::InlineFlowBox::placeBoxesInBlockDirection):
+        (WebCore::InlineFlowBox::paintFillLayer):
+        * rendering/LogicalSelectionOffsetCaches.h:
+        (WebCore::LogicalSelectionOffsetCaches::containingBlockInfo const):
+        * rendering/RenderBlock.cpp:
+        (WebCore::RenderBlock::removePositionedObjectsIfNeeded):
+        (WebCore::RenderBlock::styleDidChange):
+        (WebCore::RenderBlock::isSelfCollapsingBlock const):
+        (WebCore::RenderBlock::addOverflowFromPositionedObjects):
+        (WebCore::RenderBlock::markFixedPositionObjectForLayoutIfNeeded):
+        (WebCore::RenderBlock::isSelectionRoot const):
+        (WebCore::RenderBlock::selectionGaps):
+        (WebCore::RenderBlock::computeBlockPreferredLogicalWidths const):
+        (WebCore::RenderBlock::adjustBorderBoxLogicalHeightForBoxSizing const):
+        (WebCore::RenderBlock::adjustContentBoxLogicalHeightForBoxSizing const):
+        * rendering/RenderBlockFlow.cpp:
+        (WebCore::RenderBlockFlow::MarginInfo::MarginInfo):
+        (WebCore::RenderBlockFlow::willCreateColumns const):
+        (WebCore::RenderBlockFlow::marginOffsetForSelfCollapsingBlock):
+        (WebCore::RenderBlockFlow::clearFloatsIfNeeded):
+        (WebCore::RenderBlockFlow::marginBeforeEstimateForChild const):
+        (WebCore::RenderBlockFlow::setMustDiscardMarginBefore):
+        (WebCore::RenderBlockFlow::setMustDiscardMarginAfter):
+        (WebCore::RenderBlockFlow::mustDiscardMarginBefore const):
+        (WebCore::RenderBlockFlow::mustDiscardMarginAfter const):
+        (WebCore::RenderBlockFlow::mustDiscardMarginBeforeForChild const):
+        (WebCore::RenderBlockFlow::mustDiscardMarginAfterForChild const):
+        (WebCore::RenderBlockFlow::mustSeparateMarginBeforeForChild const):
+        (WebCore::RenderBlockFlow::mustSeparateMarginAfterForChild const):
+        (WebCore::RenderBlockFlow::styleDidChange):
+        (WebCore::RenderBlockFlow::styleWillChange):
+        (WebCore::RenderBlockFlow::computeLogicalLocationForFloat):
+        (WebCore::RenderBlockFlow::positionNewFloats):
+        (WebCore::RenderBlockFlow::clearFloats):
+        (WebCore::RenderBlockFlow::getClearDelta):
+        (WebCore::RenderBlockFlow::inlineBlockBaseline const):
+        (WebCore::RenderBlockFlow::computeInlinePreferredLogicalWidths const):
+        * rendering/RenderBlockFlow.h:
+        * rendering/RenderBlockLineLayout.cpp:
+        (WebCore::expansionBehaviorForInlineTextBox):
+        (WebCore::isCollapsibleSpace):
+        (WebCore::RenderBlockFlow::layoutRunsAndFloats):
+        (WebCore::RenderBlockFlow::layoutLineBoxes):
+        * rendering/RenderBox.cpp:
+        (WebCore::RenderBox::styleWillChange):
+        (WebCore::RenderBox::styleDidChange):
+        (WebCore::RenderBox::updateFromStyle):
+        (WebCore::RenderBox::includeVerticalScrollbarSize const):
+        (WebCore::RenderBox::includeHorizontalScrollbarSize const):
+        (WebCore::RenderBox::intrinsicScrollbarLogicalWidth const):
+        (WebCore::RenderBox::hasVerticalScrollbarWithAutoBehavior const):
+        (WebCore::RenderBox::hasHorizontalScrollbarWithAutoBehavior const):
+        (WebCore::RenderBox::adjustBorderBoxLogicalWidthForBoxSizing const):
+        (WebCore::RenderBox::adjustBorderBoxLogicalHeightForBoxSizing const):
+        (WebCore::RenderBox::adjustContentBoxLogicalWidthForBoxSizing const):
+        (WebCore::RenderBox::adjustContentBoxLogicalHeightForBoxSizing const):
+        (WebCore::RenderBox::backgroundIsKnownToBeOpaqueInRect const):
+        (WebCore::isCandidateForOpaquenessTest):
+        (WebCore::RenderBox::foregroundIsKnownToBeOpaqueInRect const):
+        (WebCore::RenderBox::backgroundHasOpaqueTopLayer const):
+        (WebCore::RenderBox::computeRectForRepaint const):
+        (WebCore::RenderBox::computeLogicalWidthInFragment const):
+        (WebCore::RenderBox::columnFlexItemHasStretchAlignment const):
+        (WebCore::RenderBox::isStretchingColumnFlexItem const):
+        (WebCore::RenderBox::hasStretchedLogicalWidth const):
+        (WebCore::RenderBox::sizesLogicalWidthToFitContent const):
+        (WebCore::RenderBox::computeLogicalHeight const):
+        (WebCore::RenderBox::computeIntrinsicLogicalContentHeightUsing const):
+        (WebCore::RenderBox::createsNewFormattingContext const):
+        * rendering/RenderBox.h:
+        (WebCore::RenderBox::scrollsOverflowX const):
+        (WebCore::RenderBox::scrollsOverflowY const):
+        (WebCore::RenderBox::selfAlignmentNormalBehavior const):
+        * rendering/RenderBoxModelObject.cpp:
+        (WebCore::RenderBoxModelObject::paintFillLayerExtended):
+        (WebCore::RenderBoxModelObject::calculateFillTileSize const):
+        (WebCore::RenderBoxModelObject::calculateBackgroundImageGeometry const):
+        (WebCore::styleRequiresClipPolygon):
+        (WebCore::borderStyleFillsBorderArea):
+        (WebCore::borderStyleHasInnerDetail):
+        (WebCore::borderStyleIsDottedOrDashed):
+        (WebCore::borderStyleHasUnmatchedColorsAtCorner):
+        (WebCore::borderStylesRequireMitre):
+        (WebCore::RenderBoxModelObject::paintBorder):
+        (WebCore::RenderBoxModelObject::drawBoxSideFromPath):
+        (WebCore::RenderBoxModelObject::boxShadowShouldBeAppliedToBackground const):
+        * rendering/RenderBoxModelObject.h:
+        * rendering/RenderDeprecatedFlexibleBox.cpp:
+        (WebCore::FlexBoxIterator::FlexBoxIterator):
+        (WebCore::RenderDeprecatedFlexibleBox::layoutBlock):
+        (WebCore::RenderDeprecatedFlexibleBox::layoutHorizontalBox):
+        (WebCore::RenderDeprecatedFlexibleBox::layoutVerticalBox):
+        * rendering/RenderDeprecatedFlexibleBox.h:
+        * rendering/RenderElement.cpp:
+        (WebCore::RenderElement::adjustStyleDifference const):
+        (WebCore::RenderElement::shouldRepaintForStyleDifference const):
+        (WebCore::RenderElement::initializeStyle):
+        (WebCore::RenderElement::setStyle):
+        (WebCore::RenderElement::didAttachChild):
+        (WebCore::RenderElement::propagateStyleToAnonymousChildren):
+        (WebCore::RenderElement::styleWillChange):
+        (WebCore::RenderElement::styleDidChange):
+        (WebCore::mustRepaintFillLayers):
+        (WebCore::RenderElement::selectionColor const):
+        (WebCore::RenderElement::selectionBackgroundColor const):
+        (WebCore::RenderElement::drawLineForBoxSide const):
+        (WebCore::RenderElement::paintFocusRing):
+        (WebCore::RenderElement::paintOutline):
+        (WebCore::RenderElement::updateOutlineAutoAncestor):
+        (WebCore::includeNonFixedHeight):
+        * rendering/RenderElement.h:
+        (WebCore::RenderElement::hasHiddenBackface const):
+        (WebCore::RenderElement::canContainAbsolutelyPositionedObjects const):
+        * rendering/RenderFlexibleBox.cpp:
+        (WebCore::RenderFlexibleBox::firstLineBaseline const):
+        (WebCore::contentAlignmentNormalBehavior):
+        (WebCore::RenderFlexibleBox::styleDidChange):
+        (WebCore::RenderFlexibleBox::repositionLogicalHeightDependentFlexItems):
+        (WebCore::RenderFlexibleBox::isLeftToRightFlow const):
+        (WebCore::RenderFlexibleBox::isMultiline const):
+        (WebCore::RenderFlexibleBox::adjustChildSizeForMinAndMax):
+        (WebCore::RenderFlexibleBox::crossSizeForPercentageResolution):
+        (WebCore::initialJustifyContentOffset):
+        (WebCore::justifyContentSpaceBetweenChildren):
+        (WebCore::alignmentOffset):
+        (WebCore::RenderFlexibleBox::staticMainAxisPositionForPositionedChild):
+        (WebCore::RenderFlexibleBox::staticCrossAxisPositionForPositionedChild):
+        (WebCore::RenderFlexibleBox::alignmentForChild const):
+        (WebCore::RenderFlexibleBox::needToStretchChildLogicalHeight const):
+        (WebCore::RenderFlexibleBox::mainAxisOverflowForChild const):
+        (WebCore::RenderFlexibleBox::crossAxisOverflowForChild const):
+        (WebCore::RenderFlexibleBox::layoutAndPlaceChildren):
+        (WebCore::RenderFlexibleBox::layoutColumnReverse):
+        (WebCore::initialAlignContentOffset):
+        (WebCore::alignContentSpaceBetweenChildren):
+        (WebCore::RenderFlexibleBox::alignFlexLines):
+        (WebCore::RenderFlexibleBox::alignChildren):
+        * rendering/RenderFlexibleBox.h:
+        * rendering/RenderFragmentContainer.cpp:
+        (WebCore::RenderFragmentContainer::overflowRectForFragmentedFlowPortion):
+        * rendering/RenderFullScreen.cpp:
+        (WebCore::createFullScreenStyle):
+        * rendering/RenderFullScreen.h:
+        * rendering/RenderGrid.cpp:
+        (WebCore::RenderGrid::selfAlignmentChangedToStretch const):
+        (WebCore::RenderGrid::selfAlignmentChangedFromStretch const):
+        (WebCore::RenderGrid::styleDidChange):
+        (WebCore::contentAlignmentNormalBehaviorGrid):
+        (WebCore::computeOverflowAlignmentOffset):
+        (WebCore::RenderGrid::isInlineBaselineAlignedChild const):
+        (WebCore::RenderGrid::columnAxisPositionForChild const):
+        (WebCore::RenderGrid::rowAxisPositionForChild const):
+        (WebCore::RenderGrid::resolveAutoStartGridPosition const):
+        (WebCore::RenderGrid::resolveAutoEndGridPosition const):
+        (WebCore::resolveContentDistributionFallback):
+        (WebCore::contentDistributionOffset):
+        (WebCore::RenderGrid::computeContentPositionAndDistributionOffset const):
+        * rendering/RenderGrid.h:
+        * rendering/RenderIFrame.cpp:
+        (WebCore::RenderIFrame::requiresLayer const):
+        * rendering/RenderImage.cpp:
+        (WebCore::RenderImage::styleDidChange):
+        (WebCore::RenderImage::foregroundIsKnownToBeOpaqueInRect const):
+        * rendering/RenderInline.cpp:
+        (WebCore::RenderInline::styleWillChange):
+        (WebCore::RenderInline::updateAlwaysCreateLineBoxes):
+        (WebCore::RenderInline::paintOutline):
+        (WebCore::RenderInline::paintOutlineForLine):
+        * rendering/RenderLayer.cpp:
+        (WebCore::isContainerForPositioned):
+        (WebCore::RenderLayer::enclosingAncestorForPosition const):
+        (WebCore::accumulateOffsetTowardsAncestor):
+        (WebCore::RenderLayer::canResize const):
+        (WebCore::RenderLayer::resize):
+        (WebCore::RenderLayer::scrollCornerRect const):
+        (WebCore::resizerCornerRect):
+        (WebCore::RenderLayer::hasOverflowControls const):
+        (WebCore::styleRequiresScrollbar):
+        (WebCore::styleDefinesAutomaticScrollbar):
+        (WebCore::RenderLayer::updateScrollbarsAfterLayout):
+        (WebCore::RenderLayer::paintResizer):
+        (WebCore::RenderLayer::hitTestOverflowControls):
+        (WebCore::RenderLayer::hitTestLayer):
+        (WebCore::RenderLayer::calculateClipRects const):
+        * rendering/RenderLayer.h:
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::updateGeometry):
+        (WebCore::canDirectlyCompositeBackgroundBackgroundImage):
+        (WebCore::RenderLayerBacking::isSimpleContainerCompositingLayer const):
+        (WebCore::backgroundRectForBox):
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::isScrollableOverflow):
+        (WebCore::styleChangeRequiresLayerRebuild):
+        (WebCore::RenderLayerCompositor::layerStyleChanged):
+        (WebCore::RenderLayerCompositor::reasonsForCompositing const):
+        (WebCore::RenderLayerCompositor::requiresCompositingForBackfaceVisibility const):
+        (WebCore::RenderLayerCompositor::requiresCompositingForIndirectReason const):
+        (WebCore::RenderLayerCompositor::isViewportConstrainedFixedOrStickyLayer const):
+        (WebCore::RenderLayerCompositor::requiresCompositingForPosition const):
+        (WebCore::RenderLayerCompositor::layerHas3DContent const):
+        (WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):
+        * rendering/RenderLayerModelObject.cpp:
+        (WebCore::RenderLayerModelObject::styleWillChange):
+        * rendering/RenderMenuList.cpp:
+        (WebCore::RenderMenuList::adjustInnerStyle):
+        * rendering/RenderMultiColumnFlow.cpp:
+        (WebCore::RenderMultiColumnFlow::isColumnSpanningDescendant const):
+        * rendering/RenderMultiColumnSet.cpp:
+        (WebCore::RenderMultiColumnSet::requiresBalancing const):
+        (WebCore::RenderMultiColumnSet::paintColumnRules):
+        * rendering/RenderMultiColumnSpannerPlaceholder.cpp:
+        (WebCore::RenderMultiColumnSpannerPlaceholder::createAnonymous):
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::propagateRepaintToParentWithOutlineAutoIfNeeded const):
+        (WebCore::containerForElement):
+        (WebCore::RenderObject::calculateBorderStyleColor):
+        * rendering/RenderObject.h:
+        (WebCore::RenderObject::isFixedPositioned const):
+        (WebCore::RenderObject::isAbsolutelyPositioned const):
+        (WebCore::RenderObject::setPositionState):
+        (WebCore::RenderObject::RenderObjectBitfields::setPositionedState):
+        (WebCore::RenderObject::RenderObjectBitfields::clearPositionedState):
+        * rendering/RenderQuote.cpp:
+        (WebCore::RenderQuote::styleDidChange):
+        (WebCore::RenderQuote::computeText const):
+        (WebCore::RenderQuote::isOpen const):
+        * rendering/RenderReplaced.cpp:
+        (WebCore::RenderReplaced::layout):
+        (WebCore::RenderReplaced::setNeedsLayoutIfNeededAfterIntrinsicSizeChange):
+        (WebCore::RenderReplaced::replacedContentRect const):
+        * rendering/RenderScrollbarPart.cpp:
+        (WebCore::RenderScrollbarPart::styleDidChange):
+        * rendering/RenderTable.cpp:
+        (WebCore::RenderTable::styleDidChange):
+        (WebCore::RenderTable::convertStyleLogicalWidthToComputedWidth):
+        (WebCore::RenderTable::convertStyleLogicalHeightToComputedHeight):
+        (WebCore::RenderTable::calcBorderStart const):
+        (WebCore::RenderTable::calcBorderEnd const):
+        (WebCore::RenderTable::outerBorderBefore const):
+        (WebCore::RenderTable::outerBorderAfter const):
+        (WebCore::RenderTable::outerBorderStart const):
+        (WebCore::RenderTable::outerBorderEnd const):
+        * rendering/RenderTable.h:
+        (WebCore::RenderTable::collapseBorders const):
+        * rendering/RenderTableCell.cpp:
+        (WebCore::RenderTableCell::computeIntrinsicPadding):
+        (WebCore::RenderTableCell::styleDidChange):
+        (WebCore::compareBorders):
+        (WebCore::chooseBorder):
+        (WebCore::emptyBorder):
+        (WebCore::RenderTableCell::computeCollapsedStartBorder const):
+        (WebCore::RenderTableCell::computeCollapsedEndBorder const):
+        (WebCore::RenderTableCell::computeCollapsedBeforeBorder const):
+        (WebCore::RenderTableCell::computeCollapsedAfterBorder const):
+        (WebCore::CollapsedBorders::addBorder):
+        (WebCore::RenderTableCell::paintCollapsedBorders):
+        (WebCore::RenderTableCell::scrollbarsChanged):
+        * rendering/RenderTableCell.h:
+        (WebCore::RenderTableCell::logicalHeightForRowSizing const):
+        (WebCore::RenderTableCell::isBaselineAligned const):
+        * rendering/RenderTableRow.cpp:
+        (WebCore::RenderTableRow::styleDidChange):
+        * rendering/RenderTableSection.cpp:
+        (WebCore::RenderTableSection::calcOuterBorderBefore const):
+        (WebCore::RenderTableSection::calcOuterBorderAfter const):
+        (WebCore::RenderTableSection::calcOuterBorderStart const):
+        (WebCore::RenderTableSection::calcOuterBorderEnd const):
+        (WebCore::RenderTableSection::paintRowGroupBorder):
+        (WebCore::RenderTableSection::paintRowGroupBorderIfRequired):
+        (WebCore::RenderTableSection::cachedCollapsedBorder):
+        * rendering/RenderTableSection.h:
+        * rendering/RenderText.cpp:
+        (WebCore::RenderText::styleDidChange):
+        (WebCore::RenderText::absoluteQuadsClippedToEllipsis const):
+        (WebCore::isSpaceAccordingToStyle):
+        (WebCore::mapLineBreakToIteratorMode):
+        (WebCore::RenderText::computePreferredLogicalWidths):
+        (WebCore::RenderText::setRenderedText):
+        (WebCore::RenderText::textWithoutConvertingBackslashToYenSymbol const):
+        (WebCore::RenderText::momentarilyRevealLastTypedCharacter):
+        * rendering/RenderTextControl.cpp:
+        (WebCore::RenderTextControl::computeLogicalHeight const):
+        * rendering/RenderTextControlSingleLine.cpp:
+        (WebCore::RenderTextControlSingleLine::styleDidChange):
+        * rendering/RenderTheme.cpp:
+        (WebCore::RenderTheme::extractControlStatesForRenderer const):
+        * rendering/RenderThemeIOS.mm:
+        (WebCore::adjustInputElementButtonStyle):
+        * rendering/RenderThemeMac.mm:
+        (WebCore::RenderThemeMac::updateFocusedState):
+        (WebCore::RenderThemeMac::paintCellAndSetFocusedElementNeedsRepaintIfNecessary):
+        (WebCore::RenderThemeMac::adjustSearchFieldStyle const):
+        * rendering/RenderTreeAsText.cpp:
+        (WebCore::printBorderStyle):
+        * rendering/RenderVideo.cpp:
+        (WebCore::RenderVideo::updatePlayer):
+        * rendering/RenderView.cpp:
+        (WebCore::RenderView::RenderView):
+        (WebCore::rendererObscuresBackground):
+        * rendering/RootInlineBox.cpp:
+        (WebCore::RootInlineBox::verticalPositionForBox):
+        * rendering/SimpleLineLayout.cpp:
+        (WebCore::SimpleLineLayout::canUseForStyle):
+        (WebCore::SimpleLineLayout::canUseForWithReason):
+        * rendering/SimpleLineLayoutTextFragmentIterator.cpp:
+        (WebCore::SimpleLineLayout::TextFragmentIterator::Style::Style):
+        * rendering/TextPaintStyle.cpp:
+        (WebCore::computeTextPaintStyle):
+        * rendering/line/BreakingContext.h:
+        (WebCore::BreakingContext::handleBR):
+        (WebCore::shouldAddBorderPaddingMargin):
+        (WebCore::BreakingContext::handleText):
+        (WebCore::BreakingContext::optimalLineBreakLocationForTrailingWord):
+        * rendering/line/LineBreaker.cpp:
+        (WebCore::LineBreaker::reset):
+        * rendering/line/LineBreaker.h:
+        (WebCore::LineBreaker::clear):
+        * rendering/line/LineInlineHeaders.h:
+        (WebCore::skipNonBreakingSpace):
+        * rendering/line/LineWidth.cpp:
+        (WebCore::requiresIndent):
+        * rendering/style/BorderData.h:
+        (WebCore::BorderData::borderLeftWidth const):
+        (WebCore::BorderData::borderRightWidth const):
+        (WebCore::BorderData::borderTopWidth const):
+        (WebCore::BorderData::borderBottomWidth const):
+        * rendering/style/BorderValue.h:
+        (WebCore::BorderValue::BorderValue):
+        (WebCore::BorderValue::nonZero const):
+        (WebCore::BorderValue::isVisible const):
+        (WebCore::BorderValue::style const):
+        * rendering/style/CollapsedBorderValue.h:
+        (WebCore::CollapsedBorderValue::CollapsedBorderValue):
+        (WebCore::CollapsedBorderValue::width const):
+        (WebCore::CollapsedBorderValue::style const):
+        (WebCore::CollapsedBorderValue::exists const):
+        (WebCore::CollapsedBorderValue::precedence const):
+        * rendering/style/FillLayer.cpp:
+        (WebCore::FillLayer::FillLayer):
+        (WebCore::clipMax):
+        (WebCore::FillLayer::computeClipMax const):
+        (WebCore::FillLayer::hasRepeatXY const):
+        (WebCore::FillLayer::hasFixedImage const):
+        * rendering/style/FillLayer.h:
+        (WebCore::FillSize::FillSize):
+        (WebCore::FillLayer::attachment const):
+        (WebCore::FillLayer::clip const):
+        (WebCore::FillLayer::origin const):
+        (WebCore::FillLayer::repeatX const):
+        (WebCore::FillLayer::repeatY const):
+        (WebCore::FillLayer::sizeType const):
+        (WebCore::FillLayer::size const):
+        (WebCore::FillLayer::maskSourceType const):
+        (WebCore::FillLayer::isSizeSet const):
+        (WebCore::FillLayer::setAttachment):
+        (WebCore::FillLayer::setClip):
+        (WebCore::FillLayer::setOrigin):
+        (WebCore::FillLayer::setRepeatX):
+        (WebCore::FillLayer::setRepeatY):
+        (WebCore::FillLayer::setComposite):
+        (WebCore::FillLayer::setBlendMode):
+        (WebCore::FillLayer::setSizeType):
+        (WebCore::FillLayer::setSize):
+        (WebCore::FillLayer::setMaskSourceType):
+        (WebCore::FillLayer::clearSize):
+        (WebCore::FillLayer::type const):
+        (WebCore::FillLayer::initialFillAttachment):
+        (WebCore::FillLayer::initialFillClip):
+        (WebCore::FillLayer::initialFillOrigin):
+        (WebCore::FillLayer::initialFillRepeatX):
+        (WebCore::FillLayer::initialFillRepeatY):
+        (WebCore::FillLayer::initialFillComposite):
+        (WebCore::FillLayer::initialFillBlendMode):
+        (WebCore::FillLayer::initialFillSize):
+        (WebCore::FillLayer::initialFillXPosition):
+        (WebCore::FillLayer::initialFillYPosition):
+        (WebCore::FillLayer::initialFillImage):
+        (WebCore::FillLayer::initialFillMaskSourceType):
+        * rendering/style/LineClampValue.h:
+        (WebCore::LineClampValue::LineClampValue):
+        (WebCore::LineClampValue::isPercentage const):
+        * rendering/style/RenderStyle.cpp:
+        (WebCore::RenderStyle::RenderStyle):
+        (WebCore::resolvedSelfAlignment):
+        (WebCore::RenderStyle::resolvedAlignSelf const):
+        (WebCore::RenderStyle::resolvedJustifySelf const):
+        (WebCore::resolvedContentAlignment):
+        (WebCore::resolvedContentAlignmentPosition):
+        (WebCore::resolvedContentAlignmentDistribution):
+        (WebCore::RenderStyle::resolvedJustifyContentDistribution const):
+        (WebCore::RenderStyle::resolvedAlignContentDistribution const):
+        (WebCore::RenderStyle::changeRequiresLayout const):
+        (WebCore::RenderStyle::changeRequiresPositionedLayoutOnly const):
+        (WebCore::RenderStyle::changeRequiresLayerRepaint const):
+        (WebCore::RenderStyle::changeRequiresRepaint const):
+        (WebCore::RenderStyle::changeRequiresRepaintIfTextOrBorderOrOutline const):
+        (WebCore::RenderStyle::changeRequiresRecompositeLayer const):
+        (WebCore::RenderStyle::diff const):
+        (WebCore::RenderStyle::diffRequiresLayerRepaint const):
+        (WebCore::allLayersAreFixed):
+        (WebCore::RenderStyle::colorIncludingFallback const):
+        (WebCore::RenderStyle::setColumnStylesFromPaginationMode):
+        (WebCore::RenderStyle::outlineWidth const):
+        (WebCore::RenderStyle::outlineOffset const):
+        * rendering/style/RenderStyle.h:
+        (WebCore::RenderStyle::isFloating const):
+        (WebCore::RenderStyle::position const):
+        (WebCore::RenderStyle::hasOutOfFlowPosition const):
+        (WebCore::RenderStyle::hasInFlowPosition const):
+        (WebCore::RenderStyle::hasViewportConstrainedPosition const):
+        (WebCore::RenderStyle::floating const):
+        (WebCore::RenderStyle::borderLeftStyle const):
+        (WebCore::RenderStyle::borderRightStyle const):
+        (WebCore::RenderStyle::borderTopStyle const):
+        (WebCore::RenderStyle::borderBottomStyle const):
+        (WebCore::RenderStyle::hasOutline const):
+        (WebCore::RenderStyle::outlineStyle const):
+        (WebCore::RenderStyle::overflowX const):
+        (WebCore::RenderStyle::overflowY const):
+        (WebCore::RenderStyle::overflowInlineDirection const):
+        (WebCore::RenderStyle::overflowBlockDirection const):
+        (WebCore::RenderStyle::verticalAlign const):
+        (WebCore::RenderStyle::clear const):
+        (WebCore::RenderStyle::tableLayout const):
+        (WebCore::RenderStyle::backgroundRepeatX const):
+        (WebCore::RenderStyle::backgroundRepeatY const):
+        (WebCore::RenderStyle::backgroundAttachment const):
+        (WebCore::RenderStyle::backgroundClip const):
+        (WebCore::RenderStyle::backgroundOrigin const):
+        (WebCore::RenderStyle::backgroundSizeType const):
+        (WebCore::RenderStyle::maskRepeatX const):
+        (WebCore::RenderStyle::maskRepeatY const):
+        (WebCore::RenderStyle::maskClip const):
+        (WebCore::RenderStyle::maskOrigin const):
+        (WebCore::RenderStyle::maskSizeType const):
+        (WebCore::RenderStyle::borderCollapse const):
+        (WebCore::RenderStyle::boxAlign const):
+        (WebCore::RenderStyle::boxDirection const):
+        (WebCore::RenderStyle::boxLines const):
+        (WebCore::RenderStyle::boxOrient const):
+        (WebCore::RenderStyle::boxPack const):
+        (WebCore::RenderStyle::flexDirection const):
+        (WebCore::RenderStyle::isColumnFlexDirection const):
+        (WebCore::RenderStyle::isReverseFlexDirection const):
+        (WebCore::RenderStyle::flexWrap const):
+        (WebCore::RenderStyle::boxDecorationBreak const):
+        (WebCore::RenderStyle::boxSizing const):
+        (WebCore::RenderStyle::userModify const):
+        (WebCore::RenderStyle::userDrag const):
+        (WebCore::RenderStyle::userSelect const):
+        (WebCore::RenderStyle::marginBeforeCollapse const):
+        (WebCore::RenderStyle::marginAfterCollapse const):
+        (WebCore::RenderStyle::wordBreak const):
+        (WebCore::RenderStyle::overflowWrap const):
+        (WebCore::RenderStyle::nbspMode const):
+        (WebCore::RenderStyle::resize const):
+        (WebCore::RenderStyle::columnRuleStyle const):
+        (WebCore::RenderStyle::hasTextCombine const):
+        (WebCore::RenderStyle::transformStyle3D const):
+        (WebCore::RenderStyle::preserves3D const):
+        (WebCore::RenderStyle::backfaceVisibility const):
+        (WebCore::RenderStyle::textSecurity const):
+        (WebCore::RenderStyle::imageRendering const):
+        (WebCore::RenderStyle::setIsolation):
+        (WebCore::RenderStyle::hasIsolation const):
+        (WebCore::RenderStyle::isolation const):
+        (WebCore::RenderStyle::setPosition):
+        (WebCore::RenderStyle::setFloating):
+        (WebCore::RenderStyle::setBackgroundSize):
+        (WebCore::RenderStyle::setBorderLeftStyle):
+        (WebCore::RenderStyle::setBorderRightStyle):
+        (WebCore::RenderStyle::setBorderTopStyle):
+        (WebCore::RenderStyle::setBorderBottomStyle):
+        (WebCore::RenderStyle::setOutlineStyleIsAuto):
+        (WebCore::RenderStyle::setOutlineStyle):
+        (WebCore::RenderStyle::setOverflowX):
+        (WebCore::RenderStyle::setOverflowY):
+        (WebCore::RenderStyle::setVerticalAlign):
+        (WebCore::RenderStyle::setVerticalAlignLength):
+        (WebCore::RenderStyle::setClear):
+        (WebCore::RenderStyle::setTableLayout):
+        (WebCore::RenderStyle::setImageRendering):
+        (WebCore::RenderStyle::clearBackgroundLayers):
+        (WebCore::RenderStyle::clearMaskLayers):
+        (WebCore::RenderStyle::setBorderCollapse):
+        (WebCore::RenderStyle::setAspectRatioType):
+        (WebCore::RenderStyle::setPrintColorAdjust):
+        (WebCore::RenderStyle::setBoxAlign):
+        (WebCore::RenderStyle::setBoxDirection):
+        (WebCore::RenderStyle::setBoxLines):
+        (WebCore::RenderStyle::setBoxOrient):
+        (WebCore::RenderStyle::setBoxPack):
+        (WebCore::RenderStyle::setBoxSizing):
+        (WebCore::RenderStyle::setFlexDirection):
+        (WebCore::RenderStyle::setFlexWrap):
+        (WebCore::RenderStyle::setBoxDecorationBreak):
+        (WebCore::RenderStyle::setUserModify):
+        (WebCore::RenderStyle::setUserDrag):
+        (WebCore::RenderStyle::setUserSelect):
+        (WebCore::RenderStyle::setTextOverflow):
+        (WebCore::RenderStyle::setMarginBeforeCollapse):
+        (WebCore::RenderStyle::setMarginAfterCollapse):
+        (WebCore::RenderStyle::setWordBreak):
+        (WebCore::RenderStyle::setOverflowWrap):
+        (WebCore::RenderStyle::setNBSPMode):
+        (WebCore::RenderStyle::setLineBreak):
+        (WebCore::RenderStyle::setResize):
+        (WebCore::RenderStyle::setColumnFill):
+        (WebCore::RenderStyle::setColumnRuleStyle):
+        (WebCore::RenderStyle::setColumnSpan):
+        (WebCore::RenderStyle::setTextCombine):
+        (WebCore::RenderStyle::setObjectFit):
+        (WebCore::RenderStyle::setTransformStyle3D):
+        (WebCore::RenderStyle::setBackfaceVisibility):
+        (WebCore::RenderStyle::setTextSecurity):
+        (WebCore::RenderStyle::initialOverflowX):
+        (WebCore::RenderStyle::initialOverflowY):
+        (WebCore::RenderStyle::initialClear):
+        (WebCore::RenderStyle::initialPosition):
+        (WebCore::RenderStyle::initialVerticalAlign):
+        (WebCore::RenderStyle::initialFloating):
+        (WebCore::RenderStyle::initialTableLayout):
+        (WebCore::RenderStyle::initialBorderCollapse):
+        (WebCore::RenderStyle::initialBorderStyle):
+        (WebCore::RenderStyle::initialOutlineStyleIsAuto):
+        (WebCore::RenderStyle::initialTextCombine):
+        (WebCore::RenderStyle::initialObjectFit):
+        (WebCore::RenderStyle::initialBoxAlign):
+        (WebCore::RenderStyle::initialBoxDecorationBreak):
+        (WebCore::RenderStyle::initialBoxDirection):
+        (WebCore::RenderStyle::initialBoxLines):
+        (WebCore::RenderStyle::initialBoxOrient):
+        (WebCore::RenderStyle::initialBoxPack):
+        (WebCore::RenderStyle::initialBoxSizing):
+        (WebCore::RenderStyle::initialJustifyItems):
+        (WebCore::RenderStyle::initialSelfAlignment):
+        (WebCore::RenderStyle::initialDefaultAlignment):
+        (WebCore::RenderStyle::initialContentAlignment):
+        (WebCore::RenderStyle::initialFlexDirection):
+        (WebCore::RenderStyle::initialFlexWrap):
+        (WebCore::RenderStyle::initialUserModify):
+        (WebCore::RenderStyle::initialUserDrag):
+        (WebCore::RenderStyle::initialUserSelect):
+        (WebCore::RenderStyle::initialTextOverflow):
+        (WebCore::RenderStyle::initialMarginBeforeCollapse):
+        (WebCore::RenderStyle::initialMarginAfterCollapse):
+        (WebCore::RenderStyle::initialWordBreak):
+        (WebCore::RenderStyle::initialOverflowWrap):
+        (WebCore::RenderStyle::initialNBSPMode):
+        (WebCore::RenderStyle::initialLineBreak):
+        (WebCore::RenderStyle::initialResize):
+        (WebCore::RenderStyle::initialAspectRatioType):
+        (WebCore::RenderStyle::initialColumnFill):
+        (WebCore::RenderStyle::initialColumnSpan):
+        (WebCore::RenderStyle::initialTransformStyle3D):
+        (WebCore::RenderStyle::initialBackfaceVisibility):
+        (WebCore::RenderStyle::initialImageRendering):
+        (WebCore::RenderStyle::initialPrintColorAdjust):
+        (WebCore::RenderStyle::initialTextIndentLine):
+        (WebCore::RenderStyle::initialTextIndentType):
+        (WebCore::RenderStyle::initialTextSecurity):
+        (WebCore::RenderStyle::initialIsolation):
+        (WebCore::collapsedBorderStyle):
+        (WebCore::RenderStyle::breakOnlyAfterWhiteSpace const):
+        (WebCore::RenderStyle::breakWords const):
+        (WebCore::RenderStyle::setTextOrientation):
+        * rendering/style/RenderStyleConstants.cpp:
+        (WebCore::operator<<):
+        * rendering/style/RenderStyleConstants.h:
+        (WebCore::operator|):
+        (WebCore::operator|=):
+        (WebCore::operator| ): Deleted.
+        (WebCore::operator|= ): Deleted.
+        * rendering/style/SVGRenderStyle.cpp:
+        (WebCore::SVGRenderStyle::diff const):
+        * rendering/style/StyleBackgroundData.cpp:
+        (WebCore::StyleBackgroundData::StyleBackgroundData):
+        * rendering/style/StyleBoxData.cpp:
+        (WebCore::StyleBoxData::StyleBoxData):
+        * rendering/style/StyleBoxData.h:
+        (WebCore::StyleBoxData::boxSizing const):
+        (WebCore::StyleBoxData::boxDecorationBreak const):
+        * rendering/style/StyleContentAlignmentData.h:
+        (WebCore::StyleContentAlignmentData::StyleContentAlignmentData):
+        (WebCore::StyleContentAlignmentData::setPosition):
+        (WebCore::StyleContentAlignmentData::setDistribution):
+        (WebCore::StyleContentAlignmentData::setOverflow):
+        (WebCore::StyleContentAlignmentData::distribution const):
+        * rendering/style/StyleDeprecatedFlexibleBoxData.cpp:
+        (WebCore::StyleDeprecatedFlexibleBoxData::StyleDeprecatedFlexibleBoxData):
+        * rendering/style/StyleDeprecatedFlexibleBoxData.h:
+        * rendering/style/StyleFlexibleBoxData.cpp:
+        (WebCore::StyleFlexibleBoxData::StyleFlexibleBoxData):
+        * rendering/style/StyleFlexibleBoxData.h:
+        * rendering/style/StyleMultiColData.cpp:
+        (WebCore::StyleMultiColData::StyleMultiColData):
+        * rendering/style/StyleMultiColData.h:
+        (WebCore::StyleMultiColData::ruleWidth const):
+        * rendering/style/StyleRareInheritedData.cpp:
+        (WebCore::StyleRareInheritedData::StyleRareInheritedData):
+        * rendering/style/StyleRareInheritedData.h:
+        * rendering/style/StyleRareNonInheritedData.cpp:
+        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
+        * rendering/style/StyleRareNonInheritedData.h:
+        * rendering/style/StyleSelfAlignmentData.h:
+        (WebCore::StyleSelfAlignmentData::StyleSelfAlignmentData):
+        (WebCore::StyleSelfAlignmentData::setPosition):
+        (WebCore::StyleSelfAlignmentData::setPositionType):
+        (WebCore::StyleSelfAlignmentData::setOverflow):
+        * rendering/svg/RenderSVGBlock.cpp:
+        (WebCore::RenderSVGBlock::styleDidChange):
+        * rendering/svg/RenderSVGGradientStop.cpp:
+        (WebCore::RenderSVGGradientStop::styleDidChange):
+        * rendering/svg/RenderSVGInline.cpp:
+        (WebCore::RenderSVGInline::styleDidChange):
+        * rendering/svg/RenderSVGInlineText.cpp:
+        (WebCore::RenderSVGInlineText::styleDidChange):
+        * rendering/svg/RenderSVGModelObject.cpp:
+        (WebCore::RenderSVGModelObject::styleDidChange):
+        * rendering/svg/RenderSVGResourceContainer.cpp:
+        (WebCore::RenderSVGResourceContainer::registerResource):
+        * rendering/svg/RenderSVGResourceFilterPrimitive.cpp:
+        (WebCore::RenderSVGResourceFilterPrimitive::styleDidChange):
+        * rendering/svg/RenderSVGRoot.cpp:
+        (WebCore::RenderSVGRoot::layout):
+        (WebCore::RenderSVGRoot::shouldApplyViewportClip const):
+        (WebCore::RenderSVGRoot::styleDidChange):
+        * rendering/svg/SVGInlineTextBox.cpp:
+        (WebCore::SVGInlineTextBox::paintText):
+        * rendering/svg/SVGRenderSupport.cpp:
+        (WebCore::SVGRenderSupport::isOverflowHidden):
+        * rendering/svg/SVGResourcesCache.cpp:
+        (WebCore::SVGResourcesCache::clientStyleChanged):
+        * rendering/updating/RenderTreeBuilder.cpp:
+        (WebCore::RenderTreeBuilder::attachToRenderElementInternal):
+        * rendering/updating/RenderTreeBuilderBlock.cpp:
+        (WebCore::RenderTreeBuilder::Block::insertChildToContinuation):
+        * rendering/updating/RenderTreeBuilderFirstLetter.cpp:
+        (WebCore::styleForFirstLetter):
+        * rendering/updating/RenderTreeBuilderMultiColumn.cpp:
+        (WebCore::isValidColumnSpanner):
+        (WebCore::RenderTreeBuilder::MultiColumn::resolveMovedChild):
+        (WebCore::RenderTreeBuilder::MultiColumn::multiColumnRelativeWillBeRemoved):
+        * rendering/updating/RenderTreeUpdater.cpp:
+        (WebCore::RenderTreeUpdater::updateElementRenderer):
+        * style/StyleResolveForDocument.cpp:
+        (WebCore::Style::resolveForDocument):
+
 2018-05-21  Alicia Boya García  <aboya@igalia.com>
 
         [MSE][GStreamer] Stream::decodebinSinkPad is read but never assigned
index 75a4171..0e37ea6 100644 (file)
@@ -105,13 +105,13 @@ static AtkAttributeSet* getAttributeSetForAccessibilityObject(const Accessibilit
     int baselinePosition;
     bool includeRise = true;
     switch (style->verticalAlign()) {
-    case SUB:
+    case VerticalAlign::Sub:
         baselinePosition = -1 * baselinePositionForRenderObject(renderer);
         break;
-    case SUPER:
+    case VerticalAlign::Super:
         baselinePosition = baselinePositionForRenderObject(renderer);
         break;
-    case BASELINE:
+    case VerticalAlign::Baseline:
         baselinePosition = 0;
         break;
     default:
index f072af8..5f76544 100644 (file)
@@ -830,10 +830,10 @@ static void AXAttributeStringSetStyle(NSMutableAttributedString* attrString, Ren
     AXAttributeStringSetColor(attrString, NSAccessibilityBackgroundColorTextAttribute, nsColor(style.visitedDependentColor(CSSPropertyBackgroundColor)), range);
     
     // set super/sub scripting
-    EVerticalAlign alignment = style.verticalAlign();
-    if (alignment == SUB)
+    VerticalAlign alignment = style.verticalAlign();
+    if (alignment == VerticalAlign::Sub)
         AXAttributeStringSetNumber(attrString, NSAccessibilitySuperscriptTextAttribute, [NSNumber numberWithInt:(-1)], range);
-    else if (alignment == SUPER)
+    else if (alignment == VerticalAlign::Super)
         AXAttributeStringSetNumber(attrString, NSAccessibilitySuperscriptTextAttribute, [NSNumber numberWithInt:1], range);
     else
         [attrString removeAttribute:NSAccessibilitySuperscriptTextAttribute range:range];
index 5f225f7..15c8560 100644 (file)
 
 namespace WebCore {
 
-static Ref<CSSPrimitiveValue> valueForCenterCoordinate(CSSValuePool& pool, const RenderStyle& style, const BasicShapeCenterCoordinate& center, EBoxOrient orientation)
+static Ref<CSSPrimitiveValue> valueForCenterCoordinate(CSSValuePool& pool, const RenderStyle& style, const BasicShapeCenterCoordinate& center, BoxOrient orientation)
 {
     if (center.direction() == BasicShapeCenterCoordinate::TopLeft)
         return pool.createValue(center.length(), style);
 
-    CSSValueID keyword = orientation == HORIZONTAL ? CSSValueRight : CSSValueBottom;
+    CSSValueID keyword = orientation == BoxOrient::Horizontal ? CSSValueRight : CSSValueBottom;
 
     return pool.createValue(Pair::create(pool.createIdentifierValue(keyword), pool.createValue(center.length(), style)));
 }
@@ -75,8 +75,8 @@ Ref<CSSPrimitiveValue> valueForBasicShape(const RenderStyle& style, const BasicS
         auto& circle = downcast<BasicShapeCircle>(basicShape);
         auto circleValue = CSSBasicShapeCircle::create();
 
-        circleValue->setCenterX(valueForCenterCoordinate(cssValuePool, style, circle.centerX(), HORIZONTAL));
-        circleValue->setCenterY(valueForCenterCoordinate(cssValuePool, style, circle.centerY(), VERTICAL));
+        circleValue->setCenterX(valueForCenterCoordinate(cssValuePool, style, circle.centerX(), BoxOrient::Horizontal));
+        circleValue->setCenterY(valueForCenterCoordinate(cssValuePool, style, circle.centerY(), BoxOrient::Vertical));
         circleValue->setRadius(basicShapeRadiusToCSSValue(style, cssValuePool, circle.radius()));
 
         basicShapeValue = WTFMove(circleValue);
@@ -86,8 +86,8 @@ Ref<CSSPrimitiveValue> valueForBasicShape(const RenderStyle& style, const BasicS
         auto& ellipse = downcast<BasicShapeEllipse>(basicShape);
         auto ellipseValue = CSSBasicShapeEllipse::create();
 
-        ellipseValue->setCenterX(valueForCenterCoordinate(cssValuePool, style, ellipse.centerX(), HORIZONTAL));
-        ellipseValue->setCenterY(valueForCenterCoordinate(cssValuePool, style, ellipse.centerY(), VERTICAL));
+        ellipseValue->setCenterX(valueForCenterCoordinate(cssValuePool, style, ellipse.centerX(), BoxOrient::Horizontal));
+        ellipseValue->setCenterY(valueForCenterCoordinate(cssValuePool, style, ellipse.centerY(), BoxOrient::Vertical));
         ellipseValue->setRadiusX(basicShapeRadiusToCSSValue(style, cssValuePool, ellipse.radiusX()));
         ellipseValue->setRadiusY(basicShapeRadiusToCSSValue(style, cssValuePool, ellipse.radiusY()));
 
index eeae426..38ad56c 100644 (file)
@@ -878,7 +878,7 @@ static LayoutRect sizingBox(RenderObject& renderer)
         return LayoutRect();
 
     auto& box = downcast<RenderBox>(renderer);
-    return box.style().boxSizing() == BORDER_BOX ? box.borderBoxRect() : box.computedCSSContentBoxRect();
+    return box.style().boxSizing() == BoxSizing::BorderBox ? box.borderBoxRect() : box.computedCSSContentBoxRect();
 }
 
 static Ref<CSSFunctionValue> matrixTransformValue(const TransformationMatrix& transform, const RenderStyle& style)
@@ -1868,16 +1868,16 @@ static Ref<CSSValue> hangingPunctuationToCSSValue(HangingPunctuation hangingPunc
     return WTFMove(list);
 }
     
-static Ref<CSSValue> fillRepeatToCSSValue(EFillRepeat xRepeat, EFillRepeat yRepeat)
+static Ref<CSSValue> fillRepeatToCSSValue(FillRepeat xRepeat, FillRepeat 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.
     auto& cssValuePool = CSSValuePool::singleton();
     if (xRepeat == yRepeat)
         return cssValuePool.createValue(xRepeat);
-    if (xRepeat == RepeatFill && yRepeat == NoRepeatFill)
+    if (xRepeat == FillRepeat::Repeat && yRepeat == FillRepeat::NoRepeat)
         return cssValuePool.createIdentifierValue(CSSValueRepeatX);
-    if (xRepeat == NoRepeatFill && yRepeat == RepeatFill)
+    if (xRepeat == FillRepeat::NoRepeat && yRepeat == FillRepeat::Repeat)
         return cssValuePool.createIdentifierValue(CSSValueRepeatY);
 
     auto list = CSSValueList::createSpaceSeparated();
@@ -1886,23 +1886,23 @@ static Ref<CSSValue> fillRepeatToCSSValue(EFillRepeat xRepeat, EFillRepeat yRepe
     return WTFMove(list);
 }
 
-static Ref<CSSValue> fillSourceTypeToCSSValue(EMaskSourceType type)
+static Ref<CSSValue> fillSourceTypeToCSSValue(MaskSourceType type)
 {
     switch (type) {
-    case MaskAlpha:
+    case MaskSourceType::Alpha:
         return CSSValuePool::singleton().createValue(CSSValueAlpha);
     default:
-        ASSERT(type == MaskLuminance);
+        ASSERT(type == MaskSourceType::Luminance);
         return CSSValuePool::singleton().createValue(CSSValueLuminance);
     }
 }
 
 static Ref<CSSValue> fillSizeToCSSValue(const FillSize& fillSize, const RenderStyle& style)
 {
-    if (fillSize.type == Contain)
+    if (fillSize.type == FillSizeType::Contain)
         return CSSValuePool::singleton().createIdentifierValue(CSSValueContain);
 
-    if (fillSize.type == Cover)
+    if (fillSize.type == FillSizeType::Cover)
         return CSSValuePool::singleton().createIdentifierValue(CSSValueCover);
 
     if (fillSize.size.height.isAuto())
@@ -2515,17 +2515,17 @@ static Ref<CSSValueList> valueForItemPositionWithOverflowAlignment(const StyleSe
 {
     auto& cssValuePool = CSSValuePool::singleton();
     auto result = CSSValueList::createSpaceSeparated();
-    if (data.positionType() == LegacyPosition)
+    if (data.positionType() == ItemPositionType::Legacy)
         result->append(cssValuePool.createIdentifierValue(CSSValueLegacy));
-    if (data.position() == ItemPositionBaseline)
+    if (data.position() == ItemPosition::Baseline)
         result->append(cssValuePool.createIdentifierValue(CSSValueBaseline));
-    else if (data.position() == ItemPositionLastBaseline) {
+    else if (data.position() == ItemPosition::LastBaseline) {
         result->append(cssValuePool.createIdentifierValue(CSSValueLast));
         result->append(cssValuePool.createIdentifierValue(CSSValueBaseline));
     } else {
-        if (data.position() >= ItemPositionCenter && data.overflow() != OverflowAlignmentDefault)
+        if (data.position() >= ItemPosition::Center && data.overflow() != OverflowAlignment::Default)
             result->append(cssValuePool.createValue(data.overflow()));
-        if (data.position() == ItemPositionLegacy)
+        if (data.position() == ItemPosition::Legacy)
             result->append(cssValuePool.createIdentifierValue(CSSValueNormal));
         else
             result->append(cssValuePool.createValue(data.position()));
@@ -2539,23 +2539,23 @@ static Ref<CSSValueList> valueForContentPositionAndDistributionWithOverflowAlign
     auto& cssValuePool = CSSValuePool::singleton();
     auto result = CSSValueList::createSpaceSeparated();
     // Handle content-distribution values
-    if (data.distribution() != ContentDistributionDefault)
+    if (data.distribution() != ContentDistribution::Default)
         result->append(cssValuePool.createValue(data.distribution()));
 
     // Handle content-position values (either as fallback or actual value)
     switch (data.position()) {
-    case ContentPositionNormal:
+    case ContentPosition::Normal:
         // Handle 'normal' value, not valid as content-distribution fallback.
-        if (data.distribution() == ContentDistributionDefault)
+        if (data.distribution() == ContentDistribution::Default)
             result->append(cssValuePool.createIdentifierValue(CSSValueNormal));
         break;
-    case ContentPositionLastBaseline:
+    case ContentPosition::LastBaseline:
         result->append(cssValuePool.createIdentifierValue(CSSValueLast));
         result->append(cssValuePool.createIdentifierValue(CSSValueBaseline));
         break;
     default:
         // Handle overflow-alignment (only allowed for content-position values)
-        if ((data.position() >= ContentPositionCenter || data.distribution() != ContentDistributionDefault) && data.overflow() != OverflowAlignmentDefault)
+        if ((data.position() >= ContentPosition::Center || data.distribution() != ContentDistribution::Default) && data.overflow() != OverflowAlignment::Default)
             result->append(cssValuePool.createValue(data.overflow()));
         result->append(cssValuePool.createValue(data.position()));
     }
@@ -2837,7 +2837,7 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
             return WTFMove(list);
         }
         case CSSPropertyBorderCollapse:
-            if (style.borderCollapse())
+            if (style.borderCollapse() == BorderCollapse::Collapse)
                 return cssValuePool.createIdentifierValue(CSSValueCollapse);
             return cssValuePool.createIdentifierValue(CSSValueSeparate);
         case CSSPropertyBorderSpacing: {
@@ -2884,7 +2884,7 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
             return cssValuePool.createValue(style.boxAlign());
 #if ENABLE(CSS_BOX_DECORATION_BREAK)
         case CSSPropertyWebkitBoxDecorationBreak:
-            if (style.boxDecorationBreak() == DSLICE)
+            if (style.boxDecorationBreak() == BoxDecorationBreak::Slice)
                 return cssValuePool.createIdentifierValue(CSSValueSlice);
         return cssValuePool.createIdentifierValue(CSSValueClone);
 #endif
@@ -2942,7 +2942,7 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
         case CSSPropertyColumnRuleWidth:
             return zoomAdjustedPixelValue(style.columnRuleWidth(), style);
         case CSSPropertyColumnSpan:
-            return cssValuePool.createIdentifierValue(style.columnSpan() ? CSSValueAll : CSSValueNone);
+            return cssValuePool.createIdentifierValue(style.columnSpan() == ColumnSpan::All ? CSSValueAll : CSSValueNone);
         case CSSPropertyWebkitColumnBreakAfter:
             return cssValuePool.createValue(convertToColumnBreak(style.breakAfter()));
         case CSSPropertyWebkitColumnBreakBefore:
@@ -3270,7 +3270,7 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
         case CSSPropertyOutlineOffset:
             return zoomAdjustedPixelValue(style.outlineOffset(), style);
         case CSSPropertyOutlineStyle:
-            if (style.outlineStyleIsAuto())
+            if (style.outlineStyleIsAuto() == OutlineIsAuto::On)
                 return cssValuePool.createIdentifierValue(CSSValueAuto);
             return cssValuePool.createValue(style.outlineStyle());
         case CSSPropertyOutlineWidth:
@@ -3372,12 +3372,12 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
 #if ENABLE(CSS3_TEXT)
             // If CSS3_TEXT is enabled and text-indent has -webkit-each-line or -webkit-hanging,
             // getPropertyCSSValue() returns CSSValueList.
-            if (style.textIndentLine() == TextIndentEachLine || style.textIndentType() == TextIndentHanging) {
+            if (style.textIndentLine() == TextIndentLine::EachLine || style.textIndentType() == TextIndentType::Hanging) {
                 auto list = CSSValueList::createSpaceSeparated();
                 list->append(WTFMove(textIndent));
-                if (style.textIndentLine() == TextIndentEachLine)
+                if (style.textIndentLine() == TextIndentLine::EachLine)
                     list->append(cssValuePool.createIdentifierValue(CSSValueWebkitEachLine));
-                if (style.textIndentType() == TextIndentHanging)
+                if (style.textIndentType() == TextIndentType::Hanging)
                     list->append(cssValuePool.createIdentifierValue(CSSValueWebkitHanging));
                 return WTFMove(list);
             }
@@ -3389,7 +3389,7 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
         case CSSPropertyTextRendering:
             return cssValuePool.createValue(style.fontDescription().textRenderingMode());
         case CSSPropertyTextOverflow:
-            if (style.textOverflow())
+            if (style.textOverflow() == TextOverflow::Ellipsis)
                 return cssValuePool.createIdentifierValue(CSSValueEllipsis);
             return cssValuePool.createIdentifierValue(CSSValueClip);
         case CSSPropertyWebkitTextSecurity:
@@ -3414,26 +3414,26 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
             return cssValuePool.createValue(style.unicodeBidi());
         case CSSPropertyVerticalAlign:
             switch (style.verticalAlign()) {
-                case BASELINE:
-                    return cssValuePool.createIdentifierValue(CSSValueBaseline);
-                case MIDDLE:
-                    return cssValuePool.createIdentifierValue(CSSValueMiddle);
-                case SUB:
-                    return cssValuePool.createIdentifierValue(CSSValueSub);
-                case SUPER:
-                    return cssValuePool.createIdentifierValue(CSSValueSuper);
-                case TEXT_TOP:
-                    return cssValuePool.createIdentifierValue(CSSValueTextTop);
-                case TEXT_BOTTOM:
-                    return cssValuePool.createIdentifierValue(CSSValueTextBottom);
-                case TOP:
-                    return cssValuePool.createIdentifierValue(CSSValueTop);
-                case BOTTOM:
-                    return cssValuePool.createIdentifierValue(CSSValueBottom);
-                case BASELINE_MIDDLE:
-                    return cssValuePool.createIdentifierValue(CSSValueWebkitBaselineMiddle);
-                case LENGTH:
-                    return cssValuePool.createValue(style.verticalAlignLength());
+            case VerticalAlign::Baseline:
+                return cssValuePool.createIdentifierValue(CSSValueBaseline);
+            case VerticalAlign::Middle:
+                return cssValuePool.createIdentifierValue(CSSValueMiddle);
+            case VerticalAlign::Sub:
+                return cssValuePool.createIdentifierValue(CSSValueSub);
+            case VerticalAlign::Super:
+                return cssValuePool.createIdentifierValue(CSSValueSuper);
+            case VerticalAlign::TextTop:
+                return cssValuePool.createIdentifierValue(CSSValueTextTop);
+            case VerticalAlign::TextBottom:
+                return cssValuePool.createIdentifierValue(CSSValueTextBottom);
+            case VerticalAlign::Top:
+                return cssValuePool.createIdentifierValue(CSSValueTop);
+            case VerticalAlign::Bottom:
+                return cssValuePool.createIdentifierValue(CSSValueBottom);
+            case VerticalAlign::BaselineMiddle:
+                return cssValuePool.createIdentifierValue(CSSValueWebkitBaselineMiddle);
+            case VerticalAlign::Length:
+                return cssValuePool.createValue(style.verticalAlignLength());
             }
             ASSERT_NOT_REACHED();
             return nullptr;
@@ -3491,7 +3491,7 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
         case CSSPropertyZoom:
             return cssValuePool.createValue(style.zoom(), CSSPrimitiveValue::CSS_NUMBER);
         case CSSPropertyBoxSizing:
-            if (style.boxSizing() == CONTENT_BOX)
+            if (style.boxSizing() == BoxSizing::ContentBox)
                 return cssValuePool.createIdentifierValue(CSSValueContentBox);
             return cssValuePool.createIdentifierValue(CSSValueBorderBox);
 #if ENABLE(DASHBOARD_SUPPORT)
@@ -3627,15 +3627,20 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
         case CSSPropertyWebkitAppearance:
             return cssValuePool.createValue(style.appearance());
         case CSSPropertyWebkitAspectRatio:
-            if (style.aspectRatioType() == AspectRatioAuto)
+            switch (style.aspectRatioType()) {
+            case AspectRatioType::Auto:
                 return cssValuePool.createIdentifierValue(CSSValueAuto);
-            if (style.aspectRatioType() == AspectRatioFromDimensions)
+            case AspectRatioType::FromDimensions:
                 return cssValuePool.createIdentifierValue(CSSValueFromDimensions);
-            if (style.aspectRatioType() == AspectRatioFromIntrinsic)
+            case AspectRatioType::FromIntrinsic:
                 return cssValuePool.createIdentifierValue(CSSValueFromIntrinsic);
-            return CSSAspectRatioValue::create(style.aspectRatioNumerator(), style.aspectRatioDenominator());
+            case AspectRatioType::Specified:
+                return CSSAspectRatioValue::create(style.aspectRatioNumerator(), style.aspectRatioDenominator());
+            }
+            ASSERT_NOT_REACHED();
+            return nullptr;
         case CSSPropertyWebkitBackfaceVisibility:
-            return cssValuePool.createIdentifierValue((style.backfaceVisibility() == BackfaceVisibilityHidden) ? CSSValueHidden : CSSValueVisible);
+            return cssValuePool.createIdentifierValue((style.backfaceVisibility() == BackfaceVisibility::Hidden) ? CSSValueHidden : CSSValueVisible);
         case CSSPropertyWebkitBorderImage:
             return valueForNinePieceImage(style.borderImage());
         case CSSPropertyBorderImageOutset:
@@ -3693,11 +3698,9 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
 
                 list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginX(), box.width()), style));
                 list->append(zoomAdjustedPixelValue(minimumValueForLength(style.perspectiveOriginY(), box.height()), style));
-            }
-            else {
+            } else {
                 list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginX(), style));
                 list->append(zoomAdjustedPixelValueForLength(style.perspectiveOriginY(), style));
-
             }
             return WTFMove(list);
         }
@@ -3762,7 +3765,7 @@ RefPtr<CSSValue> ComputedStyleExtractor::valueForPropertyinStyle(const RenderSty
         }
         case CSSPropertyTransformStyle:
         case CSSPropertyWebkitTransformStyle:
-            return cssValuePool.createIdentifierValue((style.transformStyle3D() == TransformStyle3DPreserve3D) ? CSSValuePreserve3d : CSSValueFlat);
+            return cssValuePool.createIdentifierValue((style.transformStyle3D() == TransformStyle3D::Preserve3D) ? CSSValuePreserve3d : CSSValueFlat);
         case CSSPropertyTransitionDelay:
             return delayValue(style.transitions());
         case CSSPropertyTransitionDuration:
index 15e1645..1c2a3dd 100644 (file)
@@ -129,10 +129,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineClampValue i)
 template<> inline CSSPrimitiveValue::operator LineClampValue() const
 {
     if (primitiveType() == CSS_NUMBER)
-        return LineClampValue(value<int>(), LineClampLineCount);
+        return LineClampValue(value<int>(), LineClamp::LineCount);
 
     if (primitiveType() == CSS_PERCENTAGE)
-        return LineClampValue(value<int>(), LineClampPercentage);
+        return LineClampValue(value<int>(), LineClamp::Percentage);
 
     ASSERT_NOT_REACHED();
     return LineClampValue();
@@ -183,10 +183,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnFill columnFill)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (columnFill) {
-    case ColumnFillAuto:
+    case ColumnFill::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case ColumnFillBalance:
+    case ColumnFill::Balance:
         m_value.valueID = CSSValueBalance;
         break;
     }
@@ -196,12 +196,12 @@ template<> inline CSSPrimitiveValue::operator ColumnFill() const
 {
     if (m_primitiveUnitType == CSS_VALUE_ID) {
         if (m_value.valueID == CSSValueBalance)
-            return ColumnFillBalance;
+            return ColumnFill::Balance;
         if (m_value.valueID == CSSValueAuto)
-            return ColumnFillAuto;
+            return ColumnFill::Auto;
     }
     ASSERT_NOT_REACHED();
-    return ColumnFillBalance;
+    return ColumnFill::Balance;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
@@ -209,10 +209,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ColumnSpan columnSpan)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (columnSpan) {
-    case ColumnSpanAll:
+    case ColumnSpan::All:
         m_value.valueID = CSSValueAll;
         break;
-    case ColumnSpanNone:
+    case ColumnSpan::None:
         m_value.valueID = CSSValueNone;
         break;
     }
@@ -222,21 +222,21 @@ template<> inline CSSPrimitiveValue::operator ColumnSpan() const
 {
     // Map 1 to none for compatibility reasons.
     if (m_primitiveUnitType == CSS_NUMBER && m_value.num == 1)
-        return ColumnSpanNone;
+        return ColumnSpan::None;
 
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueAll:
-        return ColumnSpanAll;
+        return ColumnSpan::All;
     case CSSValueNone:
-        return ColumnSpanNone;
+        return ColumnSpan::None;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return ColumnSpanNone;
+    return ColumnSpan::None;
 }
 
 
@@ -245,10 +245,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PrintColorAdjust value)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (value) {
-    case PrintColorAdjustExact:
+    case PrintColorAdjust::Exact:
         m_value.valueID = CSSValueExact;
         break;
-    case PrintColorAdjustEconomy:
+    case PrintColorAdjust::Economy:
         m_value.valueID = CSSValueEconomy;
         break;
     }
@@ -260,63 +260,63 @@ template<> inline CSSPrimitiveValue::operator PrintColorAdjust() const
 
     switch (m_value.valueID) {
     case CSSValueEconomy:
-        return PrintColorAdjustEconomy;
+        return PrintColorAdjust::Economy;
     case CSSValueExact:
-        return PrintColorAdjustExact;
+        return PrintColorAdjust::Exact;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return PrintColorAdjustEconomy;
+    return PrintColorAdjust::Economy;
 }
 
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderStyle e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BorderStyle e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case BNONE:
+    case BorderStyle::None:
         m_value.valueID = CSSValueNone;
         break;
-    case BHIDDEN:
+    case BorderStyle::Hidden:
         m_value.valueID = CSSValueHidden;
         break;
-    case INSET:
+    case BorderStyle::Inset:
         m_value.valueID = CSSValueInset;
         break;
-    case GROOVE:
+    case BorderStyle::Groove:
         m_value.valueID = CSSValueGroove;
         break;
-    case RIDGE:
+    case BorderStyle::Ridge:
         m_value.valueID = CSSValueRidge;
         break;
-    case OUTSET:
+    case BorderStyle::Outset:
         m_value.valueID = CSSValueOutset;
         break;
-    case DOTTED:
+    case BorderStyle::Dotted:
         m_value.valueID = CSSValueDotted;
         break;
-    case DASHED:
+    case BorderStyle::Dashed:
         m_value.valueID = CSSValueDashed;
         break;
-    case SOLID:
+    case BorderStyle::Solid:
         m_value.valueID = CSSValueSolid;
         break;
-    case DOUBLE:
+    case BorderStyle::Double:
         m_value.valueID = CSSValueDouble;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBorderStyle() const
+template<> inline CSSPrimitiveValue::operator BorderStyle() const
 {
     ASSERT(isValueID());
 
     if (m_value.valueID == CSSValueAuto) // Valid for CSS outline-style
-        return DOTTED;
-    return (EBorderStyle)(m_value.valueID - CSSValueNone);
+        return BorderStyle::Dotted;
+    return static_cast<BorderStyle>(m_value.valueID - CSSValueNone);
 }
 
 template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
@@ -324,8 +324,8 @@ template<> inline CSSPrimitiveValue::operator OutlineIsAuto() const
     ASSERT(isValueID());
 
     if (m_value.valueID == CSSValueAuto)
-        return AUTO_ON;
-    return AUTO_OFF;
+        return OutlineIsAuto::On;
+    return OutlineIsAuto::Off;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
@@ -632,277 +632,277 @@ template<> inline CSSPrimitiveValue::operator ControlPart() const
     return ControlPart(m_value.valueID - CSSValueCheckbox + 1);
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBackfaceVisibility e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BackfaceVisibility e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case BackfaceVisibilityVisible:
+    case BackfaceVisibility::Visible:
         m_value.valueID = CSSValueVisible;
         break;
-    case BackfaceVisibilityHidden:
+    case BackfaceVisibility::Hidden:
         m_value.valueID = CSSValueHidden;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBackfaceVisibility() const
+template<> inline CSSPrimitiveValue::operator BackfaceVisibility() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueVisible:
-        return BackfaceVisibilityVisible;
+        return BackfaceVisibility::Visible;
     case CSSValueHidden:
-        return BackfaceVisibilityHidden;
+        return BackfaceVisibility::Hidden;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return BackfaceVisibilityHidden;
+    return BackfaceVisibility::Hidden;
 }
 
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillAttachment e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FillAttachment e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case ScrollBackgroundAttachment:
+    case FillAttachment::ScrollBackground:
         m_value.valueID = CSSValueScroll;
         break;
-    case LocalBackgroundAttachment:
+    case FillAttachment::LocalBackground:
         m_value.valueID = CSSValueLocal;
         break;
-    case FixedBackgroundAttachment:
+    case FillAttachment::FixedBackground:
         m_value.valueID = CSSValueFixed;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EFillAttachment() const
+template<> inline CSSPrimitiveValue::operator FillAttachment() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueScroll:
-        return ScrollBackgroundAttachment;
+        return FillAttachment::ScrollBackground;
     case CSSValueLocal:
-        return LocalBackgroundAttachment;
+        return FillAttachment::LocalBackground;
     case CSSValueFixed:
-        return FixedBackgroundAttachment;
+        return FillAttachment::FixedBackground;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return ScrollBackgroundAttachment;
+    return FillAttachment::ScrollBackground;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillBox e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FillBox e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case BorderFillBox:
+    case FillBox::Border:
         m_value.valueID = CSSValueBorderBox;
         break;
-    case PaddingFillBox:
+    case FillBox::Padding:
         m_value.valueID = CSSValuePaddingBox;
         break;
-    case ContentFillBox:
+    case FillBox::Content:
         m_value.valueID = CSSValueContentBox;
         break;
-    case TextFillBox:
+    case FillBox::Text:
         m_value.valueID = CSSValueText;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EFillBox() const
+template<> inline CSSPrimitiveValue::operator FillBox() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueBorder:
     case CSSValueBorderBox:
-        return BorderFillBox;
+        return FillBox::Border;
     case CSSValuePadding:
     case CSSValuePaddingBox:
-        return PaddingFillBox;
+        return FillBox::Padding;
     case CSSValueContent:
     case CSSValueContentBox:
-        return ContentFillBox;
+        return FillBox::Content;
     case CSSValueText:
     case CSSValueWebkitText:
-        return TextFillBox;
+        return FillBox::Text;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return BorderFillBox;
+    return FillBox::Border;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFillRepeat e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FillRepeat e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case RepeatFill:
+    case FillRepeat::Repeat:
         m_value.valueID = CSSValueRepeat;
         break;
-    case NoRepeatFill:
+    case FillRepeat::NoRepeat:
         m_value.valueID = CSSValueNoRepeat;
         break;
-    case RoundFill:
+    case FillRepeat::Round:
         m_value.valueID = CSSValueRound;
         break;
-    case SpaceFill:
+    case FillRepeat::Space:
         m_value.valueID = CSSValueSpace;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EFillRepeat() const
+template<> inline CSSPrimitiveValue::operator FillRepeat() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueRepeat:
-        return RepeatFill;
+        return FillRepeat::Repeat;
     case CSSValueNoRepeat:
-        return NoRepeatFill;
+        return FillRepeat::NoRepeat;
     case CSSValueRound:
-        return RoundFill;
+        return FillRepeat::Round;
     case CSSValueSpace:
-        return SpaceFill;
+        return FillRepeat::Space;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return RepeatFill;
+    return FillRepeat::Repeat;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxPack e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxPack e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case Start:
+    case BoxPack::Start:
         m_value.valueID = CSSValueStart;
         break;
-    case Center:
+    case BoxPack::Center:
         m_value.valueID = CSSValueCenter;
         break;
-    case End:
+    case BoxPack::End:
         m_value.valueID = CSSValueEnd;
         break;
-    case Justify:
+    case BoxPack::Justify:
         m_value.valueID = CSSValueJustify;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBoxPack() const
+template<> inline CSSPrimitiveValue::operator BoxPack() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueStart:
-        return Start;
+        return BoxPack::Start;
     case CSSValueEnd:
-        return End;
+        return BoxPack::End;
     case CSSValueCenter:
-        return Center;
+        return BoxPack::Center;
     case CSSValueJustify:
-        return Justify;
+        return BoxPack::Justify;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return Justify;
+    return BoxPack::Justify;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxAlignment e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxAlignment e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case BSTRETCH:
+    case BoxAlignment::Stretch:
         m_value.valueID = CSSValueStretch;
         break;
-    case BSTART:
+    case BoxAlignment::Start:
         m_value.valueID = CSSValueStart;
         break;
-    case BCENTER:
+    case BoxAlignment::Center:
         m_value.valueID = CSSValueCenter;
         break;
-    case BEND:
+    case BoxAlignment::End:
         m_value.valueID = CSSValueEnd;
         break;
-    case BBASELINE:
+    case BoxAlignment::Baseline:
         m_value.valueID = CSSValueBaseline;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBoxAlignment() const
+template<> inline CSSPrimitiveValue::operator BoxAlignment() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueStretch:
-        return BSTRETCH;
+        return BoxAlignment::Stretch;
     case CSSValueStart:
-        return BSTART;
+        return BoxAlignment::Start;
     case CSSValueEnd:
-        return BEND;
+        return BoxAlignment::End;
     case CSSValueCenter:
-        return BCENTER;
+        return BoxAlignment::Center;
     case CSSValueBaseline:
-        return BBASELINE;
+        return BoxAlignment::Baseline;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return BSTRETCH;
+    return BoxAlignment::Stretch;
 }
 
 #if ENABLE(CSS_BOX_DECORATION_BREAK)
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDecorationBreak e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxDecorationBreak e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case DSLICE:
+    case BoxDecorationBreak::Slice:
         m_value.valueID = CSSValueSlice;
         break;
-    case DCLONE:
+    case BoxDecorationBreak::Clone:
         m_value.valueID = CSSValueClone;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBoxDecorationBreak() const
+template<> inline CSSPrimitiveValue::operator BoxDecorationBreak() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueSlice:
-        return DSLICE;
+        return BoxDecorationBreak::Slice;
     case CSSValueClone:
-        return DCLONE;
+        return BoxDecorationBreak::Clone;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return DSLICE;
+    return BoxDecorationBreak::Slice;
 }
 #endif
 
@@ -947,130 +947,130 @@ template<> inline CSSPrimitiveValue::operator Edge() const
     return Edge::Top;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxSizing e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxSizing e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case BORDER_BOX:
+    case BoxSizing::BorderBox:
         m_value.valueID = CSSValueBorderBox;
         break;
-    case CONTENT_BOX:
+    case BoxSizing::ContentBox:
         m_value.valueID = CSSValueContentBox;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBoxSizing() const
+template<> inline CSSPrimitiveValue::operator BoxSizing() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueBorderBox:
-        return BORDER_BOX;
+        return BoxSizing::BorderBox;
     case CSSValueContentBox:
-        return CONTENT_BOX;
+        return BoxSizing::ContentBox;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return BORDER_BOX;
+    return BoxSizing::BorderBox;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxDirection e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxDirection e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case BNORMAL:
+    case BoxDirection::Normal:
         m_value.valueID = CSSValueNormal;
         break;
-    case BREVERSE:
+    case BoxDirection::Reverse:
         m_value.valueID = CSSValueReverse;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBoxDirection() const
+template<> inline CSSPrimitiveValue::operator BoxDirection() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueNormal:
-        return BNORMAL;
+        return BoxDirection::Normal;
     case CSSValueReverse:
-        return BREVERSE;
+        return BoxDirection::Reverse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return BNORMAL;
+    return BoxDirection::Normal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxLines e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxLines e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case SINGLE:
+    case BoxLines::Single:
         m_value.valueID = CSSValueSingle;
         break;
-    case MULTIPLE:
+    case BoxLines::Multiple:
         m_value.valueID = CSSValueMultiple;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBoxLines() const
+template<> inline CSSPrimitiveValue::operator BoxLines() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueSingle:
-        return SINGLE;
+        return BoxLines::Single;
     case CSSValueMultiple:
-        return MULTIPLE;
+        return BoxLines::Multiple;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return SINGLE;
+    return BoxLines::Single;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBoxOrient e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BoxOrient e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case HORIZONTAL:
+    case BoxOrient::Horizontal:
         m_value.valueID = CSSValueHorizontal;
         break;
-    case VERTICAL:
+    case BoxOrient::Vertical:
         m_value.valueID = CSSValueVertical;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBoxOrient() const
+template<> inline CSSPrimitiveValue::operator BoxOrient() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueHorizontal:
     case CSSValueInlineAxis:
-        return HORIZONTAL;
+        return BoxOrient::Horizontal;
     case CSSValueVertical:
     case CSSValueBlockAxis:
-        return VERTICAL;
+        return BoxOrient::Vertical;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return HORIZONTAL;
+    return BoxOrient::Horizontal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECaptionSide e)
@@ -1114,45 +1114,45 @@ template<> inline CSSPrimitiveValue::operator ECaptionSide() const
     return CAPTOP;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EClear e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Clear e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case CNONE:
+    case Clear::None:
         m_value.valueID = CSSValueNone;
         break;
-    case CLEFT:
+    case Clear::Left:
         m_value.valueID = CSSValueLeft;
         break;
-    case CRIGHT:
+    case Clear::Right:
         m_value.valueID = CSSValueRight;
         break;
-    case CBOTH:
+    case Clear::Both:
         m_value.valueID = CSSValueBoth;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EClear() const
+template<> inline CSSPrimitiveValue::operator Clear() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueNone:
-        return CNONE;
+        return Clear::None;
     case CSSValueLeft:
-        return CLEFT;
+        return Clear::Left;
     case CSSValueRight:
-        return CRIGHT;
+        return Clear::Right;
     case CSSValueBoth:
-        return CBOTH;
+        return Clear::Both;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return CNONE;
+    return Clear::None;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ECursor e)
@@ -1447,169 +1447,169 @@ template<> inline CSSPrimitiveValue::operator EEmptyCell() const
     return SHOW;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexDirection e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FlexDirection e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case FlowRow:
+    case FlexDirection::Row:
         m_value.valueID = CSSValueRow;
         break;
-    case FlowRowReverse:
+    case FlexDirection::RowReverse:
         m_value.valueID = CSSValueRowReverse;
         break;
-    case FlowColumn:
+    case FlexDirection::Column:
         m_value.valueID = CSSValueColumn;
         break;
-    case FlowColumnReverse:
+    case FlexDirection::ColumnReverse:
         m_value.valueID = CSSValueColumnReverse;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EFlexDirection() const
+template<> inline CSSPrimitiveValue::operator FlexDirection() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueRow:
-        return FlowRow;
+        return FlexDirection::Row;
     case CSSValueRowReverse:
-        return FlowRowReverse;
+        return FlexDirection::RowReverse;
     case CSSValueColumn:
-        return FlowColumn;
+        return FlexDirection::Column;
     case CSSValueColumnReverse:
-        return FlowColumnReverse;
+        return FlexDirection::ColumnReverse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return FlowRow;
+    return FlexDirection::Row;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EAlignContent e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(AlignContent e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case AlignContentFlexStart:
+    case AlignContent::FlexStart:
         m_value.valueID = CSSValueFlexStart;
         break;
-    case AlignContentFlexEnd:
+    case AlignContent::FlexEnd:
         m_value.valueID = CSSValueFlexEnd;
         break;
-    case AlignContentCenter:
+    case AlignContent::Center:
         m_value.valueID = CSSValueCenter;
         break;
-    case AlignContentSpaceBetween:
+    case AlignContent::SpaceBetween:
         m_value.valueID = CSSValueSpaceBetween;
         break;
-    case AlignContentSpaceAround:
+    case AlignContent::SpaceAround:
         m_value.valueID = CSSValueSpaceAround;
         break;
-    case AlignContentStretch:
+    case AlignContent::Stretch:
         m_value.valueID = CSSValueStretch;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EAlignContent() const
+template<> inline CSSPrimitiveValue::operator AlignContent() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueFlexStart:
-        return AlignContentFlexStart;
+        return AlignContent::FlexStart;
     case CSSValueFlexEnd:
-        return AlignContentFlexEnd;
+        return AlignContent::FlexEnd;
     case CSSValueCenter:
-        return AlignContentCenter;
+        return AlignContent::Center;
     case CSSValueSpaceBetween:
-        return AlignContentSpaceBetween;
+        return AlignContent::SpaceBetween;
     case CSSValueSpaceAround:
-        return AlignContentSpaceAround;
+        return AlignContent::SpaceAround;
     case CSSValueStretch:
-        return AlignContentStretch;
+        return AlignContent::Stretch;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return AlignContentStretch;
+    return AlignContent::Stretch;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFlexWrap e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FlexWrap e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case FlexNoWrap:
+    case FlexWrap::NoWrap:
         m_value.valueID = CSSValueNowrap;
         break;
-    case FlexWrap:
+    case FlexWrap::Wrap:
         m_value.valueID = CSSValueWrap;
         break;
-    case FlexWrapReverse:
+    case FlexWrap::Reverse:
         m_value.valueID = CSSValueWrapReverse;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EFlexWrap() const
+template<> inline CSSPrimitiveValue::operator FlexWrap() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueNowrap:
-        return FlexNoWrap;
+        return FlexWrap::NoWrap;
     case CSSValueWrap:
-        return FlexWrap;
+        return FlexWrap::Wrap;
     case CSSValueWrapReverse:
-        return FlexWrapReverse;
+        return FlexWrap::Reverse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return FlexNoWrap;
+    return FlexWrap::NoWrap;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EFloat e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Float e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case NoFloat:
+    case Float::No:
         m_value.valueID = CSSValueNone;
         break;
-    case LeftFloat:
+    case Float::Left:
         m_value.valueID = CSSValueLeft;
         break;
-    case RightFloat:
+    case Float::Right:
         m_value.valueID = CSSValueRight;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EFloat() const
+template<> inline CSSPrimitiveValue::operator Float() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueLeft:
-        return LeftFloat;
+        return Float::Left;
     case CSSValueRight:
-        return RightFloat;
+        return Float::Right;
     case CSSValueNone:
     case CSSValueCenter: // Non-standard CSS value.
-        return NoFloat;
+        return Float::No;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return NoFloat;
+    return Float::No;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
@@ -1617,19 +1617,19 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineBreak e)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case LineBreakAuto:
+    case LineBreak::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case LineBreakLoose:
+    case LineBreak::Loose:
         m_value.valueID = CSSValueLoose;
         break;
-    case LineBreakNormal:
+    case LineBreak::Normal:
         m_value.valueID = CSSValueNormal;
         break;
-    case LineBreakStrict:
+    case LineBreak::Strict:
         m_value.valueID = CSSValueStrict;
         break;
-    case LineBreakAfterWhiteSpace:
+    case LineBreak::AfterWhiteSpace:
         m_value.valueID = CSSValueAfterWhiteSpace;
         break;
     }
@@ -1664,21 +1664,21 @@ template<> inline CSSPrimitiveValue::operator LineBreak() const
 
     switch (m_value.valueID) {
     case CSSValueAuto:
-        return LineBreakAuto;
+        return LineBreak::Auto;
     case CSSValueLoose:
-        return LineBreakLoose;
+        return LineBreak::Loose;
     case CSSValueNormal:
-        return LineBreakNormal;
+        return LineBreak::Normal;
     case CSSValueStrict:
-        return LineBreakStrict;
+        return LineBreak::Strict;
     case CSSValueAfterWhiteSpace:
-        return LineBreakAfterWhiteSpace;
+        return LineBreak::AfterWhiteSpace;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return LineBreakAuto;
+    return LineBreak::Auto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EListStylePosition e)
@@ -1975,40 +1975,40 @@ template<> inline CSSPrimitiveValue::operator EListStyleType() const
     }
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EMarginCollapse e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(MarginCollapse e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case MCOLLAPSE:
+    case MarginCollapse::Collapse:
         m_value.valueID = CSSValueCollapse;
         break;
-    case MSEPARATE:
+    case MarginCollapse::Separate:
         m_value.valueID = CSSValueSeparate;
         break;
-    case MDISCARD:
+    case MarginCollapse::Discard:
         m_value.valueID = CSSValueDiscard;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EMarginCollapse() const
+template<> inline CSSPrimitiveValue::operator MarginCollapse() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueCollapse:
-        return MCOLLAPSE;
+        return MarginCollapse::Collapse;
     case CSSValueSeparate:
-        return MSEPARATE;
+        return MarginCollapse::Separate;
     case CSSValueDiscard:
-        return MDISCARD;
+        return MarginCollapse::Discard;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return MCOLLAPSE;
+    return MarginCollapse::Collapse;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(MarqueeBehavior e)
@@ -2110,91 +2110,91 @@ template<> inline CSSPrimitiveValue::operator MarqueeDirection() const
     return MarqueeDirection::Auto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ENBSPMode e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(NBSPMode e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case NBNORMAL:
+    case NBSPMode::Normal:
         m_value.valueID = CSSValueNormal;
         break;
-    case SPACE:
+    case NBSPMode::Space:
         m_value.valueID = CSSValueSpace;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator ENBSPMode() const
+template<> inline CSSPrimitiveValue::operator NBSPMode() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueSpace:
-        return SPACE;
+        return NBSPMode::Space;
     case CSSValueNormal:
-        return NBNORMAL;
+        return NBSPMode::Normal;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return NBNORMAL;
+    return NBSPMode::Normal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflow e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Overflow e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case OVISIBLE:
+    case Overflow::Visible:
         m_value.valueID = CSSValueVisible;
         break;
-    case OHIDDEN:
+    case Overflow::Hidden:
         m_value.valueID = CSSValueHidden;
         break;
-    case OSCROLL:
+    case Overflow::Scroll:
         m_value.valueID = CSSValueScroll;
         break;
-    case OAUTO:
+    case Overflow::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case OOVERLAY:
+    case Overflow::Overlay:
         m_value.valueID = CSSValueOverlay;
         break;
-    case OPAGEDX:
+    case Overflow::PagedX:
         m_value.valueID = CSSValueWebkitPagedX;
         break;
-    case OPAGEDY:
+    case Overflow::PagedY:
         m_value.valueID = CSSValueWebkitPagedY;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EOverflow() const
+template<> inline CSSPrimitiveValue::operator Overflow() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueVisible:
-        return OVISIBLE;
+        return Overflow::Visible;
     case CSSValueHidden:
-        return OHIDDEN;
+        return Overflow::Hidden;
     case CSSValueScroll:
-        return OSCROLL;
+        return Overflow::Scroll;
     case CSSValueAuto:
-        return OAUTO;
+        return Overflow::Auto;
     case CSSValueOverlay:
-        return OOVERLAY;
+        return Overflow::Overlay;
     case CSSValueWebkitPagedX:
-        return OPAGEDX;
+        return Overflow::PagedX;
     case CSSValueWebkitPagedY:
-        return OPAGEDY;
+        return Overflow::PagedY;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return OVISIBLE;
+    return Overflow::Visible;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BreakBetween e)
@@ -2309,125 +2309,125 @@ template<> inline CSSPrimitiveValue::operator BreakInside() const
     return AutoBreakInside;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EPosition e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(PositionType e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case StaticPosition:
+    case PositionType::Static:
         m_value.valueID = CSSValueStatic;
         break;
-    case RelativePosition:
+    case PositionType::Relative:
         m_value.valueID = CSSValueRelative;
         break;
-    case AbsolutePosition:
+    case PositionType::Absolute:
         m_value.valueID = CSSValueAbsolute;
         break;
-    case FixedPosition:
+    case PositionType::Fixed:
         m_value.valueID = CSSValueFixed;
         break;
-    case StickyPosition:
+    case PositionType::Sticky:
         m_value.valueID = CSSValueWebkitSticky;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EPosition() const
+template<> inline CSSPrimitiveValue::operator PositionType() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueStatic:
-        return StaticPosition;
+        return PositionType::Static;
     case CSSValueRelative:
-        return RelativePosition;
+        return PositionType::Relative;
     case CSSValueAbsolute:
-        return AbsolutePosition;
+        return PositionType::Absolute;
     case CSSValueFixed:
-        return FixedPosition;
+        return PositionType::Fixed;
     case CSSValueWebkitSticky:
-        return StickyPosition;
+        return PositionType::Sticky;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return StaticPosition;
+    return PositionType::Static;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EResize e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Resize e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case RESIZE_BOTH:
+    case Resize::Both:
         m_value.valueID = CSSValueBoth;
         break;
-    case RESIZE_HORIZONTAL:
+    case Resize::Horizontal:
         m_value.valueID = CSSValueHorizontal;
         break;
-    case RESIZE_VERTICAL:
+    case Resize::Vertical:
         m_value.valueID = CSSValueVertical;
         break;
-    case RESIZE_NONE:
+    case Resize::None:
         m_value.valueID = CSSValueNone;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EResize() const
+template<> inline CSSPrimitiveValue::operator Resize() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueBoth:
-        return RESIZE_BOTH;
+        return Resize::Both;
     case CSSValueHorizontal:
-        return RESIZE_HORIZONTAL;
+        return Resize::Horizontal;
     case CSSValueVertical:
-        return RESIZE_VERTICAL;
+        return Resize::Vertical;
     case CSSValueAuto:
         ASSERT_NOT_REACHED(); // Depends on settings, thus should be handled by the caller.
-        return RESIZE_NONE;
+        return Resize::None;
     case CSSValueNone:
-        return RESIZE_NONE;
+        return Resize::None;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return RESIZE_NONE;
+    return Resize::None;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETableLayout e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TableLayoutType e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case TAUTO:
+    case TableLayoutType::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case TFIXED:
+    case TableLayoutType::Fixed:
         m_value.valueID = CSSValueFixed;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator ETableLayout() const
+template<> inline CSSPrimitiveValue::operator TableLayoutType() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueFixed:
-        return TFIXED;
+        return TableLayoutType::Fixed;
     case CSSValueAuto:
-        return TAUTO;
+        return TableLayoutType::Auto;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return TAUTO;
+    return TableLayoutType::Auto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextAlign e)
@@ -2669,45 +2669,45 @@ template<> inline CSSPrimitiveValue::operator TextUnderlinePosition() const
     return TextUnderlinePositionAuto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextSecurity e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextSecurity e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case TSNONE:
+    case TextSecurity::None:
         m_value.valueID = CSSValueNone;
         break;
-    case TSDISC:
+    case TextSecurity::Disc:
         m_value.valueID = CSSValueDisc;
         break;
-    case TSCIRCLE:
+    case TextSecurity::Circle:
         m_value.valueID = CSSValueCircle;
         break;
-    case TSSQUARE:
+    case TextSecurity::Square:
         m_value.valueID = CSSValueSquare;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator ETextSecurity() const
+template<> inline CSSPrimitiveValue::operator TextSecurity() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueNone:
-        return TSNONE;
+        return TextSecurity::None;
     case CSSValueDisc:
-        return TSDISC;
+        return TextSecurity::Disc;
     case CSSValueCircle:
-        return TSCIRCLE;
+        return TextSecurity::Circle;
     case CSSValueSquare:
-        return TSSQUARE;
+        return TextSecurity::Square;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return TSNONE;
+    return TextSecurity::None;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETextTransform e)
@@ -2805,18 +2805,18 @@ template<> inline CSSPrimitiveValue::operator EUnicodeBidi() const
     return UBNormal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(UserDrag e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case DRAG_AUTO:
+    case UserDrag::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case DRAG_NONE:
+    case UserDrag::None:
         m_value.valueID = CSSValueNone;
         break;
-    case DRAG_ELEMENT:
+    case UserDrag::Element:
         m_value.valueID = CSSValueElement;
         break;
     default:
@@ -2824,165 +2824,165 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserDrag e)
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EUserDrag() const
+template<> inline CSSPrimitiveValue::operator UserDrag() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueAuto:
-        return DRAG_AUTO;
+        return UserDrag::Auto;
     case CSSValueNone:
-        return DRAG_NONE;
+        return UserDrag::None;
     case CSSValueElement:
-        return DRAG_ELEMENT;
+        return UserDrag::Element;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return DRAG_AUTO;
+    return UserDrag::Auto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserModify e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(UserModify e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case READ_ONLY:
+    case UserModify::ReadOnly:
         m_value.valueID = CSSValueReadOnly;
         break;
-    case READ_WRITE:
+    case UserModify::ReadWrite:
         m_value.valueID = CSSValueReadWrite;
         break;
-    case READ_WRITE_PLAINTEXT_ONLY:
+    case UserModify::ReadWritePlaintextOnly:
         m_value.valueID = CSSValueReadWritePlaintextOnly;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EUserModify() const
+template<> inline CSSPrimitiveValue::operator UserModify() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueReadOnly:
-        return READ_ONLY;
+        return UserModify::ReadOnly;
     case CSSValueReadWrite:
-        return READ_WRITE;
+        return UserModify::ReadWrite;
     case CSSValueReadWritePlaintextOnly:
-        return READ_WRITE_PLAINTEXT_ONLY;
+        return UserModify::ReadWritePlaintextOnly;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return READ_ONLY;
+    return UserModify::ReadOnly;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EUserSelect e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(UserSelect e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case SELECT_NONE:
+    case UserSelect::None:
         m_value.valueID = CSSValueNone;
         break;
-    case SELECT_TEXT:
+    case UserSelect::Text:
         m_value.valueID = CSSValueText;
         break;
-    case SELECT_ALL:
+    case UserSelect::All:
         m_value.valueID = CSSValueAll;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EUserSelect() const
+template<> inline CSSPrimitiveValue::operator UserSelect() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueAuto:
-        return SELECT_TEXT;
+        return UserSelect::Text;
     case CSSValueNone:
-        return SELECT_NONE;
+        return UserSelect::None;
     case CSSValueText:
-        return SELECT_TEXT;
+        return UserSelect::Text;
     case CSSValueAll:
-        return SELECT_ALL;
+        return UserSelect::All;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return SELECT_TEXT;
+    return UserSelect::Text;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVerticalAlign a)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(VerticalAlign a)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (a) {
-    case TOP:
+    case VerticalAlign::Top:
         m_value.valueID = CSSValueTop;
         break;
-    case BOTTOM:
+    case VerticalAlign::Bottom:
         m_value.valueID = CSSValueBottom;
         break;
-    case MIDDLE:
+    case VerticalAlign::Middle:
         m_value.valueID = CSSValueMiddle;
         break;
-    case BASELINE:
+    case VerticalAlign::Baseline:
         m_value.valueID = CSSValueBaseline;
         break;
-    case TEXT_BOTTOM:
+    case VerticalAlign::TextBottom:
         m_value.valueID = CSSValueTextBottom;
         break;
-    case TEXT_TOP:
+    case VerticalAlign::TextTop:
         m_value.valueID = CSSValueTextTop;
         break;
-    case SUB:
+    case VerticalAlign::Sub:
         m_value.valueID = CSSValueSub;
         break;
-    case SUPER:
+    case VerticalAlign::Super:
         m_value.valueID = CSSValueSuper;
         break;
-    case BASELINE_MIDDLE:
+    case VerticalAlign::BaselineMiddle:
         m_value.valueID = CSSValueWebkitBaselineMiddle;
         break;
-    case LENGTH:
+    case VerticalAlign::Length:
         m_value.valueID = CSSValueInvalid;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EVerticalAlign() const
+template<> inline CSSPrimitiveValue::operator VerticalAlign() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueTop:
-        return TOP;
+        return VerticalAlign::Top;
     case CSSValueBottom:
-        return BOTTOM;
+        return VerticalAlign::Bottom;
     case CSSValueMiddle:
-        return MIDDLE;
+        return VerticalAlign::Middle;
     case CSSValueBaseline:
-        return BASELINE;
+        return VerticalAlign::Baseline;
     case CSSValueTextBottom:
-        return TEXT_BOTTOM;
+        return VerticalAlign::TextBottom;
     case CSSValueTextTop:
-        return TEXT_TOP;
+        return VerticalAlign::TextTop;
     case CSSValueSub:
-        return SUB;
+        return VerticalAlign::Sub;
     case CSSValueSuper:
-        return SUPER;
+        return VerticalAlign::Super;
     case CSSValueWebkitBaselineMiddle:
-        return BASELINE_MIDDLE;
+        return VerticalAlign::BaselineMiddle;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return TOP;
+    return VerticalAlign::Top;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EVisibility e)
@@ -3072,76 +3072,76 @@ template<> inline CSSPrimitiveValue::operator EWhiteSpace() const
     return NORMAL;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EWordBreak e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(WordBreak e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case NormalWordBreak:
+    case WordBreak::Normal:
         m_value.valueID = CSSValueNormal;
         break;
-    case BreakAllWordBreak:
+    case WordBreak::BreakAll:
         m_value.valueID = CSSValueBreakAll;
         break;
-    case KeepAllWordBreak:
+    case WordBreak::KeepAll:
         m_value.valueID = CSSValueKeepAll;
         break;
-    case BreakWordBreak:
+    case WordBreak::Break:
         m_value.valueID = CSSValueBreakWord;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EWordBreak() const
+template<> inline CSSPrimitiveValue::operator WordBreak() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueBreakAll:
-        return BreakAllWordBreak;
+        return WordBreak::BreakAll;
     case CSSValueKeepAll:
-        return KeepAllWordBreak;
+        return WordBreak::KeepAll;
     case CSSValueBreakWord:
-        return BreakWordBreak;
+        return WordBreak::Break;
     case CSSValueNormal:
-        return NormalWordBreak;
+        return WordBreak::Normal;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return NormalWordBreak;
+    return WordBreak::Normal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EOverflowWrap e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowWrap e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case NormalOverflowWrap:
+    case OverflowWrap::Normal:
         m_value.valueID = CSSValueNormal;
         break;
-    case BreakOverflowWrap:
+    case OverflowWrap::Break:
         m_value.valueID = CSSValueBreakWord;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EOverflowWrap() const
+template<> inline CSSPrimitiveValue::operator OverflowWrap() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueBreakWord:
-        return BreakOverflowWrap;
+        return OverflowWrap::Break;
     case CSSValueNormal:
-        return NormalOverflowWrap;
+        return OverflowWrap::Normal;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return NormalOverflowWrap;
+    return OverflowWrap::Normal;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextDirection e)
@@ -3227,10 +3227,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextCombine e)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case TextCombineNone:
+    case TextCombine::None:
         m_value.valueID = CSSValueNone;
         break;
-    case TextCombineHorizontal:
+    case TextCombine::Horizontal:
         m_value.valueID = CSSValueHorizontal;
         break;
     }
@@ -3242,15 +3242,15 @@ template<> inline CSSPrimitiveValue::operator TextCombine() const
 
     switch (m_value.valueID) {
     case CSSValueNone:
-        return TextCombineNone;
+        return TextCombine::None;
     case CSSValueHorizontal:
-        return TextCombineHorizontal;
+        return TextCombine::Horizontal;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return TextCombineNone;
+    return TextCombine::None;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(RubyPosition position)
@@ -3294,10 +3294,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextOverflow overflow)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (overflow) {
-    case TextOverflowClip:
+    case TextOverflow::Clip:
         m_value.valueID = CSSValueClip;
         break;
-    case TextOverflowEllipsis:
+    case TextOverflow::Ellipsis:
         m_value.valueID = CSSValueEllipsis;
         break;
     }
@@ -3309,15 +3309,15 @@ template<> inline CSSPrimitiveValue::operator TextOverflow() const
 
     switch (m_value.valueID) {
     case CSSValueClip:
-        return TextOverflowClip;
+        return TextOverflow::Clip;
     case CSSValueEllipsis:
-        return TextOverflowEllipsis;
+        return TextOverflow::Ellipsis;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return TextOverflowClip;
+    return TextOverflow::Clip;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TextEmphasisFill fill)
@@ -3560,19 +3560,19 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ObjectFit fit)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (fit) {
-    case ObjectFitFill:
+    case ObjectFit::Fill:
         m_value.valueID = CSSValueFill;
         break;
-    case ObjectFitContain:
+    case ObjectFit::Contain:
         m_value.valueID = CSSValueContain;
         break;
-    case ObjectFitCover:
+    case ObjectFit::Cover:
         m_value.valueID = CSSValueCover;
         break;
-    case ObjectFitNone:
+    case ObjectFit::None:
         m_value.valueID = CSSValueNone;
         break;
-    case ObjectFitScaleDown:
+    case ObjectFit::ScaleDown:
         m_value.valueID = CSSValueScaleDown;
         break;
     }
@@ -3584,18 +3584,18 @@ template<> inline CSSPrimitiveValue::operator ObjectFit() const
 
     switch (m_value.valueID) {
     case CSSValueFill:
-        return ObjectFitFill;
+        return ObjectFit::Fill;
     case CSSValueContain:
-        return ObjectFitContain;
+        return ObjectFit::Contain;
     case CSSValueCover:
-        return ObjectFitCover;
+        return ObjectFit::Cover;
     case CSSValueNone:
-        return ObjectFitNone;
+        return ObjectFit::None;
     case CSSValueScaleDown:
-        return ObjectFitScaleDown;
+        return ObjectFit::ScaleDown;
     default:
         ASSERT_NOT_REACHED();
-        return ObjectFitFill;
+        return ObjectFit::Fill;
     }
 }
 
@@ -4013,10 +4013,10 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (isolation) {
-    case IsolationAuto:
+    case Isolation::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case IsolationIsolate:
+    case Isolation::Isolate:
         m_value.valueID = CSSValueIsolate;
         break;
     default:
@@ -4029,15 +4029,15 @@ template<> inline CSSPrimitiveValue::operator Isolation() const
     ASSERT(isValueID());
     switch (m_value.valueID) {
     case CSSValueAuto:
-        return IsolationAuto;
+        return Isolation::Auto;
     case CSSValueIsolate:
-        return IsolationIsolate;
+        return Isolation::Isolate;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return IsolationAuto;
+    return Isolation::Auto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(LineCap e)
@@ -4225,35 +4225,35 @@ template<> inline CSSPrimitiveValue::operator EAlignmentBaseline() const
     return AB_AUTO;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderCollapse e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BorderCollapse e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case BSEPARATE:
+    case BorderCollapse::Separate:
         m_value.valueID = CSSValueSeparate;
         break;
-    case BCOLLAPSE:
+    case BorderCollapse::Collapse:
         m_value.valueID = CSSValueCollapse;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EBorderCollapse() const
+template<> inline CSSPrimitiveValue::operator BorderCollapse() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueSeparate:
-        return BSEPARATE;
+        return BorderCollapse::Separate;
     case CSSValueCollapse:
-        return BCOLLAPSE;
+        return BorderCollapse::Collapse;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return BSEPARATE;
+    return BorderCollapse::Separate;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EBorderFit e)
@@ -4287,83 +4287,83 @@ template<> inline CSSPrimitiveValue::operator EBorderFit() const
     return BorderFitLines;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(EImageRendering imageRendering)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ImageRendering imageRendering)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (imageRendering) {
-    case ImageRenderingAuto:
+    case ImageRendering::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case ImageRenderingCrispEdges:
+    case ImageRendering::CrispEdges:
         m_value.valueID = CSSValueCrispEdges;
         break;
-    case ImageRenderingPixelated:
+    case ImageRendering::Pixelated:
         m_value.valueID = CSSValuePixelated;
         break;
-    case ImageRenderingOptimizeSpeed:
+    case ImageRendering::OptimizeSpeed:
         m_value.valueID = CSSValueOptimizeSpeed;
         break;
-    case ImageRenderingOptimizeQuality:
+    case ImageRendering::OptimizeQuality:
         m_value.valueID = CSSValueOptimizeQuality;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator EImageRendering() const
+template<> inline CSSPrimitiveValue::operator ImageRendering() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueAuto:
-        return ImageRenderingAuto;
+        return ImageRendering::Auto;
     case CSSValueWebkitOptimizeContrast:
     case CSSValueCrispEdges:
     case CSSValueWebkitCrispEdges:
-        return ImageRenderingCrispEdges;
+        return ImageRendering::CrispEdges;
     case CSSValuePixelated:
-        return ImageRenderingPixelated;
+        return ImageRendering::Pixelated;
     case CSSValueOptimizeSpeed:
-        return ImageRenderingOptimizeSpeed;
+        return ImageRendering::OptimizeSpeed;
     case CSSValueOptimizeQuality:
-        return ImageRenderingOptimizeQuality;
+        return ImageRendering::OptimizeQuality;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return ImageRenderingAuto;
+    return ImageRendering::Auto;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ETransformStyle3D e)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TransformStyle3D e)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (e) {
-    case TransformStyle3DFlat:
+    case TransformStyle3D::Flat:
         m_value.valueID = CSSValueFlat;
         break;
-    case TransformStyle3DPreserve3D:
+    case TransformStyle3D::Preserve3D:
         m_value.valueID = CSSValuePreserve3d;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator ETransformStyle3D() const
+template<> inline CSSPrimitiveValue::operator TransformStyle3D() const
 {
     ASSERT(isValueID());
 
     switch (m_value.valueID) {
     case CSSValueFlat:
-        return TransformStyle3DFlat;
+        return TransformStyle3D::Flat;
     case CSSValuePreserve3d:
-        return TransformStyle3DPreserve3D;
+        return TransformStyle3D::Preserve3D;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED();
-    return TransformStyle3DFlat;
+    return TransformStyle3D::Flat;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(TransformBox box)
@@ -4963,49 +4963,49 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ItemPosition itemPosition
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (itemPosition) {
-    case ItemPositionLegacy:
+    case ItemPosition::Legacy:
         m_value.valueID = CSSValueLegacy;
         break;
-    case ItemPositionAuto:
+    case ItemPosition::Auto:
         m_value.valueID = CSSValueAuto;
         break;
-    case ItemPositionNormal:
+    case ItemPosition::Normal:
         m_value.valueID = CSSValueNormal;
         break;
-    case ItemPositionStretch:
+    case ItemPosition::Stretch:
         m_value.valueID = CSSValueStretch;
         break;
-    case ItemPositionBaseline:
+    case ItemPosition::Baseline:
         m_value.valueID = CSSValueBaseline;
         break;
-    case ItemPositionLastBaseline:
+    case ItemPosition::LastBaseline:
         m_value.valueID = CSSValueLastBaseline;
         break;
-    case ItemPositionCenter:
+    case ItemPosition::Center:
         m_value.valueID = CSSValueCenter;
         break;
-    case ItemPositionStart:
+    case ItemPosition::Start:
         m_value.valueID = CSSValueStart;
         break;
-    case ItemPositionEnd:
+    case ItemPosition::End:
         m_value.valueID = CSSValueEnd;
         break;
-    case ItemPositionSelfStart:
+    case ItemPosition::SelfStart:
         m_value.valueID = CSSValueSelfStart;
         break;
-    case ItemPositionSelfEnd:
+    case ItemPosition::SelfEnd:
         m_value.valueID = CSSValueSelfEnd;
         break;
-    case ItemPositionFlexStart:
+    case ItemPosition::FlexStart:
         m_value.valueID = CSSValueFlexStart;
         break;
-    case ItemPositionFlexEnd:
+    case ItemPosition::FlexEnd:
         m_value.valueID = CSSValueFlexEnd;
         break;
-    case ItemPositionLeft:
+    case ItemPosition::Left:
         m_value.valueID = CSSValueLeft;
         break;
-    case ItemPositionRight:
+    case ItemPosition::Right:
         m_value.valueID = CSSValueRight;
         break;
     }
@@ -5015,42 +5015,42 @@ template<> inline CSSPrimitiveValue::operator ItemPosition() const
 {
     switch (m_value.valueID) {
     case CSSValueLegacy:
-        return ItemPositionLegacy;
+        return ItemPosition::Legacy;
     case CSSValueAuto:
-        return ItemPositionAuto;
+        return ItemPosition::Auto;
     case CSSValueNormal:
-        return ItemPositionNormal;
+        return ItemPosition::Normal;
     case CSSValueStretch:
-        return ItemPositionStretch;
+        return ItemPosition::Stretch;
     case CSSValueBaseline:
-        return ItemPositionBaseline;
+        return ItemPosition::Baseline;
     case CSSValueFirstBaseline:
-        return ItemPositionBaseline;
+        return ItemPosition::Baseline;
     case CSSValueLastBaseline:
-        return ItemPositionLastBaseline;
+        return ItemPosition::LastBaseline;
     case CSSValueCenter:
-        return ItemPositionCenter;
+        return ItemPosition::Center;
     case CSSValueStart:
-        return ItemPositionStart;
+        return ItemPosition::Start;
     case CSSValueEnd:
-        return ItemPositionEnd;
+        return ItemPosition::End;
     case CSSValueSelfStart:
-        return ItemPositionSelfStart;
+        return ItemPosition::SelfStart;
     case CSSValueSelfEnd:
-        return ItemPositionSelfEnd;
+        return ItemPosition::SelfEnd;
     case CSSValueFlexStart:
-        return ItemPositionFlexStart;
+        return ItemPosition::FlexStart;
     case CSSValueFlexEnd:
-        return ItemPositionFlexEnd;
+        return ItemPosition::FlexEnd;
     case CSSValueLeft:
-        return ItemPositionLeft;
+        return ItemPosition::Left;
     case CSSValueRight:
-        return ItemPositionRight;
+        return ItemPosition::Right;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
-    return ItemPositionAuto;
+    return ItemPosition::Auto;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflowAlignment)
@@ -5058,13 +5058,13 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(OverflowAlignment overflo
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (overflowAlignment) {
-    case OverflowAlignmentDefault:
+    case OverflowAlignment::Default:
         m_value.valueID = CSSValueDefault;
         break;
-    case OverflowAlignmentUnsafe:
+    case OverflowAlignment::Unsafe:
         m_value.valueID = CSSValueUnsafe;
         break;
-    case OverflowAlignmentSafe:
+    case OverflowAlignment::Safe:
         m_value.valueID = CSSValueSafe;
         break;
     }
@@ -5074,14 +5074,14 @@ template<> inline CSSPrimitiveValue::operator OverflowAlignment() const
 {
     switch (m_value.valueID) {
     case CSSValueUnsafe:
-        return OverflowAlignmentUnsafe;
+        return OverflowAlignment::Unsafe;
     case CSSValueSafe:
-        return OverflowAlignmentSafe;
+        return OverflowAlignment::Safe;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
-    return OverflowAlignmentUnsafe;
+    return OverflowAlignment::Unsafe;
 }
 
 template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPosition)
@@ -5089,34 +5089,34 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentPosition contentPo
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (contentPosition) {
-    case ContentPositionNormal:
+    case ContentPosition::Normal:
         m_value.valueID = CSSValueNormal;
         break;
-    case ContentPositionBaseline:
+    case ContentPosition::Baseline:
         m_value.valueID = CSSValueBaseline;
         break;
-    case ContentPositionLastBaseline:
+    case ContentPosition::LastBaseline:
         m_value.valueID = CSSValueLastBaseline;
         break;
-    case ContentPositionCenter:
+    case ContentPosition::Center:
         m_value.valueID = CSSValueCenter;
         break;
-    case ContentPositionStart:
+    case ContentPosition::Start:
         m_value.valueID = CSSValueStart;
         break;
-    case ContentPositionEnd:
+    case ContentPosition::End:
         m_value.valueID = CSSValueEnd;
         break;
-    case ContentPositionFlexStart:
+    case ContentPosition::FlexStart:
         m_value.valueID = CSSValueFlexStart;
         break;
-    case ContentPositionFlexEnd:
+    case ContentPosition::FlexEnd:
         m_value.valueID = CSSValueFlexEnd;
         break;
-    case ContentPositionLeft:
+    case ContentPosition::Left:
         m_value.valueID = CSSValueLeft;
         break;
-    case ContentPositionRight:
+    case ContentPosition::Right:
         m_value.valueID = CSSValueRight;
         break;
     }
@@ -5126,73 +5126,73 @@ template<> inline CSSPrimitiveValue::operator ContentPosition() const
 {
     switch (m_value.valueID) {
     case CSSValueNormal:
-        return ContentPositionNormal;
+        return ContentPosition::Normal;
     case CSSValueBaseline:
-        return ContentPositionBaseline;
+        return ContentPosition::Baseline;
     case CSSValueFirstBaseline:
-        return ContentPositionBaseline;
+        return ContentPosition::Baseline;
     case CSSValueLastBaseline:
-        return ContentPositionLastBaseline;
+        return ContentPosition::LastBaseline;
     case CSSValueCenter:
-        return ContentPositionCenter;
+        return ContentPosition::Center;
     case CSSValueStart:
-        return ContentPositionStart;
+        return ContentPosition::Start;
     case CSSValueEnd:
-        return ContentPositionEnd;
+        return ContentPosition::End;
     case CSSValueFlexStart:
-        return ContentPositionFlexStart;
+        return ContentPosition::FlexStart;
     case CSSValueFlexEnd:
-        return ContentPositionFlexEnd;
+        return ContentPosition::FlexEnd;
     case CSSValueLeft:
-        return ContentPositionLeft;
+        return ContentPosition::Left;
     case CSSValueRight:
-        return ContentPositionRight;
+        return ContentPosition::Right;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
-    return ContentPositionNormal;
+    return ContentPosition::Normal;
 }
 
-template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentDistributionType contentDistribution)
+template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ContentDistribution contentDistribution)
     : CSSValue(PrimitiveClass)
 {
     m_primitiveUnitType = CSS_VALUE_ID;
     switch (contentDistribution) {
-    case ContentDistributionDefault:
+    case ContentDistribution::Default:
         m_value.valueID = CSSValueDefault;
         break;
-    case ContentDistributionSpaceBetween:
+    case ContentDistribution::SpaceBetween:
         m_value.valueID = CSSValueSpaceBetween;
         break;
-    case ContentDistributionSpaceAround:
+    case ContentDistribution::SpaceAround:
         m_value.valueID = CSSValueSpaceAround;
         break;
-    case ContentDistributionSpaceEvenly:
+    case ContentDistribution::SpaceEvenly:
         m_value.valueID = CSSValueSpaceEvenly;
         break;
-    case ContentDistributionStretch:
+    case ContentDistribution::Stretch:
         m_value.valueID = CSSValueStretch;
         break;
     }
 }
 
-template<> inline CSSPrimitiveValue::operator ContentDistributionType() const
+template<> inline CSSPrimitiveValue::operator ContentDistribution() const
 {
     switch (m_value.valueID) {
     case CSSValueSpaceBetween:
-        return ContentDistributionSpaceBetween;
+        return ContentDistribution::SpaceBetween;
     case CSSValueSpaceAround:
-        return ContentDistributionSpaceAround;
+        return ContentDistribution::SpaceAround;
     case CSSValueSpaceEvenly:
-        return ContentDistributionSpaceEvenly;
+        return ContentDistribution::SpaceEvenly;
     case CSSValueStretch:
-        return ContentDistributionStretch;
+        return ContentDistribution::Stretch;
     default:
         break;
     }
     ASSERT_NOT_REACHED();
-    return ContentDistributionStretch;
+    return ContentDistribution::Stretch;
 }
 
 template<> inline CSSPrimitiveValue::operator TextZoom() const
index ccd67d4..cde4a40 100644 (file)
             ],
             "codegen-properties": {
                 "name-for-methods": "TransformStyle3D",
-                "comment": "Keeping -webkit-transform-style around is how we'll detect legacy content. At that point, we'll have to add a custom builder and a new ETransformStyle3D type. FIXME: this never happened."
+                "comment": "Keeping -webkit-transform-style around is how we'll detect legacy content. At that point, we'll have to add a custom builder and a new TransformStyle3D type. FIXME: this never happened."
             }
         },
         "-webkit-user-drag": {
index 3520551..e66ada2 100644 (file)
@@ -83,13 +83,13 @@ void CSSToStyleMap::mapFillAttachment(CSSPropertyID propertyID, FillLayer& layer
 
     switch (downcast<CSSPrimitiveValue>(value).valueID()) {
     case CSSValueFixed:
-        layer.setAttachment(FixedBackgroundAttachment);
+        layer.setAttachment(FillAttachment::FixedBackground);
         break;
     case CSSValueScroll:
-        layer.setAttachment(ScrollBackgroundAttachment);
+        layer.setAttachment(FillAttachment::ScrollBackground);
         break;
     case CSSValueLocal:
-        layer.setAttachment(LocalBackgroundAttachment);
+        layer.setAttachment(FillAttachment::LocalBackground);
         break;
     default:
         return;
@@ -208,13 +208,13 @@ void CSSToStyleMap::mapFillSize(CSSPropertyID propertyID, FillLayer& layer, cons
     FillSize fillSize;
     switch (primitiveValue.valueID()) {
     case CSSValueContain:
-        fillSize.type = Contain;
+        fillSize.type = FillSizeType::Contain;
         break;
     case CSSValueCover:
-        fillSize.type = Cover;
+        fillSize.type = FillSizeType::Cover;
         break;
     default:
-        ASSERT(fillSize.type == SizeLength);
+        ASSERT(fillSize.type == FillSizeType::Size);
         if (!convertToLengthSize(primitiveValue, m_resolver->state().cssToLengthConversionData(), fillSize.size))
             return;
         break;
@@ -272,7 +272,7 @@ void CSSToStyleMap::mapFillYPosition(CSSPropertyID propertyID, FillLayer& layer,
 
 void CSSToStyleMap::mapFillMaskSourceType(CSSPropertyID propertyID, FillLayer& layer, const CSSValue& value)
 {
-    EMaskSourceType type = FillLayer::initialFillMaskSourceType(layer.type());
+    MaskSourceType type = FillLayer::initialFillMaskSourceType(layer.type());
     if (value.treatAsInitialValue(propertyID)) {
         layer.setMaskSourceType(type);
         return;
@@ -283,10 +283,10 @@ void CSSToStyleMap::mapFillMaskSourceType(CSSPropertyID propertyID, FillLayer& l
 
     switch (downcast<CSSPrimitiveValue>(value).valueID()) {
     case CSSValueAlpha:
-        type = EMaskSourceType::MaskAlpha;
+        type = MaskSourceType::Alpha;
         break;
     case CSSValueLuminance:
-        type = EMaskSourceType::MaskLuminance;
+        type = MaskSourceType::Luminance;
         break;
     case CSSValueAuto:
         break;
index 1433444..ae7f8b0 100644 (file)
@@ -11,7 +11,7 @@ revert
 // CSS_PROP_BORDER_TOP_STYLE
 // CSS_PROP_BORDER_BOTTOM_STYLE
 // CSS_PROP_BORDER_LEFT_STYLE
-// The order here must match the order of the EBorderStyle enum in RenderStyleConstants.h.
+// The order here must match the order of the BorderStyle enum in RenderStyleConstants.h.
 none
 hidden
 inset
index 6c37c9f..da83cc4 100644 (file)
@@ -83,7 +83,7 @@ public:
     static TextEmphasisPosition convertTextEmphasisPosition(StyleResolver&, const CSSValue&);
     static ETextAlign convertTextAlign(StyleResolver&, const CSSValue&);
     static RefPtr<ClipPathOperation> convertClipPath(StyleResolver&, const CSSValue&);
-    static EResize convertResize(StyleResolver&, const CSSValue&);
+    static Resize convertResize(StyleResolver&, const CSSValue&);
     static int convertMarqueeRepetition(StyleResolver&, const CSSValue&);
     static int convertMarqueeSpeed(StyleResolver&, const CSSValue&);
     static Ref<QuotesData> convertQuotes(StyleResolver&, const CSSValue&);
@@ -562,13 +562,13 @@ inline RefPtr<ClipPathOperation> StyleBuilderConverter::convertClipPath(StyleRes
     return operation;
 }
 
-inline EResize StyleBuilderConverter::convertResize(StyleResolver& styleResolver, const CSSValue& value)
+inline Resize StyleBuilderConverter::convertResize(StyleResolver& styleResolver, const CSSValue& value)
 {
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
-    EResize resize = RESIZE_NONE;
+    Resize resize = Resize::None;
     if (primitiveValue.valueID() == CSSValueAuto)
-        resize = styleResolver.settings().textAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
+        resize = styleResolver.settings().textAreasAreResizable() ? Resize::Both : Resize::None;
     else
         resize = primitiveValue;
 
@@ -1355,12 +1355,12 @@ inline StyleSelfAlignmentData StyleBuilderConverter::convertSelfOrDefaultAlignme
     auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
     if (Pair* pairValue = primitiveValue.pairValue()) {
         if (pairValue->first()->valueID() == CSSValueLegacy) {
-            alignmentData.setPositionType(LegacyPosition);
+            alignmentData.setPositionType(ItemPositionType::Legacy);
             alignmentData.setPosition(*pairValue->second());
         } else if (pairValue->first()->valueID() == CSSValueFirst) {
-            alignmentData.setPosition(ItemPositionBaseline);
+            alignmentData.setPosition(ItemPosition::Baseline);
         } else if (pairValue->first()->valueID() == CSSValueLast) {
-            alignmentData.setPosition(ItemPositionLastBaseline);
+            alignmentData.setPosition(ItemPosition::LastBaseline);
         } else {
             alignmentData.setOverflow(*pairValue->first());
             alignmentData.setPosition(*pairValue->second());
index a0ee59d..a74f931 100644 (file)
@@ -518,9 +518,9 @@ inline void StyleBuilderCustom::applyValueTextIndent(StyleResolver& styleResolve
             lengthOrPercentageValue = primitiveValue.convertToLength<FixedIntegerConversion | PercentConversion | CalculatedConversion>(styleResolver.state().cssToLengthConversionData());
 #if ENABLE(CSS3_TEXT)
         else if (primitiveValue.valueID() == CSSValueWebkitEachLine)
-            textIndentLineValue = TextIndentEachLine;
+            textIndentLineValue = TextIndentLine::EachLine;
         else if (primitiveValue.valueID() == CSSValueWebkitHanging)
-            textIndentTypeValue = TextIndentHanging;
+            textIndentTypeValue = TextIndentType::Hanging;
 #endif
     }
 
@@ -1058,7 +1058,7 @@ inline void StyleBuilderCustom::applyInitialWebkitAspectRatio(StyleResolver& sty
 
 inline void StyleBuilderCustom::applyInheritWebkitAspectRatio(StyleResolver& styleResolver)
 {
-    if (styleResolver.parentStyle()->aspectRatioType() == AspectRatioAuto)
+    if (styleResolver.parentStyle()->aspectRatioType() == AspectRatioType::Auto)
         return;
     styleResolver.style()->setAspectRatioType(styleResolver.parentStyle()->aspectRatioType());
     styleResolver.style()->setAspectRatioDenominator(styleResolver.parentStyle()->aspectRatioDenominator());
@@ -1071,16 +1071,16 @@ inline void StyleBuilderCustom::applyValueWebkitAspectRatio(StyleResolver& style
         auto& primitiveValue = downcast<CSSPrimitiveValue>(value);
 
         if (primitiveValue.valueID() == CSSValueFromDimensions)
-            return styleResolver.style()->setAspectRatioType(AspectRatioFromDimensions);
+            return styleResolver.style()->setAspectRatioType(AspectRatioType::FromDimensions);
         if (primitiveValue.valueID() == CSSValueFromIntrinsic)
-            return styleResolver.style()->setAspectRatioType(AspectRatioFromIntrinsic);
+            return styleResolver.style()->setAspectRatioType(AspectRatioType::FromIntrinsic);
 
         ASSERT(primitiveValue.valueID() == CSSValueAuto);
-        return styleResolver.style()->setAspectRatioType(AspectRatioAuto);
+        return styleResolver.style()->setAspectRatioType(AspectRatioType::Auto);
     }
 
     auto& aspectRatioValue = downcast<CSSAspectRatioValue>(value);
-    styleResolver.style()->setAspectRatioType(AspectRatioSpecified);
+    styleResolver.style()->setAspectRatioType(AspectRatioType::Specified);
     styleResolver.style()->setAspectRatioDenominator(aspectRatioValue.denominatorValue());
     styleResolver.style()->setAspectRatioNumerator(aspectRatioValue.numeratorValue());
 }
@@ -1436,19 +1436,19 @@ inline void StyleBuilderCustom::applyValueContent(StyleResolver& styleResolver,
         } else {
             switch (contentValue.valueID()) {
             case CSSValueOpenQuote:
-                styleResolver.style()->setContent(OPEN_QUOTE, didSet);
+                styleResolver.style()->setContent(QuoteType::OpenQuote, didSet);
                 didSet = true;
                 break;
             case CSSValueCloseQuote:
-                styleResolver.style()->setContent(CLOSE_QUOTE, didSet);
+                styleResolver.style()->setContent(QuoteType::CloseQuote, didSet);
                 didSet = true;
                 break;
             case CSSValueNoOpenQuote:
-                styleResolver.style()->setContent(NO_OPEN_QUOTE, didSet);
+                styleResolver.style()->setContent(QuoteType::NoOpenQuote, didSet);
                 didSet = true;
                 break;
             case CSSValueNoCloseQuote:
-                styleResolver.style()->setContent(NO_CLOSE_QUOTE, didSet);
+                styleResolver.style()->setContent(QuoteType::NoCloseQuote, didSet);
                 didSet = true;
                 break;
             default:
index 6bab457..f567416 100644 (file)
@@ -733,9 +733,9 @@ static bool doesNotInheritTextDecoration(const RenderStyle& style, const Element
 }
 
 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
-static bool isScrollableOverflow(EOverflow overflow)
+static bool isScrollableOverflow(Overflow overflow)
 {
-    return overflow == OSCROLL || overflow == OAUTO || overflow == OOVERLAY;
+    return overflow == Overflow::Scroll || overflow == Overflow::Auto || overflow == Overflow::Overlay;
 }
 #endif
 
@@ -851,7 +851,7 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
             if (document().inQuirksMode()) {
                 if (element->hasTagName(tdTag)) {
                     style.setDisplay(TABLE_CELL);
-                    style.setFloating(NoFloat);
+                    style.setFloating(Float::No);
                 } else if (is<HTMLTableElement>(*element))
                     style.setDisplay(style.isDisplayInlineType() ? INLINE_TABLE : TABLE);
             }
@@ -875,14 +875,14 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
             // Frames and framesets never honor position:relative or position:absolute. This is necessary to
             // fix a crash where a site tries to position these objects. They also never honor display.
             if (element->hasTagName(frameTag) || element->hasTagName(framesetTag)) {
-                style.setPosition(StaticPosition);
+                style.setPosition(PositionType::Static);
                 style.setDisplay(BLOCK);
             }
 
             // Ruby text does not support float or position. This might change with evolution of the specification.
             if (element->hasTagName(rtTag)) {
-                style.setPosition(StaticPosition);
-                style.setFloating(NoFloat);
+                style.setPosition(PositionType::Static);
+                style.setFloating(Float::No);
             }
 
             // User agents are expected to have a rule in their user agent stylesheet that matches th elements that have a parent
@@ -910,8 +910,8 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
         // on some sites).
         if ((style.display() == TABLE_HEADER_GROUP || style.display() == TABLE_ROW_GROUP
             || style.display() == TABLE_FOOTER_GROUP || style.display() == TABLE_ROW)
-            && style.position() == RelativePosition)
-            style.setPosition(StaticPosition);
+            && style.position() == PositionType::Relative)
+            style.setPosition(PositionType::Static);
 
         // writing-mode does not apply to table row groups, table column groups, table rows, and table columns.
         // FIXME: Table cells should be allowed to be perpendicular or flipped with respect to the table, though.
@@ -929,13 +929,13 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
         // https://www.w3.org/TR/css-display/#transformations
         // "A parent with a grid or flex display value blockifies the box’s display type."
         if (parentBoxStyle->isDisplayFlexibleOrGridBox()) {
-            style.setFloating(NoFloat);
+            style.setFloating(Float::No);
             style.setDisplay(equivalentBlockDisplay(style, document()));
         }
     }
 
     // Make sure our z-index value is only applied if the object is positioned.
-    if (style.position() == StaticPosition && !parentBoxStyle->isDisplayFlexibleOrGridBox())
+    if (style.position() == PositionType::Static && !parentBoxStyle->isDisplayFlexibleOrGridBox())
         style.setHasAutoZIndex();
 
     // Auto z-index becomes 0 for the root element and transparent objects. This prevents
@@ -954,8 +954,8 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
 #endif
             || style.hasBlendMode()
             || style.hasIsolation()
-            || style.position() == StickyPosition
-            || style.position() == FixedPosition
+            || style.position() == PositionType::Sticky
+            || style.position() == PositionType::Fixed
             || style.willChangeCreatesStackingContext())
             style.setZIndex(0);
     }
@@ -963,18 +963,18 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
     if (element) {
         // Textarea considers overflow visible as auto.
         if (is<HTMLTextAreaElement>(*element)) {
-            style.setOverflowX(style.overflowX() == OVISIBLE ? OAUTO : style.overflowX());
-            style.setOverflowY(style.overflowY() == OVISIBLE ? OAUTO : style.overflowY());
+            style.setOverflowX(style.overflowX() == Overflow::Visible ? Overflow::Auto : style.overflowX());
+            style.setOverflowY(style.overflowY() == Overflow::Visible ? Overflow::Auto : style.overflowY());
         }
 
         // Disallow -webkit-user-modify on :pseudo and ::pseudo elements.
         if (!element->shadowPseudoId().isNull())
-            style.setUserModify(READ_ONLY);
+            style.setUserModify(UserModify::ReadOnly);
 
         if (is<HTMLMarqueeElement>(*element)) {
             // For now, <marquee> requires an overflow clip to work properly.
-            style.setOverflowX(OHIDDEN);
-            style.setOverflowY(OHIDDEN);
+            style.setOverflowX(Overflow::Hidden);
+            style.setOverflowY(Overflow::Hidden);
 
             bool isVertical = style.marqueeDirection() == MarqueeDirection::Up || style.marqueeDirection() == MarqueeDirection::Down;
             // Make horizontal marquees not wrap.
@@ -994,34 +994,34 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
         style.addToTextDecorationsInEffect(style.textDecoration());
 
     // If either overflow value is not visible, change to auto.
-    if (style.overflowX() == OVISIBLE && style.overflowY() != OVISIBLE) {
+    if (style.overflowX() == Overflow::Visible && style.overflowY() != Overflow::Visible) {
         // FIXME: Once we implement pagination controls, overflow-x should default to hidden
         // if overflow-y is set to -webkit-paged-x or -webkit-page-y. For now, we'll let it
         // default to auto so we can at least scroll through the pages.
-        style.setOverflowX(OAUTO);
-    } else if (style.overflowY() == OVISIBLE && style.overflowX() != OVISIBLE)
-        style.setOverflowY(OAUTO);
+        style.setOverflowX(Overflow::Auto);
+    } else if (style.overflowY() == Overflow::Visible && style.overflowX() != Overflow::Visible)
+        style.setOverflowY(Overflow::Auto);
 
     // Call setStylesForPaginationMode() if a pagination mode is set for any non-root elements. If these
     // styles are specified on a root element, then they will be incorporated in
     // Style::createForDocument().
-    if ((style.overflowY() == OPAGEDX || style.overflowY() == OPAGEDY) && !(element && (element->hasTagName(htmlTag) || element->hasTagName(bodyTag))))
+    if ((style.overflowY() == Overflow::PagedX || style.overflowY() == Overflow::PagedY) && !(element && (element->hasTagName(htmlTag) || element->hasTagName(bodyTag))))
         style.setColumnStylesFromPaginationMode(WebCore::paginationModeForRenderStyle(style));
 
     // Table rows, sections and the table itself will support overflow:hidden and will ignore scroll/auto.
     // FIXME: Eventually table sections will support auto and scroll.
     if (style.display() == TABLE || style.display() == INLINE_TABLE
         || style.display() == TABLE_ROW_GROUP || style.display() == TABLE_ROW) {
-        if (style.overflowX() != OVISIBLE && style.overflowX() != OHIDDEN)
-            style.setOverflowX(OVISIBLE);
-        if (style.overflowY() != OVISIBLE && style.overflowY() != OHIDDEN)
-            style.setOverflowY(OVISIBLE);
+        if (style.overflowX() != Overflow::Visible && style.overflowX() != Overflow::Hidden)
+            style.setOverflowX(Overflow::Visible);
+        if (style.overflowY() != Overflow::Visible && style.overflowY() != Overflow::Hidden)
+            style.setOverflowY(Overflow::Visible);
     }
 
     // Menulists should have visible overflow
     if (style.appearance() == MenulistPart) {
-        style.setOverflowX(OVISIBLE);
-        style.setOverflowY(OVISIBLE);
+        style.setOverflowX(Overflow::Visible);
+        style.setOverflowY(Overflow::Visible);
     }
 
 #if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
@@ -1056,8 +1056,8 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
         style.setUnique();
 
     // FIXME: when dropping the -webkit prefix on transform-style, we should also have opacity < 1 cause flattening.
-    if (style.preserves3D() && (style.overflowX() != OVISIBLE
-        || style.overflowY() != OVISIBLE
+    if (style.preserves3D() && (style.overflowX() != Overflow::Visible
+        || style.overflowY() != Overflow::Visible
         || style.hasClip()
         || style.clipPath()
         || style.hasFilter()
@@ -1065,14 +1065,14 @@ void StyleResolver::adjustRenderStyle(RenderStyle& style, const RenderStyle& par
         || style.hasBackdropFilter()
 #endif
         || style.hasBlendMode()))
-        style.setTransformStyle3D(TransformStyle3DFlat);
+        style.setTransformStyle3D(TransformStyle3D::Flat);
 
     if (is<SVGElement>(element))
         adjustSVGElementStyle(downcast<SVGElement>(*element), style);
 
     // If the inherited value of justify-items includes the 'legacy' keyword (plus 'left', 'right' or
     // 'center'), 'legacy' computes to the the inherited value. Otherwise, 'auto' computes to 'normal'.
-    if (parentBoxStyle->justifyItems().positionType() == LegacyPosition && style.justifyItems().position() == ItemPositionLegacy)
+    if (parentBoxStyle->justifyItems().positionType() == ItemPositionType::Legacy && style.justifyItems().position() == ItemPosition::Legacy)
         style.setJustifyItems(parentBoxStyle->justifyItems());
 }
 
index 310b2e6..6d66a62 100644 (file)
@@ -418,7 +418,7 @@ public:
         bool m_hasUAAppearance { false };
 
         BorderData m_borderData;
-        FillLayer m_backgroundData { BackgroundFillLayer };
+        FillLayer m_backgroundData { FillLayerType::Background };
         Color m_backgroundColor;
 
         CSSToLengthConversionData m_cssToLengthConversionData;
index 8b3d1df..a8b46b0 100755 (executable)
@@ -576,8 +576,8 @@ sub getLayersAccessorFunction {
 sub getFillLayerType {
 my $name = shift;
 
-  return "BackgroundFillLayer" if $name =~ /background-/;
-  return "MaskFillLayer" if $name =~ /mask-/;
+  return "FillLayerType::Background" if $name =~ /background-/;
+  return "FillLayerType::Mask" if $name =~ /mask-/;
 }
 
 sub getFillLayerMapfunction {
index 1c4db86..dffdac7 100644 (file)
@@ -539,7 +539,7 @@ public:
     // This should be called whenever an element changes in a manner that can affect its style.
     void invalidateStyle();
 
-    // As above but also call RenderElement::setStyle with StyleDifferenceRecompositeLayer flag for
+    // As above but also call RenderElement::setStyle with StyleDifference::RecompositeLayer flag for
     // the element even when the style doesn't change. This is mostly needed by the animation code.
     WEBCORE_EXPORT void invalidateStyleAndLayerComposition();
 
index bba678a..4504e40 100644 (file)
@@ -685,17 +685,17 @@ static Node::Editability computeEditabilityFromComputedStyle(const Node& startNo
 #if ENABLE(USERSELECT_ALL)
         // Elements with user-select: all style are considered atomic
         // therefore non editable.
-        if (treatment == Node::UserSelectAllIsAlwaysNonEditable && style->userSelect() == SELECT_ALL)
+        if (treatment == Node::UserSelectAllIsAlwaysNonEditable && style->userSelect() == UserSelect::All)
             return Node::Editability::ReadOnly;
 #else
         UNUSED_PARAM(treatment);
 #endif
         switch (style->userModify()) {
-        case READ_ONLY:
+        case UserModify::ReadOnly:
             return Node::Editability::ReadOnly;
-        case READ_WRITE:
+        case UserModify::ReadWrite:
             return Node::Editability::CanEditRichly;
-        case READ_WRITE_PLAINTEXT_ONLY:
+        case UserModify::ReadWritePlaintextOnly:
             return Node::Editability::CanEditPlainText;
         }
         ASSERT_NOT_REACHED();
@@ -1070,7 +1070,7 @@ bool Node::canStartSelection() const
         const RenderStyle& style = renderer()->style();
         // We allow selections to begin within an element that has -webkit-user-select: none set,
         // but if the element is draggable then dragging should take priority over selection.
-        if (style.userDrag() == DRAG_ELEMENT && style.userSelect() == SELECT_NONE)
+        if (style.userDrag() == UserDrag::Element && style.userSelect() == UserSelect::None)
             return false;
     }
     return parentOrShadowHostNode() ? parentOrShadowHostNode()->canStartSelection() : true;
index 89a506f..0b0a518 100644 (file)
@@ -954,13 +954,13 @@ bool Position::hasRenderedNonAnonymousDescendantsWithHeight(const RenderElement&
 
 bool Position::nodeIsUserSelectNone(Node* node)
 {
-    return node && node->renderer() && node->renderer()->style().userSelect() == SELECT_NONE;
+    return node && node->renderer() && node->renderer()->style().userSelect() == UserSelect::None;
 }
 
 #if ENABLE(USERSELECT_ALL)
 bool Position::nodeIsUserSelectAll(const Node* node)
 {
-    return node && node->renderer() && node->renderer()->style().userSelect() == SELECT_ALL;
+    return node && node->renderer() && node->renderer()->style().userSelect() == UserSelect::All;
 }
 
 Node* Position::rootUserSelectAllForNode(Node* node)
index a57a5e2..dc1d666 100644 (file)
@@ -1310,7 +1310,7 @@ int Range::collectSelectionRectsWithoutUnionInteriorLines(Vector<SelectionRect>&
     for (Node* node = firstNode(); node && node != stopNode; node = NodeTraversal::next(*node)) {
         RenderObject* renderer = node->renderer();
         // Only ask leaf render objects for their line box rects.
-        if (renderer && !renderer->firstChildSlow() && renderer->style().userSelect() != SELECT_NONE) {
+        if (renderer && !renderer->firstChildSlow() && renderer->style().userSelect() != UserSelect::None) {
             bool isStartNode = renderer->node() == &startContainer;
             bool isEndNode = renderer->node() == &endContainer;
             if (hasFlippedWritingMode != renderer->style().isFlippedBlocksWritingMode())
index 89cd294..d72d0ca 100644 (file)
@@ -238,7 +238,7 @@ void ApplyBlockElementCommand::rangeForParagraphSplittingTextNodesIfNeeded(const
         }
 
         // If end is in the middle of a text node and the text node is editable, split.
-        if (endStyle->userModify() != READ_ONLY && !endStyle->collapseWhiteSpace() && end.offsetInContainerNode() && end.offsetInContainerNode() < end.containerNode()->maxCharacterOffset()) {
+        if (endStyle->userModify() != UserModify::ReadOnly && !endStyle->collapseWhiteSpace() && end.offsetInContainerNode() && end.offsetInContainerNode() < end.containerNode()->maxCharacterOffset()) {
             RefPtr<Text> endContainer = end.containerText();
             splitTextNode(*endContainer, end.offsetInContainerNode());
             if (isStartAndEndOnSameNode)
index 60967c2..1bc9b40 100644 (file)
@@ -900,7 +900,7 @@ void DeleteSelectionCommand::doApply()
         if (is<Text>(node)) {
             Text& textNode = downcast<Text>(*node);
             if (textNode.length() && textNode.renderer())
-                shouldRebalaceWhiteSpace = textNode.renderer()->style().textSecurity() == TSNONE;
+                shouldRebalaceWhiteSpace = textNode.renderer()->style().textSecurity() == TextSecurity::None;
         }        
     }
     if (shouldRebalaceWhiteSpace)
index e79b646..3abc4d9 100644 (file)
@@ -462,7 +462,7 @@ static bool isSpecialHTMLElement(const Node* node)
     if (renderer->style().isFloating())
         return true;
 
-    if (renderer->style().position() != StaticPosition)
+    if (renderer->style().position() != PositionType::Static)
         return true;
 
     return false;
index 3bf4213..6f1bc9f 100644 (file)
@@ -219,7 +219,7 @@ static unsigned verticalScrollDistance(Frame& frame)
     if (!is<RenderBox>(renderer))
         return 0;
     const RenderStyle& style = renderer->style();
-    if (!(style.overflowY() == OSCROLL || style.overflowY() == OAUTO || focusedElement->hasEditableStyle()))
+    if (!(style.overflowY() == Overflow::Scroll || style.overflowY() == Overflow::Auto || focusedElement->hasEditableStyle()))
         return 0;
     int height = std::min<int>(downcast<RenderBox>(*renderer).clientHeight(), frame.view()->visibleHeight());
     return static_cast<unsigned>(Scrollbar::pageStep(height));
index 9cb5276..8029333 100644 (file)
@@ -935,8 +935,8 @@ void ReplaceSelectionCommand::doApply()
         return;
     
     // We can skip matching the style if the selection is plain text.
-    if ((selection.start().deprecatedNode()->renderer() && selection.start().deprecatedNode()->renderer()->style().userModify() == READ_WRITE_PLAINTEXT_ONLY)
-        && (selection.end().deprecatedNode()->renderer() && selection.end().deprecatedNode()->renderer()->style().userModify() == READ_WRITE_PLAINTEXT_ONLY))
+    if ((selection.start().deprecatedNode()->renderer() && selection.start().deprecatedNode()->renderer()->style().userModify() == UserModify::ReadWritePlaintextOnly)
+        && (selection.end().deprecatedNode()->renderer() && selection.end().deprecatedNode()->renderer()->style().userModify() == UserModify::ReadWritePlaintextOnly))
         m_matchStyle = false;
     
     if (m_matchStyle) {
index d6676e3..eba3021 100644 (file)
@@ -79,8 +79,8 @@ void SimplifyMarkupCommand::doApply()
                 break;
             }
             
-            unsigned context;
-            if (currentNode->renderStyle()->diff(*startingStyle, context) == StyleDifferenceEqual)
+            OptionSet<StyleDifferenceContextSensitiveProperty> contextSensitiveProperties;
+            if (currentNode->renderStyle()->diff(*startingStyle, contextSensitiveProperties) == StyleDifference::Equal)
                 topNodeWithStartingStyle = currentNode;
             
         }
index cc17dd6..29b36d6 100644 (file)
@@ -510,7 +510,7 @@ unsigned backwardSearchForBoundaryWithTextIterator(SimplifiedBackwardsTextIterat
     unsigned next = 0;
     bool needMoreContext = false;
     while (!it.atEnd()) {
-        bool inTextSecurityMode = it.node() && it.node()->renderer() && it.node()->renderer()->style().textSecurity() != TSNONE;
+        bool inTextSecurityMode = it.node() && it.node()->renderer() && it.node()->renderer()->style().textSecurity() != TextSecurity::None;
         // iterate to get chunks until the searchFunction returns a non-zero value.
         if (!inTextSecurityMode)
             prepend(string, it.text());
@@ -540,7 +540,7 @@ unsigned forwardSearchForBoundaryWithTextIterator(TextIterator& it, Vector<UChar
     unsigned next = 0;
     bool needMoreContext = false;
     while (!it.atEnd()) {
-        bool inTextSecurityMode = it.node() && it.node()->renderer() && it.node()->renderer()->style().textSecurity() != TSNONE;
+        bool inTextSecurityMode = it.node() && it.node()->renderer() && it.node()->renderer()->style().textSecurity() != TextSecurity::None;
         // Keep asking the iterator for chunks until the search function
         // returns an end value not equal to the length of the string passed to it.
         if (!inTextSecurityMode)
index 6e2a0d6..d01daf3 100644 (file)
@@ -110,19 +110,19 @@ RetainPtr<NSDictionary> Editor::fontAttributesForSelectionStart() const
 
     int superscriptInt = 0;
     switch (style->verticalAlign()) {
-    case BASELINE:
-    case BOTTOM:
-    case BASELINE_MIDDLE:
-    case LENGTH:
-    case MIDDLE:
-    case TEXT_BOTTOM:
-    case TEXT_TOP:
-    case TOP:
+    case VerticalAlign::Baseline:
+    case VerticalAlign::Bottom:
+    case VerticalAlign::BaselineMiddle:
+    case VerticalAlign::Length:
+    case VerticalAlign::Middle:
+    case VerticalAlign::TextBottom:
+    case VerticalAlign::TextTop:
+    case VerticalAlign::Top:
         break;
-    case SUB:
+    case VerticalAlign::Sub:
         superscriptInt = -1;
         break;
-    case SUPER:
+    case VerticalAlign::Super:
         superscriptInt = 1;
         break;
     }
index 6b1397e..9e3f92b 100644 (file)
@@ -2523,7 +2523,7 @@ NSAttributedString *editingAttributedStringFromRange(Range& range, IncludeImages
             [attrs.get() removeObjectForKey:NSBackgroundColorAttributeName];
 
         RetainPtr<NSString> text;
-        if (style.nbspMode() == NBNORMAL)
+        if (style.nbspMode() == NBSPMode::Normal)
             text = it.text().createNSStringWithoutCopying();
         else
             text = it.text().toString().replace(noBreakSpace, ' ');
index 3978796..848eda5 100644 (file)
@@ -1974,7 +1974,7 @@ bool HTMLInputElement::shouldTruncateText(const RenderStyle& style) const
 {
     if (!isTextField())
         return false;
-    return document().focusedElement() != this && style.textOverflow() == TextOverflowEllipsis;
+    return document().focusedElement() != this && style.textOverflow() == TextOverflow::Ellipsis;
 }
 
 ExceptionOr<int> HTMLInputElement::selectionStartForBindings() const
@@ -2061,16 +2061,16 @@ RenderStyle HTMLInputElement::createInnerTextStyle(const RenderStyle& style)
     adjustInnerTextStyle(style, textBlockStyle);
 
     textBlockStyle.setWhiteSpace(PRE);
-    textBlockStyle.setOverflowWrap(NormalOverflowWrap);
-    textBlockStyle.setOverflowX(OHIDDEN);
-    textBlockStyle.setOverflowY(OHIDDEN);
-    textBlockStyle.setTextOverflow(shouldTruncateText(style) ? TextOverflowEllipsis : TextOverflowClip);
+    textBlockStyle.setOverflowWrap(OverflowWrap::Normal);
+    textBlockStyle.setOverflowX(Overflow::Hidden);
+    textBlockStyle.setOverflowY(Overflow::Hidden);
+    textBlockStyle.setTextOverflow(shouldTruncateText(style) ? TextOverflow::Ellipsis : TextOverflow::Clip);
 
     textBlockStyle.setDisplay(BLOCK);
 
     if (hasAutoFillStrongPasswordButton()) {
         textBlockStyle.setColor({ 0.0f, 0.0f, 0.0f, 0.6f });
-        textBlockStyle.setTextOverflow(TextOverflowClip);
+        textBlockStyle.setTextOverflow(TextOverflow::Clip);
         textBlockStyle.setMaskImage(styleResolver().styleImage(autoFillStrongPasswordMaskImage()));
         // A stacking context is needed for the mask.
         if (textBlockStyle.hasAutoZIndex())
index 58f91aa..0adef0f 100644 (file)
@@ -816,7 +816,7 @@ void HTMLTextFormControlElement::adjustInnerTextStyle(const RenderStyle& parentS
     if (isDisabledFormControl())
         textBlockStyle.setColor(RenderTheme::singleton().disabledTextColor(textBlockStyle.visitedDependentColorWithColorFilter(CSSPropertyColor), parentStyle.visitedDependentColorWithColorFilter(CSSPropertyBackgroundColor)));
 #if PLATFORM(IOS)
-    if (textBlockStyle.textSecurity() != TSNONE && !textBlockStyle.isLeftToRightDirection()) {
+    if (textBlockStyle.textSecurity() != TextSecurity::None && !textBlockStyle.isLeftToRightDirection()) {
         // Preserve the alignment but force the direction to LTR so that the last-typed, unmasked character
         // (which cannot have RTL directionality) will appear to the right of the masked characters. See <rdar://problem/7024375>.
         
index 8df02e4..6af9458 100644 (file)
@@ -165,7 +165,7 @@ void RenderSliderContainer::layout()
     ASSERT(element()->shadowHost());
     auto& input = downcast<HTMLInputElement>(*element()->shadowHost());
     bool isVertical = hasVerticalAppearance(input);
-    mutableStyle().setFlexDirection(isVertical ? FlowColumn : FlowRow);
+    mutableStyle().setFlexDirection(isVertical ? FlexDirection::Column : FlexDirection::Row);
     TextDirection oldTextDirection = style().direction();
     if (isVertical) {
         // FIXME: Work around rounding issues in RTL vertical sliders. We want them to
index 6822599..b79792f 100644 (file)
@@ -84,9 +84,9 @@ std::optional<ElementStyle> TextControlInnerContainer::resolveCustomStyle(const
 {
     auto elementStyle = resolveStyle(&parentStyle);
     if (isStrongPasswordTextField(shadowHost())) {
-        elementStyle.renderStyle->setFlexWrap(FlexWrap);
-        elementStyle.renderStyle->setOverflowX(OHIDDEN);
-        elementStyle.renderStyle->setOverflowY(OHIDDEN);
+        elementStyle.renderStyle->setFlexWrap(FlexWrap::Wrap);
+        elementStyle.renderStyle->setOverflowX(Overflow::Hidden);
+        elementStyle.renderStyle->setOverflowY(Overflow::Hidden);
     }
     return WTFMove(elementStyle);
 }
@@ -111,13 +111,13 @@ std::optional<ElementStyle> TextControlInnerElement::resolveCustomStyle(const Re
     newStyle->setDisplay(BLOCK);
     newStyle->setDirection(LTR);
     // We don't want the shadow DOM to be editable, so we set this block to read-only in case the input itself is editable.
-    newStyle->setUserModify(READ_ONLY);
+    newStyle->setUserModify(UserModify::ReadOnly);
 
     if (isStrongPasswordTextField(shadowHost())) {
         newStyle->setFlexShrink(0);
-        newStyle->setTextOverflow(TextOverflowClip);
-        newStyle->setOverflowX(OHIDDEN);
-        newStyle->setOverflowY(OHIDDEN);
+        newStyle->setTextOverflow(TextOverflow::Clip);
+        newStyle->setOverflowX(Overflow::Hidden);
+        newStyle->setOverflowY(Overflow::Hidden);
 
         // Set "flex-basis: 1em". Note that CSSPrimitiveValue::computeLengthInt() only needs the element's
         // style to calculate em lengths. Since the element might not be in a document, just pass nullptr
@@ -201,7 +201,7 @@ std::optional<ElementStyle> TextControlPlaceholderElement::resolveCustomStyle(co
 
     if (is<HTMLInputElement>(controlElement)) {
         auto& inputElement = downcast<HTMLInputElement>(controlElement);
-        style.renderStyle->setTextOverflow(inputElement.shouldTruncateText(*shadowHostStyle) ? TextOverflowEllipsis : TextOverflowClip);
+        style.renderStyle->setTextOverflow(inputElement.shouldTruncateText(*shadowHostStyle) ? TextOverflow::Ellipsis : TextOverflow::Clip);
     }
     return WTFMove(style);
 }
index eb97a0b..f8bfdb4 100644 (file)
@@ -66,7 +66,7 @@ LayoutRect Box::marginBox() const
 
 LayoutRect Box::borderBox() const
 {
-    if (m_style.boxSizing == BORDER_BOX)
+    if (m_style.boxSizing == BoxSizing::BorderBox)
         return LayoutRect( { }, size());
 
     // Width is content box.
@@ -92,7 +92,7 @@ LayoutRect Box::paddingBox() const
 
 LayoutRect Box::contentBox() const
 {
-    if (m_style.boxSizing == CONTENT_BOX)
+    if (m_style.boxSizing == BoxSizing::ContentBox)
         return LayoutRect(LayoutPoint(0, 0), size());
 
     // Width is border box.
index 83f8119..b178bd4 100644 (file)
@@ -94,7 +94,7 @@ private:
     struct Style {
         Style(const RenderStyle&);
 
-        EBoxSizing boxSizing { CONTENT_BOX };
+        BoxSizing boxSizing { BoxSizing::ContentBox };
     };
 
     void setRect(const LayoutRect&);
index 44797af..0d15fdf 100644 (file)
@@ -72,27 +72,27 @@ bool Box::establishesBlockFormattingContext() const
 
 bool Box::isRelativelyPositioned() const
 {
-    return m_style.position() == RelativePosition;
+    return m_style.position() == PositionType::Relative;
 }
 
 bool Box::isStickyPositioned() const
 {
-    return m_style.position() == StickyPosition;
+    return m_style.position() == PositionType::Sticky;
 }
 
 bool Box::isAbsolutelyPositioned() const
 {
-    return m_style.position() == AbsolutePosition;
+    return m_style.position() == PositionType::Absolute;
 }
 
 bool Box::isFixedPositioned() const
 {
-    return m_style.position() == FixedPosition;
+    return m_style.position() == PositionType::Fixed;
 }
 
 bool Box::isFloatingPositioned() const
 {
-    return m_style.floating() != NoFloat;
+    return m_style.floating() != Float::No;
 }
 
 const Container* Box::containingBlock() const
@@ -221,7 +221,7 @@ const Box* Box::previousInFlowOrFloatingSibling() const
 
 bool Box::isOverflowVisible() const
 {
-    return m_style.overflowX() == OVISIBLE || m_style.overflowY() == OVISIBLE;
+    return m_style.overflowX() == Overflow::Visible || m_style.overflowY() == Overflow::Visible;
 }
 
 }
index 4705550..6eb63bb 100644 (file)
@@ -761,12 +761,12 @@ Element* DragController::draggableElement(const Frame* sourceFrame, Element* sta
         if (!renderer)
             continue;
 
-        EUserDrag dragMode = renderer->style().userDrag();
-        if ((m_dragSourceAction & DragSourceActionDHTML) && dragMode == DRAG_ELEMENT) {
+        UserDrag dragMode = renderer->style().userDrag();
+        if ((m_dragSourceAction & DragSourceActionDHTML) && dragMode == UserDrag::Element) {
             state.type = static_cast<DragSourceAction>(state.type | DragSourceActionDHTML);
             return element;
         }
-        if (dragMode == DRAG_AUTO) {
+        if (dragMode == UserDrag::Auto) {
             if ((m_dragSourceAction & DragSourceActionImage)
                 && is<HTMLImageElement>(*element)
                 && imageElementIsDraggable(downcast<HTMLImageElement>(*element), *sourceFrame)) {
index ab0a8ce..63bf386 100644 (file)
@@ -883,7 +883,7 @@ RefPtr<Range> Frame::rangeForPoint(const IntPoint& framePoint)
 
     Position deepPosition = position.deepEquivalent();
     Text* containerText = deepPosition.containerText();
-    if (!containerText || !containerText->renderer() || containerText->renderer()->style().userSelect() == SELECT_NONE)
+    if (!containerText || !containerText->renderer() || containerText->renderer()->style().userSelect() == UserSelect::None)
         return nullptr;
 
     VisiblePosition previous = position.previous();
index bcaeeca..d21a4e0 100644 (file)
@@ -143,8 +143,8 @@ static RenderLayer::UpdateLayerPositionsFlags updateLayerPositionFlags(RenderLay
 
 Pagination::Mode paginationModeForRenderStyle(const RenderStyle& style)
 {
-    EOverflow overflow = style.overflowY();
-    if (overflow != OPAGEDX && overflow != OPAGEDY)
+    Overflow overflow = style.overflowY();
+    if (overflow != Overflow::PagedX && overflow != Overflow::PagedY)
         return Pagination::Unpaginated;
 
     bool isHorizontalWritingMode = style.isHorizontalWritingMode();
@@ -154,7 +154,7 @@ Pagination::Mode paginationModeForRenderStyle(const RenderStyle& style)
     // paged-x always corresponds to LeftToRightPaginated or RightToLeftPaginated. If the WritingMode
     // is horizontal, then we use TextDirection to choose between those options. If the WritingMode
     // is vertical, then the direction of the verticality dictates the choice.
-    if (overflow == OPAGEDX) {
+    if (overflow == Overflow::PagedX) {
         if ((isHorizontalWritingMode && textDirection == LTR) || writingMode == LeftToRightWritingMode)
             return Pagination::LeftToRightPaginated;
         return Pagination::RightToLeftPaginated;
@@ -650,52 +650,52 @@ void FrameView::applyOverflowToViewport(const RenderElement& renderer, Scrollbar
 
     bool overrideHidden = frame().isMainFrame() && ((frame().frameScaleFactor() > 1) || headerHeight() || footerHeight());
 
-    EOverflow overflowX = renderer.style().overflowX();
-    EOverflow overflowY = renderer.style().overflowY();
+    Overflow overflowX = renderer.style().overflowX();
+    Overflow overflowY = renderer.style().overflowY();
 
     if (is<RenderSVGRoot>(renderer)) {
         // FIXME: evaluate if we can allow overflow for these cases too.
         // Overflow is always hidden when stand-alone SVG documents are embedded.
         if (downcast<RenderSVGRoot>(renderer).isEmbeddedThroughFrameContainingSVGDocument()) {
-            overflowX = OHIDDEN;
-            overflowY = OHIDDEN;
+            overflowX = Overflow::Hidden;
+            overflowY = Overflow::Hidden;
         }
     }
 
     switch (overflowX) {
-        case OHIDDEN:
-            if (overrideHidden)
-                hMode = ScrollbarAuto;
-            else
-                hMode = ScrollbarAlwaysOff;
-            break;
-        case OSCROLL:
-            hMode = ScrollbarAlwaysOn;
-            break;
-        case OAUTO:
+    case Overflow::Hidden:
+        if (overrideHidden)
             hMode = ScrollbarAuto;
-            break;
-        default:
-            // Don't set it at all.
-            ;
+        else
+            hMode = ScrollbarAlwaysOff;
+        break;
+    case Overflow::Scroll:
+        hMode = ScrollbarAlwaysOn;
+        break;
+    case Overflow::Auto:
+        hMode = ScrollbarAuto;
+        break;
+    default:
+        // Don't set it at all.
+        ;
     }
-    
-     switch (overflowY) {
-        case OHIDDEN:
-            if (overrideHidden)
-                vMode = ScrollbarAuto;
-            else
-                vMode = ScrollbarAlwaysOff;
-            break;
-        case OSCROLL:
-            vMode = ScrollbarAlwaysOn;
-            break;
-        case OAUTO:
+
+    switch (overflowY) {
+    case Overflow::Hidden:
+        if (overrideHidden)
             vMode = ScrollbarAuto;
-            break;
-        default:
-            // Don't set it at all. Values of OPAGEDX and OPAGEDY are handled by applyPaginationToViewPort().
-            ;
+        else
+            vMode = ScrollbarAlwaysOff;
+        break;
+    case Overflow::Scroll:
+        vMode = ScrollbarAlwaysOn;
+        break;
+    case Overflow::Auto:
+        vMode = ScrollbarAuto;
+        break;
+    default:
+        // Don't set it at all. Values of Overflow::PagedX and Overflow::PagedY are handled by applyPaginationToViewPort().
+        ;
     }
 }
 
@@ -713,13 +713,13 @@ void FrameView::applyPaginationToViewport()
 
     auto* body = document->body();
     if (body && body->renderer()) {
-        documentOrBodyRenderer = documentRenderer.style().overflowX() == OVISIBLE && is<HTMLHtmlElement>(*documentElement) ?
+        documentOrBodyRenderer = documentRenderer.style().overflowX() == Overflow::Visible && is<HTMLHtmlElement>(*documentElement) ?
             body->renderer() : &documentRenderer;
     }
 
     Pagination pagination;
-    EOverflow overflowY = documentOrBodyRenderer->style().overflowY();
-    if (overflowY == OPAGEDX || overflowY == OPAGEDY) {
+    Overflow overflowY = documentOrBodyRenderer->style().overflowY();
+    if (overflowY == Overflow::PagedX || overflowY == Overflow::PagedY) {
         pagination.mode = WebCore::paginationModeForRenderStyle(documentOrBodyRenderer->style());
         GapLength columnGapLength = documentOrBodyRenderer->style().columnGap();
         pagination.gap = 0;
@@ -780,7 +780,7 @@ void FrameView::calculateScrollbarModesForLayout(ScrollbarMode& hMode, Scrollbar
     if (is<HTMLBodyElement>(*bodyOrFrameset) && rootRenderer) {
         // It's sufficient to just check the X overflow,
         // since it's illegal to have visible in only one direction.
-        if (rootRenderer->style().overflowX() == OVISIBLE && is<HTMLHtmlElement>(documentElement)) {
+        if (rootRenderer->style().overflowX() == Overflow::Visible && is<HTMLHtmlElement>(documentElement)) {
             auto* bodyRenderer = bodyOrFrameset->renderer();
             if (bodyRenderer) {
                 applyOverflowToViewport(*bodyRenderer, hMode, vMode);
@@ -2987,9 +2987,9 @@ FrameView::ExtendedBackgroundMode FrameView::calculateExtendedBackgroundMode() c
         return ExtendedBackgroundModeNone;
 
     ExtendedBackgroundMode mode = ExtendedBackgroundModeNone;
-    if (rootBackgroundRenderer->style().backgroundRepeatX() == RepeatFill)
+    if (rootBackgroundRenderer->style().backgroundRepeatX() == FillRepeat::Repeat)
         mode |= ExtendedBackgroundModeHorizontal;
-    if (rootBackgroundRenderer->style().backgroundRepeatY() == RepeatFill)
+    if (rootBackgroundRenderer->style().backgroundRepeatY() == FillRepeat::Repeat)
         mode |= ExtendedBackgroundModeVertical;
 
     return mode;
@@ -3604,7 +3604,7 @@ float FrameView::adjustScrollStepForFixedContent(float step, ScrollbarOrientatio
     float bottomObscuredArea = 0;
     for (const auto& positionedObject : *positionedObjects) {
         const RenderStyle& style = positionedObject->style();
-        if (style.position() != FixedPosition || style.visibility() == HIDDEN || !style.opacity())
+        if (style.position() != PositionType::Fixed || style.visibility() == HIDDEN || !style.opacity())
             continue;
 
         FloatQuad contentQuad = positionedObject->absoluteContentQuad();
index 465c35b..763aea5 100644 (file)
@@ -454,13 +454,13 @@ bool canScrollInDirection(const Node* container, FocusDirection direction)
 
     switch (direction) {
     case FocusDirectionLeft:
-        return (container->renderer()->style().overflowX() != OHIDDEN && container->renderBox()->scrollLeft() > 0);
+        return (container->renderer()->style().overflowX() != Overflow::Hidden && container->renderBox()->scrollLeft() > 0);
     case FocusDirectionUp:
-        return (container->renderer()->style().overflowY() != OHIDDEN && container->renderBox()->scrollTop() > 0);
+        return (container->renderer()->style().overflowY() != Overflow::Hidden && container->renderBox()->scrollTop() > 0);
     case FocusDirectionRight:
-        return (container->renderer()->style().overflowX() != OHIDDEN && container->renderBox()->scrollLeft() + container->renderBox()->clientWidth() < container->renderBox()->scrollWidth());
+        return (container->renderer()->style().overflowX() != Overflow::Hidden && container->renderBox()->scrollLeft() + container->renderBox()->clientWidth() < container->renderBox()->scrollWidth());
     case FocusDirectionDown:
-        return (container->renderer()->style().overflowY() != OHIDDEN && container->renderBox()->scrollTop() + container->renderBox()->clientHeight() < container->renderBox()->scrollHeight());
+        return (container->renderer()->style().overflowY() != Overflow::Hidden && container->renderBox()->scrollTop() + container->renderBox()->clientHeight() < container->renderBox()->scrollHeight());
     default:
         ASSERT_NOT_REACHED();
         return false;
@@ -707,8 +707,8 @@ bool canBeScrolledIntoView(FocusDirection direction, const FocusCandidate& candi
     for (Node* parentNode = candidate.visibleNode->parentNode(); parentNode; parentNode = parentNode->parentNode()) {
         LayoutRect parentRect = nodeRectInAbsoluteCoordinates(parentNode);
         if (!candidateRect.intersects(parentRect)) {
-            if (((direction == FocusDirectionLeft || direction == FocusDirectionRight) && parentNode->renderer()->style().overflowX() == OHIDDEN)
-                || ((direction == FocusDirectionUp || direction == FocusDirectionDown) && parentNode->renderer()->style().overflowY() == OHIDDEN))
+            if (((direction == FocusDirectionLeft || direction == FocusDirectionRight) && parentNode->renderer()->style().overflowX() == Overflow::Hidden)
+                || ((direction == FocusDirectionUp || direction == FocusDirectionDown) && parentNode->renderer()->style().overflowY() == Overflow::Hidden))
                 return false;
         }
         if (parentNode == candidate.enclosingScrollableBox)
index e1b0185..3213c2b 100644 (file)
@@ -468,8 +468,8 @@ Node* Frame::nodeRespondingToScrollWheelEvents(const FloatPoint& viewportLocatio
             auto& style = renderer->style();
 
             if (renderer->hasOverflowClip()
-                && (style.overflowY() == OAUTO || style.overflowY() == OSCROLL || style.overflowY() == OOVERLAY
-                || style.overflowX() == OAUTO || style.overflowX() == OSCROLL || style.overflowX() == OOVERLAY)) {
+                && (style.overflowY() == Overflow::Auto || style.overflowY() == Overflow::Scroll || style.overflowY() == Overflow::Overlay
+                || style.overflowX() == Overflow::Auto || style.overflowX() == Overflow::Scroll || style.overflowX() == Overflow::Overlay)) {
                 scrollingAncestor = node;
             }
         }
index 468f457..830c303 100644 (file)
@@ -821,7 +821,7 @@ static bool scrolledToEdgeInDominantDirection(const ContainerNode& container, co
     const RenderStyle& style = container.renderer()->style();
 
     if (!deltaIsPredominantlyVertical(deltaX, deltaY) && deltaX) {
-        if (style.overflowX() == OHIDDEN)
+        if (style.overflowX() == Overflow::Hidden)
             return true;
 
         if (deltaX < 0)
@@ -830,7 +830,7 @@ static bool scrolledToEdgeInDominantDirection(const ContainerNode& container, co
         return area.scrolledToLeft();
     }
 
-    if (style.overflowY() == OHIDDEN)
+    if (style.overflowY() == Overflow::Hidden)
         return true;
 
     if (deltaY < 0)
index 1f60c5c..bb30f3d 100644 (file)
@@ -33,7 +33,7 @@
 
 namespace WebCore {
 
-BorderEdge::BorderEdge(float edgeWidth, Color edgeColor, EBorderStyle edgeStyle, bool edgeIsTransparent, bool edgeIsPresent, float devicePixelRatio)
+BorderEdge::BorderEdge(float edgeWidth, Color edgeColor, BorderStyle edgeStyle, bool edgeIsTransparent, bool edgeIsPresent, float devicePixelRatio)
     : m_width(edgeWidth)
     , m_color(edgeColor)
     , m_style(edgeStyle)
@@ -41,8 +41,8 @@ BorderEdge::BorderEdge(float edgeWidth, Color edgeColor, EBorderStyle edgeStyle,
     , m_isPresent(edgeIsPresent)
     , m_devicePixelRatio(devicePixelRatio)
 {
-    if (edgeStyle == DOUBLE && edgeWidth  < borderWidthInDevicePixel(3))
-        m_style = SOLID;
+    if (edgeStyle == BorderStyle::Double && edgeWidth  < borderWidthInDevicePixel(3))
+        m_style = BorderStyle::Solid;
     m_flooredToDevicePixelWidth = floorf(edgeWidth * devicePixelRatio) / devicePixelRatio;
 }
 
@@ -62,13 +62,13 @@ void BorderEdge::getBorderEdgeInfo(BorderEdge edges[], const RenderStyle& style,
 
 bool BorderEdge::obscuresBackgroundEdge(float scale) const
 {
-    if (!m_isPresent || m_isTransparent || (m_width * scale) < borderWidthInDevicePixel(2) || !m_color.isOpaque() || m_style == BHIDDEN)
+    if (!m_isPresent || m_isTransparent || (m_width * scale) < borderWidthInDevicePixel(2) || !m_color.isOpaque() || m_style == BorderStyle::Hidden)
         return false;
 
-    if (m_style == DOTTED || m_style == DASHED)
+    if (m_style == BorderStyle::Dotted || m_style == BorderStyle::Dashed)
         return false;
 
-    if (m_style == DOUBLE)
+    if (m_style == BorderStyle::Double)
         return m_width >= scale * borderWidthInDevicePixel(5); // The outer band needs to be >= 2px wide at unit scale.
 
     return true;
@@ -76,10 +76,10 @@ bool BorderEdge::obscuresBackgroundEdge(float scale) const
 
 bool BorderEdge::obscuresBackground() const
 {
-    if (!m_isPresent || m_isTransparent || !m_color.isOpaque() || m_style == BHIDDEN)
+    if (!m_isPresent || m_isTransparent || !m_color.isOpaque() || m_style == BorderStyle::Hidden)
         return false;
 
-    if (m_style == DOTTED || m_style == DASHED || m_style == DOUBLE)
+    if (m_style == BorderStyle::Dotted || m_style == BorderStyle::Dashed || m_style == BorderStyle::Double)
         return false;
 
     return true;
index f439f58..782cad9 100644 (file)
@@ -47,16 +47,16 @@ public:
     };
 
     BorderEdge() = default;
-    BorderEdge(float edgeWidth, Color edgeColor, EBorderStyle edgeStyle, bool edgeIsTransparent, bool edgeIsPresent, float devicePixelRatio);
+    BorderEdge(float edgeWidth, Color edgeColor, BorderStyle edgeStyle, bool edgeIsTransparent, bool edgeIsPresent, float devicePixelRatio);
 
     static void getBorderEdgeInfo(BorderEdge edges[], const RenderStyle&, float deviceScaleFactor, bool includeLogicalLeftEdge = true, bool includeLogicalRightEdge = true);
 
-    EBorderStyle style() const { return m_style; }
+    BorderStyle style() const { return m_style; }
     const Color& color() const { return m_color; }
     bool isTransparent() const { return m_isTransparent; }
     bool isPresent() const { return m_isPresent; }
 
-    inline bool hasVisibleColorAndStyle() const { return m_style > BHIDDEN && !m_isTransparent; }
+    inline bool hasVisibleColorAndStyle() const { return m_style > BorderStyle::Hidden && !m_isTransparent; }
     inline bool shouldRender() const { return m_isPresent && widthForPainting() && hasVisibleColorAndStyle(); }
     inline bool presentButInvisible() const { return widthForPainting() && !hasVisibleColorAndStyle(); }
     inline float widthForPainting() const { return m_isPresent ?  m_flooredToDevicePixelWidth : 0; }
@@ -69,7 +69,7 @@ private:
 
     LayoutUnit m_width;
     Color m_color;
-    EBorderStyle m_style { BHIDDEN };
+    BorderStyle m_style { BorderStyle::Hidden };
     bool m_isTransparent { false };
     bool m_isPresent { false };
     float m_flooredToDevicePixelWidth { 0 };
index 4289200..9416919 100644 (file)
@@ -78,7 +78,7 @@ public:
     bool computeNextFlexLine(size_t& nextIndex, Vector<FlexItem>& lineItems, LayoutUnit& sumFlexBaseSize, double& totalFlexGrow, double& totalFlexShrink, double& totalWeightedFlexShrink, LayoutUnit& sumHypotheticalMainSize);
 
 private:
-    bool isMultiline() const { return m_style.flexWrap() != FlexNoWrap; }
+    bool isMultiline() const { return m_style.flexWrap() != FlexWrap::NoWrap; }
 
     const RenderStyle& m_style;
     LayoutUnit m_lineBreakLength;
index f576dcf..3f7db1b 100644 (file)
@@ -51,11 +51,11 @@ FloatingObject::FloatingObject(RenderBox& renderer)
     , m_isInPlacedTree(false)
 #endif
 {
-    EFloat type = renderer.style().floating();
-    ASSERT(type != NoFloat);
-    if (type == LeftFloat)
+    Float type = renderer.style().floating();
+    ASSERT(type != Float::No);
+    if (type == Float::Left)
         m_type = FloatLeft;
-    else if (type == RightFloat)
+    else if (type == Float::Right)
         m_type = FloatRight;
 }
 
index 7d49e04..6543b3e 100644 (file)
@@ -745,7 +745,7 @@ LayoutUnit GridTrackSizingAlgorithmStrategy::minSizeForChild(RenderBox& child) c
     const Length& childMinSize = isRowAxis ? child.style().logicalMinWidth() : child.style().logicalMinHeight();
     const Length& childSize = isRowAxis ? child.style().logicalWidth() : child.style().logicalHeight();
 
-    bool overflowIsVisible = isRowAxis ? child.style().overflowInlineDirection() == OVISIBLE : child.style().overflowBlockDirection() == OVISIBLE;
+    bool overflowIsVisible = isRowAxis ? child.style().overflowInlineDirection() == Overflow::Visible : child.style().overflowBlockDirection() == Overflow::Visible;
     if (childSize.isAuto() && childMinSize.isAuto() && overflowIsVisible) {
         auto minSize = minContentForChild(child);
         LayoutUnit maxBreadth;
@@ -1070,7 +1070,7 @@ void GridTrackSizingAlgorithm::stretchAutoTracks()
 {
     auto currentFreeSpace = m_strategy->freeSpaceForStretchAutoTracksStep();
     if (m_autoSizedTracksForStretchIndex.isEmpty() || currentFreeSpace <= 0
-        || (m_renderGrid->contentAlignment(m_direction).distribution() != ContentDistributionStretch))
+        || (m_renderGrid->contentAlignment(m_direction).distribution() != ContentDistribution::Stretch))
         return;
 
     Vector<GridTrack>& allTracks = tracks(m_direction);
index 00e1b13..c091d8d 100644 (file)
@@ -277,7 +277,7 @@ String HitTestResult::innerTextIfTruncated(TextDirection& dir) const
         if (auto renderer = downcast<Element>(*truncatedNode).renderer()) {
             if (is<RenderBlockFlow>(*renderer)) {
                 RenderBlockFlow& block = downcast<RenderBlockFlow>(*renderer);
-                if (block.style().textOverflow()) {
+                if (block.style().textOverflow() == TextOverflow::Ellipsis) {
                     for (RootInlineBox* line = block.firstRootBox(); line; line = line->nextRootBox()) {
                         if (line->hasEllipsisBox()) {
                             dir = block.style().direction();
index 75415d0..f3dbef9 100644 (file)
@@ -100,14 +100,14 @@ void ImageQualityController::restartTimer()
 std::optional<InterpolationQuality> ImageQualityController::interpolationQualityFromStyle(const RenderStyle& style)
 {
     switch (style.imageRendering()) {
-    case ImageRenderingOptimizeSpeed:
+    case ImageRendering::OptimizeSpeed:
         return InterpolationLow;
-    case ImageRenderingCrispEdges:
-    case ImageRenderingPixelated:
+    case ImageRendering::CrispEdges:
+    case ImageRendering::Pixelated:
         return InterpolationNone;
-    case ImageRenderingOptimizeQuality:
+    case ImageRendering::OptimizeQuality:
         return InterpolationDefault; // FIXME: CSS 3 Images says that optimizeQuality should behave like 'auto', but that prevents authors from overriding this low quality rendering behavior.
-    case ImageRenderingAuto:
+    case ImageRendering::Auto:
         break;
     }
     return std::nullopt;
index e93e936..0d00e3e 100644 (file)
@@ -245,7 +245,7 @@ public:
 
     const RenderStyle& lineStyle() const { return m_bitfields.firstLine() ? renderer().firstLineStyle() : renderer().style(); }
     
-    EVerticalAlign verticalAlign() const { return lineStyle().verticalAlign(); }
+    VerticalAlign verticalAlign() const { return lineStyle().verticalAlign(); }
 
     // Use with caution! The type is not checked!
     RenderBoxModelObject* boxModelObject() const
index 5f6d66d..1db82be 100644 (file)
@@ -126,7 +126,7 @@ void InlineFlowBox::addToLine(InlineBox* child)
             if (child->renderer().isLineBreak() || child->renderer().parent() != &renderer()) {
                 if (!parentStyle.fontCascade().fontMetrics().hasIdenticalAscentDescentAndLineGap(childStyle.fontCascade().fontMetrics())
                     || parentStyle.lineHeight() != childStyle.lineHeight()
-                    || (parentStyle.verticalAlign() != BASELINE && !isRootInlineBox()) || childStyle.verticalAlign() != BASELINE)
+                    || (parentStyle.verticalAlign() != VerticalAlign::Baseline && !isRootInlineBox()) || childStyle.verticalAlign() != VerticalAlign::Baseline)
                     shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
             }
             if (childStyle.hasTextCombine() || childStyle.textEmphasisMark() != TextEmphasisMarkNone)
@@ -142,7 +142,7 @@ void InlineFlowBox::addToLine(InlineBox* child)
                 if (!childFlowBox.descendantsHaveSameLineHeightAndBaseline()
                     || !parentStyle.fontCascade().fontMetrics().hasIdenticalAscentDescentAndLineGap(childStyle.fontCascade().fontMetrics())
                     || parentStyle.lineHeight() != childStyle.lineHeight()
-                    || (parentStyle.verticalAlign() != BASELINE && !isRootInlineBox()) || childStyle.verticalAlign() != BASELINE
+                    || (parentStyle.verticalAlign() != VerticalAlign::Baseline && !isRootInlineBox()) || childStyle.verticalAlign() != VerticalAlign::Baseline
                     || childStyle.hasBorder() || childStyle.hasPadding() || childStyle.hasTextCombine())
                     shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
             }
@@ -313,7 +313,7 @@ void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, bool isLogically
         const auto& lineBoxList = inlineFlow.lineBoxes();
         if (!lineBoxList.firstLineBox()->isConstructed() && !inlineFlow.isContinuation()) {
 #if ENABLE(CSS_BOX_DECORATION_BREAK)
-            if (renderer().style().boxDecorationBreak() == DCLONE)
+            if (renderer().style().boxDecorationBreak() == BoxDecorationBreak::Clone)
                 includeLeftEdge = includeRightEdge = true;
             else
 #endif
@@ -332,7 +332,7 @@ void InlineFlowBox::determineSpacingForFlowBoxes(bool lastLine, bool isLogically
             // (3) The logicallyLastRun is a descendant of this renderer, but it is the last child of this renderer and it does not wrap to the next line.
 #if ENABLE(CSS_BOX_DECORATION_BREAK)
             // (4) The decoration break is set to clone therefore there will be borders on every sides.
-            if (renderer().style().boxDecorationBreak() == DCLONE)
+            if (renderer().style().boxDecorationBreak() == BoxDecorationBreak::Clone)
                 includeLeftEdge = includeRightEdge = true;
             else
 #endif
@@ -492,9 +492,9 @@ void InlineFlowBox::adjustMaxAscentAndDescent(int& maxAscent, int& maxDescent, i
         if (child->renderer().isOutOfFlowPositioned())
             continue; // Positioned placeholders don't affect calculations.
 
-        if ((child->verticalAlign() == TOP || child->verticalAlign() == BOTTOM) && verticalAlignApplies(child->renderer())) {
+        if ((child->verticalAlign() == VerticalAlign::Top || child->verticalAlign() == VerticalAlign::Bottom) && verticalAlignApplies(child->renderer())) {
             int lineHeight = child->lineHeight();
-            if (child->verticalAlign() == TOP) {
+            if (child->verticalAlign() == VerticalAlign::Top) {
                 if (maxAscent + maxDescent < lineHeight)
                     maxDescent = lineHeight - maxAscent;
             }
@@ -575,10 +575,10 @@ void InlineFlowBox::computeLogicalBoxHeights(RootInlineBox& rootBox, LayoutUnit&
         rootBox.ascentAndDescentForBox(*child, textBoxDataMap, ascent, descent, affectsAscent, affectsDescent);
 
         LayoutUnit boxHeight = ascent + descent;
-        if (child->verticalAlign() == TOP && verticalAlignApplies(child->renderer())) {
+        if (child->verticalAlign() == VerticalAlign::Top && verticalAlignApplies(child->renderer())) {
             if (maxPositionTop < boxHeight)
                 maxPositionTop = boxHeight;
-        } else if (child->verticalAlign() == BOTTOM && verticalAlignApplies(child->renderer())) {
+        } else if (child->verticalAlign() == VerticalAlign::Bottom && verticalAlignApplies(child->renderer())) {
             if (maxPositionBottom < boxHeight)
                 maxPositionBottom = boxHeight;
         } else if (!inlineFlowBox || strictMode || inlineFlowBox->hasTextChildren() || (inlineFlowBox->descendantsHaveSameLineHeightAndBaseline() && inlineFlowBox->hasTextDescendants())
@@ -639,9 +639,9 @@ void InlineFlowBox::placeBoxesInBlockDirection(LayoutUnit top, LayoutUnit maxHei
         InlineFlowBox* inlineFlowBox = is<InlineFlowBox>(*child) ? downcast<InlineFlowBox>(child) : nullptr;
         bool childAffectsTopBottomPos = true;
 
-        if (child->verticalAlign() == TOP && verticalAlignApplies(child->renderer()))
+        if (child->verticalAlign() == VerticalAlign::Top && verticalAlignApplies(child->renderer()))
             child->setLogicalTop(top);
-        else if (child->verticalAlign() == BOTTOM && verticalAlignApplies(child->renderer()))
+        else if (child->verticalAlign() == VerticalAlign::Bottom && verticalAlignApplies(child->renderer()))
             child->setLogicalTop(top + maxHeight - child->lineHeight());
         else {
             if (!strictMode && inlineFlowBox && !inlineFlowBox->hasTextChildren() && !inlineFlowBox->renderer().hasInlineDirectionBordersOrPadding()
@@ -1236,7 +1236,7 @@ void InlineFlowBox::paintFillLayer(const PaintInfo& paintInfo, const Color& colo
     if ((!hasFillImage && !renderer().style().hasBorderRadius()) || (!prevLineBox() && !nextLineBox()) || !parent())
         renderer().paintFillLayerExtended(paintInfo, color, fillLayer, rect, BackgroundBleedNone, this, rect.size(), op);
 #if ENABLE(CSS_BOX_DECORATION_BREAK)
-    else if (renderer().style().boxDecorationBreak() == DCLONE) {
+    else if (renderer().style().boxDecorationBreak() == BoxDecorationBreak::Clone) {
         GraphicsContextStateSaver stateSaver(paintInfo.context());
         paintInfo.context().clip(LayoutRect(rect.x(), rect.y(), width(), height()));
         renderer().paintFillLayerExtended(paintInfo, color, fillLayer, rect, BackgroundBleedNone, this, rect.size(), op);
index 9cce7b2..5c4ecc9 100644 (file)
@@ -109,12 +109,12 @@ public:
 
     const ContainingBlockInfo& containingBlockInfo(RenderBlock& block) const
     {
-        EPosition position = block.style().position();
-        if (position == FixedPosition) {
+        auto position = block.style().position();
+        if (position == PositionType::Fixed) {
             ASSERT(block.containingBlock() == m_containingBlockForFixedPosition.block());
             return m_containingBlockForFixedPosition;
         }
-        if (position == AbsolutePosition) {
+        if (position == PositionType::Absolute) {
             ASSERT(block.containingBlock() == m_containingBlockForAbsolutePosition.block());
             return m_containingBlockForAbsolutePosition;
         }
index a30bb39..a844ad6 100644 (file)
@@ -385,20 +385,20 @@ void RenderBlock::removePositionedObjectsIfNeeded(const RenderStyle& oldStyle, c
     }
 
     // We are no longer the containing block for absolute positioned descendants.
-    if (newStyle.position() == StaticPosition && !willHaveTransform) {
+    if (newStyle.position() == PositionType::Static && !willHaveTransform) {
         // Our positioned descendants will be inserted into a new containing block's positioned objects list during the next layout.
         removePositionedObjects(nullptr, NewContainingBlock);
         return;
     }
 
     // We are a new containing block.
-    if (oldStyle.position() == StaticPosition && !hadTransform) {
+    if (oldStyle.position() == PositionType::Static && !hadTransform) {
         // Remove our absolutely positioned descendants from their current containing block.
         // They will be inserted into our positioned objects list during layout.
         auto* containingBlock = parent();
         while (containingBlock && !is<RenderView>(*containingBlock)
-            && (containingBlock->style().position() == StaticPosition || (containingBlock->isInline() && !containingBlock->isReplaced()))) {
-            if (containingBlock->style().position() == RelativePosition && containingBlock->isInline() && !containingBlock->isReplaced()) {
+            && (containingBlock->style().position() == PositionType::Static || (containingBlock->isInline() && !containingBlock->isReplaced()))) {
+            if (containingBlock->style().position() == PositionType::Relative && containingBlock->isInline() && !containingBlock->isReplaced()) {
                 containingBlock = containingBlock->containingBlock();
                 break;
             }
@@ -445,7 +445,7 @@ void RenderBlock::styleDidChange(StyleDifference diff, const RenderStyle* oldSty
 
     // It's possible for our border/padding to change, but for the overall logical width of the block to
     // end up being the same. We keep track of this change so in layoutBlock, we can know to set relayoutChildren=true.
-    setShouldForceRelayoutChildren(oldStyle && diff == StyleDifferenceLayout && needsLayout() && borderOrPaddingLogicalWidthChanged(*oldStyle, style()));
+    setShouldForceRelayoutChildren(oldStyle && diff == StyleDifference::Layout && needsLayout() && borderOrPaddingLogicalWidthChanged(*oldStyle, style()));
 }
 
 RenderPtr<RenderBlock> RenderBlock::clone() const
@@ -498,7 +498,7 @@ bool RenderBlock::isSelfCollapsingBlock() const
     if (logicalHeight() > 0
         || isTable() || borderAndPaddingLogicalHeight()
         || style().logicalMinHeight().isPositive()
-        || style().marginBeforeCollapse() == MSEPARATE || style().marginAfterCollapse() == MSEPARATE)
+        || style().marginBeforeCollapse() == MarginCollapse::Separate || style().marginAfterCollapse() == MarginCollapse::Separate)
         return false;
 
     Length logicalHeightLength = style().logicalHeight();
@@ -728,7 +728,7 @@ void RenderBlock::addOverflowFromPositionedObjects()
         RenderBox* positionedObject = *it;
         
         // Fixed positioned elements don't contribute to layout overflow, since they don't scroll with the content.
-        if (positionedObject->style().position() != FixedPosition)
+        if (positionedObject->style().position() != PositionType::Fixed)
             addOverflowFromChild(positionedObject, { positionedObject->x(), positionedObject->y() });
     }
 }
@@ -935,7 +935,7 @@ bool RenderBlock::simplifiedLayout()
 
 void RenderBlock::markFixedPositionObjectForLayoutIfNeeded(RenderBox& positionedChild)
 {
-    if (positionedChild.style().position() != FixedPosition)
+    if (positionedChild.style().position() != PositionType::Fixed)
         return;
 
     bool hasStaticBlockPosition = positionedChild.style().hasStaticBlockPosition(isHorizontalWritingMode());
@@ -944,9 +944,9 @@ void RenderBlock::markFixedPositionObjectForLayoutIfNeeded(RenderBox& positioned
         return;
 
     auto* parent = positionedChild.parent();
-    while (parent && !is<RenderView>(*parent) && parent->style().position() != AbsolutePosition)
+    while (parent && !is<RenderView>(*parent) && parent->style().position() != PositionType::Absolute)
         parent = parent->parent();
-    if (!parent || parent->style().position() != AbsolutePosition)
+    if (!parent || parent->style().position() != PositionType::Absolute)
         return;
 
     if (hasStaticInlinePosition) {
@@ -1390,7 +1390,7 @@ bool RenderBlock::isSelectionRoot() const
         || isPositioned() || isFloating()
         || isTableCell() || isInlineBlockOrInlineTable()
         || hasTransform() || hasReflection() || hasMask() || isWritingModeRoot()
-        || isRenderFragmentedFlow() || style().columnSpan() == ColumnSpanAll)
+        || isRenderFragmentedFlow() || style().columnSpan() == ColumnSpan::All)
         return true;
     
     if (view().selection().start()) {
@@ -1509,7 +1509,7 @@ GapRects RenderBlock::selectionGaps(RenderBlock& rootBlock, const LayoutPoint& r
     if (!isRenderBlockFlow()) // FIXME: Make multi-column selection gap filling work someday.
         return result;
 
-    if (hasTransform() || style().columnSpan() == ColumnSpanAll || isInFlowRenderFragmentedFlow()) {
+    if (hasTransform() || style().columnSpan() == ColumnSpan::All || isInFlowRenderFragmentedFlow()) {
         // FIXME: We should learn how to gap fill multiple columns and transforms eventually.
         lastLogicalTop = blockDirectionOffset(rootBlock, offsetFromRootBlock) + logicalHeight();
         lastLogicalLeft = logicalLeftSelectionOffset(rootBlock, logicalHeight(), cache);
@@ -2284,11 +2284,11 @@ void RenderBlock::computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth
         const RenderStyle& childStyle = child->style();
         if (child->isFloating() || (is<RenderBox>(*child) && downcast<RenderBox>(*child).avoidsFloats())) {
             LayoutUnit floatTotalWidth = floatLeftWidth + floatRightWidth;
-            if (childStyle.clear() & CLEFT) {
+            if (childStyle.clear() == Clear::Left || childStyle.clear() == Clear::Both) {
                 maxLogicalWidth = std::max(floatTotalWidth, maxLogicalWidth);
                 floatLeftWidth = 0;
             }
-            if (childStyle.clear() & CRIGHT) {
+            if (childStyle.clear() == Clear::Right || childStyle.clear() == Clear::Both) {
                 maxLogicalWidth = std::max(floatTotalWidth, maxLogicalWidth);
                 floatRightWidth = 0;
             }
@@ -2339,7 +2339,7 @@ void RenderBlock::computeBlockPreferredLogicalWidths(LayoutUnit& minLogicalWidth
         }
         
         if (child->isFloating()) {
-            if (childStyle.floating() == LeftFloat)
+            if (childStyle.floating() == Float::Left)
                 floatLeftWidth += w;
             else
                 floatRightWidth += w;
@@ -3434,7 +3434,7 @@ LayoutUnit RenderBlock::adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit heig
     // Shouldn't height:100px mean the fieldset content gets 100px of height even if the
     // resulting fieldset becomes much taller because of the legend?
     LayoutUnit bordersPlusPadding = borderAndPaddingLogicalHeight();
-    if (style().boxSizing() == CONTENT_BOX)
+    if (style().boxSizing() == BoxSizing::ContentBox)
         return height + bordersPlusPadding - intrinsicBorderForFieldset();
     return std::max(height, bordersPlusPadding);
 }
@@ -3447,7 +3447,7 @@ LayoutUnit RenderBlock::adjustContentBoxLogicalHeightForBoxSizing(std::optional<
     if (!height)
         return 0;
     LayoutUnit result = height.value();
-    if (style().boxSizing() == BORDER_BOX)
+    if (style().boxSizing() == BoxSizing::BorderBox)
         result -= borderAndPaddingLogicalHeight();
     else
         result -= intrinsicBorderForFieldset();
index 4fc17d9..f4a8f2f 100644 (file)
@@ -86,14 +86,14 @@ RenderBlockFlow::MarginInfo::MarginInfo(const RenderBlockFlow& block, LayoutUnit
     ASSERT(block.isRenderView() || block.parent());
     m_canCollapseWithChildren = !block.createsNewFormattingContext() && !block.isRenderView();
 
-    m_canCollapseMarginBeforeWithChildren = m_canCollapseWithChildren && !beforeBorderPadding && blockStyle.marginBeforeCollapse() != MSEPARATE;
+    m_canCollapseMarginBeforeWithChildren = m_canCollapseWithChildren && !beforeBorderPadding && blockStyle.marginBeforeCollapse() != MarginCollapse::Separate;
 
     // If any height other than auto is specified in CSS, then we don't collapse our bottom
     // margins with our children's margins. To do otherwise would be to risk odd visual
     // effects when the children overflow out of the parent block and yet still collapse
     // with it. We also don't collapse if we have any bottom border/padding.
     m_canCollapseMarginAfterWithChildren = m_canCollapseWithChildren && !afterBorderPadding
-        && (blockStyle.logicalHeight().isAuto() && !blockStyle.logicalHeight().value()) && blockStyle.marginAfterCollapse() != MSEPARATE;
+        && (blockStyle.logicalHeight().isAuto() && !blockStyle.logicalHeight().value()) && blockStyle.marginAfterCollapse() != MarginCollapse::Separate;
     
     m_quirkContainer = block.isTableCell() || block.isBody();
 
@@ -422,7 +422,7 @@ bool RenderBlockFlow::willCreateColumns(std::optional<unsigned> desiredColumnCou
         return false;
 
     // If overflow-y is set to paged-x or paged-y on the body or html element, we'll handle the paginating in the RenderView instead.
-    if ((style().overflowY() == OPAGEDX || style().overflowY() == OPAGEDY) && !(isDocumentElementRenderer() || isBody()))
+    if ((style().overflowY() == Overflow::PagedX || style().overflowY() == Overflow::PagedY) && !(isDocumentElementRenderer() || isBody()))
         return true;
     
     // Lines clamping creates columns.
@@ -846,7 +846,7 @@ LayoutUnit RenderBlockFlow::marginOffsetForSelfCollapsingBlock()
 {
     ASSERT(isSelfCollapsingBlock());
     RenderBlockFlow* parentBlock = downcast<RenderBlockFlow>(parent());
-    if (parentBlock && style().clear() && parentBlock->getClearDelta(*this, logicalHeight()))
+    if (parentBlock && style().clear() != Clear::None && parentBlock->getClearDelta(*this, logicalHeight()))
         return marginValuesForChild(*this).positiveMarginBefore();
     return LayoutUnit();
 }
@@ -1198,7 +1198,7 @@ LayoutUnit RenderBlockFlow::clearFloatsIfNeeded(RenderBox& child, MarginInfo& ma
         marginInfo.setAtBeforeSideOfBlock(false);
 
         // In case the child discarded the before margin of the block we need to reset the mustDiscardMarginBefore flag to the initial value.
-        setMustDiscardMarginBefore(style().marginBeforeCollapse() == MDISCARD);
+        setMustDiscardMarginBefore(style().marginBeforeCollapse() == MarginCollapse::Discard);
     }
 
     return yPos + heightIncrease;
@@ -1209,12 +1209,12 @@ void RenderBlockFlow::marginBeforeEstimateForChild(RenderBox& child, LayoutUnit&
     // Give up if in quirks mode and we're a body/table cell and the top margin of the child box is quirky.
     // Give up if the child specified -webkit-margin-collapse: separate that prevents collapsing.
     // FIXME: Use writing mode independent accessor for marginBeforeCollapse.
-    if ((document().inQuirksMode() && hasMarginAfterQuirk(child) && (isTableCell() || isBody())) || child.style().marginBeforeCollapse() == MSEPARATE)
+    if ((document().inQuirksMode() && hasMarginAfterQuirk(child) && (isTableCell() || isBody())) || child.style().marginBeforeCollapse() == MarginCollapse::Separate)
         return;
 
     // The margins are discarded by a child that specified -webkit-margin-collapse: discard.
     // FIXME: Use writing mode independent accessor for marginBeforeCollapse.
-    if (child.style().marginBeforeCollapse() == MDISCARD) {
+    if (child.style().marginBeforeCollapse() == MarginCollapse::Discard) {
         positiveMarginBefore = 0;
         negativeMarginBefore = 0;
         discardMarginBefore = true;
@@ -1243,7 +1243,7 @@ void RenderBlockFlow::marginBeforeEstimateForChild(RenderBox& child, LayoutUnit&
     }
     
     // Give up if there is clearance on the box, since it probably won't collapse into us.
-    if (!grandchildBox || grandchildBox->style().clear() != CNONE)
+    if (!grandchildBox || grandchildBox->style().clear() != Clear::None)
         return;
 
     // Make sure to update the block margins now for the grandchild box so that we're looking at current values.
@@ -1389,7 +1389,7 @@ void RenderBlockFlow::setMaxMarginAfterValues(LayoutUnit pos, LayoutUnit neg)
 
 void RenderBlockFlow::setMustDiscardMarginBefore(bool value)
 {
-    if (style().marginBeforeCollapse() == MDISCARD) {
+    if (style().marginBeforeCollapse() == MarginCollapse::Discard) {
         ASSERT(value);
         return;
     }
@@ -1405,7 +1405,7 @@ void RenderBlockFlow::setMustDiscardMarginBefore(bool value)
 
 void RenderBlockFlow::setMustDiscardMarginAfter(bool value)
 {
-    if (style().marginAfterCollapse() == MDISCARD) {
+    if (style().marginAfterCollapse() == MarginCollapse::Discard) {
         ASSERT(value);
         return;
     }
@@ -1421,21 +1421,21 @@ void RenderBlockFlow::setMustDiscardMarginAfter(bool value)
 
 bool RenderBlockFlow::mustDiscardMarginBefore() const
 {
-    return style().marginBeforeCollapse() == MDISCARD || (hasRareBlockFlowData() && rareBlockFlowData()->m_discardMarginBefore);
+    return style().marginBeforeCollapse() == MarginCollapse::Discard || (hasRareBlockFlowData() && rareBlockFlowData()->m_discardMarginBefore);
 }
 
 bool RenderBlockFlow::mustDiscardMarginAfter() const
 {
-    return style().marginAfterCollapse() == MDISCARD || (hasRareBlockFlowData() && rareBlockFlowData()->m_discardMarginAfter);
+    return style().marginAfterCollapse() == MarginCollapse::Discard || (hasRareBlockFlowData() && rareBlockFlowData()->m_discardMarginAfter);
 }
 
 bool RenderBlockFlow::mustDiscardMarginBeforeForChild(const RenderBox& child) const
 {
     ASSERT(!child.selfNeedsLayout());
     if (!child.isWritingModeRoot())
-        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginBefore() : (child.style().marginBeforeCollapse() == MDISCARD);
+        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginBefore() : (child.style().marginBeforeCollapse() == MarginCollapse::Discard);
     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
-        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginAfter() : (child.style().marginAfterCollapse() == MDISCARD);
+        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginAfter() : (child.style().marginAfterCollapse() == MarginCollapse::Discard);
 
     // FIXME: We return false here because the implementation is not geometrically complete. We have values only for before/after, not start/end.
     // In case the boxes are perpendicular we assume the property is not specified.
@@ -1446,9 +1446,9 @@ bool RenderBlockFlow::mustDiscardMarginAfterForChild(const RenderBox& child) con
 {
     ASSERT(!child.selfNeedsLayout());
     if (!child.isWritingModeRoot())
-        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginAfter() : (child.style().marginAfterCollapse() == MDISCARD);
+        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginAfter() : (child.style().marginAfterCollapse() == MarginCollapse::Discard);
     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
-        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginBefore() : (child.style().marginBeforeCollapse() == MDISCARD);
+        return is<RenderBlockFlow>(child) ? downcast<RenderBlockFlow>(child).mustDiscardMarginBefore() : (child.style().marginBeforeCollapse() == MarginCollapse::Discard);
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
@@ -1459,9 +1459,9 @@ bool RenderBlockFlow::mustSeparateMarginBeforeForChild(const RenderBox& child) c
     ASSERT(!child.selfNeedsLayout());
     const RenderStyle& childStyle = child.style();
     if (!child.isWritingModeRoot())
-        return childStyle.marginBeforeCollapse() == MSEPARATE;
+        return childStyle.marginBeforeCollapse() == MarginCollapse::Separate;
     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
-        return childStyle.marginAfterCollapse() == MSEPARATE;
+        return childStyle.marginAfterCollapse() == MarginCollapse::Separate;
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
@@ -1472,9 +1472,9 @@ bool RenderBlockFlow::mustSeparateMarginAfterForChild(const RenderBox& child) co
     ASSERT(!child.selfNeedsLayout());
     const RenderStyle& childStyle = child.style();
     if (!child.isWritingModeRoot())
-        return childStyle.marginAfterCollapse() == MSEPARATE;
+        return childStyle.marginAfterCollapse() == MarginCollapse::Separate;
     if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
-        return childStyle.marginBeforeCollapse() == MSEPARATE;
+        return childStyle.marginBeforeCollapse() == MarginCollapse::Separate;
 
     // FIXME: See |mustDiscardMarginBeforeForChild| above.
     return false;
@@ -2000,7 +2000,7 @@ void RenderBlockFlow::styleDidChange(StyleDifference diff, const RenderStyle* ol
     // then mark its descendants with floats for layout and clear all floats from its next
     // sibling blocks that exist in our floating objects list. See bug 56299 and 62875.
     bool canPropagateFloatIntoSibling = !isFloatingOrOutOfFlowPositioned() && !avoidsFloats();
-    if (diff == StyleDifferenceLayout && s_canPropagateFloatIntoSibling && !canPropagateFloatIntoSibling && hasOverhangingFloats()) {
+    if (diff == StyleDifference::Layout && s_canPropagateFloatIntoSibling && !canPropagateFloatIntoSibling && hasOverhangingFloats()) {
         RenderBlockFlow* parentBlock = this;
         const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
 
@@ -2022,7 +2022,7 @@ void RenderBlockFlow::styleDidChange(StyleDifference diff, const RenderStyle* ol
         parentBlock->markSiblingsWithFloatsForLayout();
     }
 
-    if (diff >= StyleDifferenceRepaint) {
+    if (diff >= StyleDifference::Repaint) {
         // FIXME: This could use a cheaper style-only test instead of SimpleLineLayout::canUseFor.
         if (selfNeedsLayout() || !m_simpleLineLayout || !SimpleLineLayout::canUseFor(*this))
             invalidateLineLayoutPath();
@@ -2044,10 +2044,10 @@ void RenderBlockFlow::styleWillChange(StyleDifference diff, const RenderStyle& n
     s_canPropagateFloatIntoSibling = oldStyle ? !isFloatingOrOutOfFlowPositioned() && !avoidsFloats() : false;
 
     if (oldStyle) {
-        EPosition oldPosition = oldStyle->position();
-        EPosition newPosition = newStyle.position();
+        auto oldPosition = oldStyle->position();
+        auto newPosition = newStyle.position();
 
-        if (parent() && diff == StyleDifferenceLayout && oldPosition != newPosition) {
+        if (parent() && diff == StyleDifference::Layout && oldPosition != newPosition) {
             if (containsFloats() && !isFloating() && !isOutOfFlowPositioned() && newStyle.hasOutOfFlowPosition())
                 markAllDescendantsWithFloatsForLayout();
         }
@@ -2355,7 +2355,7 @@ void RenderBlockFlow::computeLogicalLocationForFloat(FloatingObject& floatingObj
         }
     }
     
-    if (childBox.style().floating() == LeftFloat) {
+    if (childBox.style().floating() == Float::Left) {
         LayoutUnit heightRemainingLeft = 1;
         LayoutUnit heightRemainingRight = 1;
         floatLogicalLeft = logicalLeftOffsetForPositioningFloat(logicalTopOffset, logicalLeftOffset, false, &heightRemainingLeft);
@@ -2480,9 +2480,9 @@ bool RenderBlockFlow::positionNewFloats()
 
         LayoutRect oldRect = childBox.frameRect();
 
-        if (childBox.style().clear() & CLEFT)
+        if (childBox.style().clear() == Clear::Left || childBox.style().clear() == Clear::Both)
             logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatLeft), logicalTop);
-        if (childBox.style().clear() & CRIGHT)
+        if (childBox.style().clear() == Clear::Right || childBox.style().clear() == Clear::Both)
             logicalTop = std::max(lowestFloatLogicalBottom(FloatingObject::FloatRight), logicalTop);
 
         computeLogicalLocationForFloat(floatingObject, logicalTop);
@@ -2537,22 +2537,22 @@ bool RenderBlockFlow::positionNewFloats()
     return true;
 }
 
-void RenderBlockFlow::clearFloats(EClear clear)
+void RenderBlockFlow::clearFloats(Clear clear)
 {
     positionNewFloats();
     // set y position
     LayoutUnit newY = 0;
     switch (clear) {
-    case CLEFT:
+    case Clear::Left:
         newY = lowestFloatLogicalBottom(FloatingObject::FloatLeft);
         break;
-    case CRIGHT:
+    case Clear::Right:
         newY = lowestFloatLogicalBottom(FloatingObject::FloatRight);
         break;
-    case CBOTH:
+    case Clear::Both:
         newY = lowestFloatLogicalBottom();
         break;
-    default:
+    case Clear::None:
         break;
     }
     if (height() < newY)
@@ -2803,18 +2803,18 @@ LayoutUnit RenderBlockFlow::getClearDelta(RenderBox& child, LayoutUnit logicalTo
         return 0;
     
     // At least one float is present. We need to perform the clearance computation.
-    bool clearSet = child.style().clear() != CNONE;
+    bool clearSet = child.style().clear() != Clear::None;
     LayoutUnit logicalBottom = 0;
     switch (child.style().clear()) {
-    case CNONE:
+    case Clear::None:
         break;
-    case CLEFT:
+    case Clear::Left:
         logicalBottom = lowestFloatLogicalBottom(FloatingObject::FloatLeft);
         break;
-    case CRIGHT:
+    case Clear::Right:
         logicalBottom = lowestFloatLogicalBottom(FloatingObject::FloatRight);
         break;
-    case CBOTH:
+    case Clear::Both:
         logicalBottom = lowestFloatLogicalBottom();
         break;
     }
@@ -3055,7 +3055,7 @@ std::optional<int> RenderBlockFlow::inlineBlockBaseline(LineDirectionMode lineDi
     // According to the CSS spec http://www.w3.org/TR/CSS21/visudet.html, we shouldn't be performing this min, but should
     // instead be returning boxHeight directly. However, we feel that a min here is better behavior (and is consistent
     // enough with the spec to not cause tons of breakages).
-    return style().overflowY() == OVISIBLE ? lastBaseline : std::min(boxHeight, lastBaseline);
+    return style().overflowY() == Overflow::Visible ? lastBaseline : std::min(boxHeight, lastBaseline);
 }
 
 void RenderBlockFlow::setSelectionState(SelectionState state)
@@ -4189,8 +4189,8 @@ void RenderBlockFlow::computeInlinePreferredLogicalWidths(LayoutUnit& minLogical
                 bool clearPreviousFloat;
                 if (child->isFloating()) {
                     clearPreviousFloat = (prevFloat
-                        && ((prevFloat->style().floating() == LeftFloat && (childStyle.clear() & CLEFT))
-                            || (prevFloat->style().floating() == RightFloat && (childStyle.clear() & CRIGHT))));
+                        && ((prevFloat->style().floating() == Float::Left && (childStyle.clear() == Clear::Left || childStyle.clear() == Clear::Both))
+                            || (prevFloat->style().floating() == Float::Right && (childStyle.clear() == Clear::Right || childStyle.clear() == Clear::Both))));
                     prevFloat = child;
                 } else
                     clearPreviousFloat = false;
index c220bdb..2b1cc42 100644 (file)
@@ -487,7 +487,7 @@ private:
     // Returns true if and only if it has positioned any floats.
     bool positionNewFloats();
 
-    void clearFloats(EClear);
+    void clearFloats(Clear);
 
     LayoutUnit logicalRightFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit logicalHeight) const override;
     LayoutUnit logicalLeftFloatOffsetForLine(LayoutUnit logicalTop, LayoutUnit fixedOffset, LayoutUnit logicalHeight) const override;
index c1980a8..065f80a 100644 (file)
@@ -705,7 +705,7 @@ void RenderBlockFlow::computeInlineDirectionPositionsForLine(RootInlineBox* line
 static inline ExpansionBehavior expansionBehaviorForInlineTextBox(RenderBlockFlow& block, InlineTextBox& textBox, BidiRun* previousRun, BidiRun* nextRun, ETextAlign textAlign, bool isAfterExpansion)
 {
     // Tatechuyoko is modeled as the Object Replacement Character (U+FFFC), which can never have expansion opportunities inside nor intrinsically adjacent to it.
-    if (textBox.renderer().style().textCombine() == TextCombineHorizontal)
+    if (textBox.renderer().style().textCombine() == TextCombine::Horizontal)
         return ForbidLeadingExpansion | ForbidTrailingExpansion;
 
     ExpansionBehavior result = 0;
@@ -1020,7 +1020,7 @@ static inline bool isCollapsibleSpace(UChar character, const RenderText& rendere
     if (character == '\n')
         return !renderer.style().preserveNewline();
     if (character == noBreakSpace)
-        return renderer.style().nbspMode() == SPACE;
+        return renderer.style().nbspMode() == NBSPMode::Space;
     return false;
 }
 
@@ -1304,8 +1304,8 @@ void RenderBlockFlow::layoutRunsAndFloats(LineLayoutState& layoutState, bool has
             if (!lastObject->isBR())
                 lastObject = &lastRootBox()->firstLeafChild()->renderer();
             if (lastObject->isBR()) {
-                EClear clear = lastObject->style().clear();
-                if (clear != CNONE)
+                Clear clear = lastObject->style().clear();
+                if (clear != Clear::None)
                     clearFloats(clear);
             }
         }
@@ -1658,8 +1658,8 @@ void RenderBlockFlow::layoutLineBoxes(bool relayoutChildren, LayoutUnit& repaint
     // FIXME: CSS3 says that descendants that are clipped must also know how to truncate.  This is insanely
     // difficult to figure out in general (especially in the middle of doing layout), so we only handle the
     // simple case of an anonymous block truncating when it's parent is clipped.
-    bool hasTextOverflow = (style().textOverflow() && hasOverflowClip())
-        || (isAnonymousBlock() && parent() && parent()->isRenderBlock() && parent()->style().textOverflow() && parent()->hasOverflowClip());
+    bool hasTextOverflow = (style().textOverflow() == TextOverflow::Ellipsis && hasOverflowClip())
+        || (isAnonymousBlock() && parent() && parent()->isRenderBlock() && parent()->style().textOverflow() == TextOverflow::Ellipsis && parent()->hasOverflowClip());
 
     // Walk all the lines and delete our ellipsis line boxes if they exist.
     if (hasTextOverflow)
index 832ae32..192373d 100644 (file)
@@ -262,7 +262,7 @@ void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyl
     if (oldStyle) {
         // The background of the root element or the body element could propagate up to
         // the canvas. Issue full repaint, when our style changes substantially.
-        if (diff >= StyleDifferenceRepaint && (isDocumentElementRenderer() || isBody())) {
+        if (diff >= StyleDifference::Repaint && (isDocumentElementRenderer() || isBody())) {
             view().repaintRootContents();
             if (oldStyle->hasEntirelyFixedBackground() != newStyle.hasEntirelyFixedBackground())
                 view().compositor().rootFixedBackgroundsChanged();
@@ -270,9 +270,9 @@ void RenderBox::styleWillChange(StyleDifference diff, const RenderStyle& newStyl
         
         // When a layout hint happens and an object's position style changes, we have to do a layout
         // to dirty the render tree using the old position value now.
-        if (diff == StyleDifferenceLayout && parent() && oldStyle->position() != newStyle.position()) {
+        if (diff == StyleDifference::Layout && parent() && oldStyle->position() != newStyle.position()) {
             markContainingBlocksForLayout();
-            if (oldStyle->position() == StaticPosition)
+            if (oldStyle->position() == PositionType::Static)
                 repaint();
             else if (newStyle.hasOutOfFlowPosition())
                 parent()->setChildNeedsLayout();
@@ -330,7 +330,7 @@ void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle
     }
 
     // Our opaqueness might have changed without triggering layout.
-    if (diff >= StyleDifferenceRepaint && diff <= StyleDifferenceRepaintLayer) {
+    if (diff >= StyleDifference::Repaint && diff <= StyleDifference::RepaintLayer) {
         auto parentToInvalidate = parent();
         for (unsigned i = 0; i < backgroundObscurationTestMaxDepth && parentToInvalidate; ++i) {
             parentToInvalidate->invalidateBackgroundObscurationStatus();
@@ -397,7 +397,7 @@ void RenderBox::styleDidChange(StyleDifference diff, const RenderStyle* oldStyle
             }
         }
 
-        if (diff != StyleDifferenceEqual)
+        if (diff != StyleDifference::Equal)
             view().compositor().rootOrBodyStyleChanged(*this, oldStyle);
     }
 
@@ -469,7 +469,7 @@ void RenderBox::updateFromStyle()
     setFloating(!isOutOfFlowPositioned() && styleToUse.isFloating());
 
     // We also handle <body> and <html>, whose overflow applies to the viewport.
-    if (styleToUse.overflowX() != OVISIBLE && !isDocElementRenderer && isRenderBlock()) {
+    if (styleToUse.overflowX() != Overflow::Visible && !isDocElementRenderer && isRenderBlock()) {
         bool boxHasOverflowClip = true;
         if (isBody()) {
             // Overflow on the body can propagate to the viewport under the following conditions.
@@ -478,7 +478,7 @@ void RenderBox::updateFromStyle()
             // (3) The root element has visible overflow.
             if (is<HTMLHtmlElement>(*document().documentElement())
                 && document().body() == element()
-                && document().documentElement()->renderer()->style().overflowX() == OVISIBLE) {
+                && document().documentElement()->renderer()->style().overflowX() == Overflow::Visible) {
                 boxHasOverflowClip = false;
             }
         }
@@ -752,13 +752,13 @@ bool RenderBox::fixedElementLaysOutRelativeToFrame(const FrameView& frameView) c
 bool RenderBox::includeVerticalScrollbarSize() const
 {
     return hasOverflowClip() && layer() && !layer()->hasOverlayScrollbars()
-        && (style().overflowY() == OSCROLL || style().overflowY() == OAUTO);
+        && (style().overflowY() == Overflow::Scroll || style().overflowY() == Overflow::Auto);
 }
 
 bool RenderBox::includeHorizontalScrollbarSize() const
 {
     return hasOverflowClip() && layer() && !layer()->hasOverlayScrollbars()
-        && (style().overflowX() == OSCROLL || style().overflowX() == OAUTO);
+        && (style().overflowX() == Overflow::Scroll || style().overflowX() == Overflow::Auto);
 }
 
 int RenderBox::verticalScrollbarWidth() const
@@ -776,12 +776,12 @@ int RenderBox::intrinsicScrollbarLogicalWidth() const
     if (!hasOverflowClip())
         return 0;
 
-    if (isHorizontalWritingMode() && (style().overflowY() == OSCROLL && !hasVerticalScrollbarWithAutoBehavior())) {
+    if (isHorizontalWritingMode() && (style().overflowY() == Overflow::Scroll && !hasVerticalScrollbarWithAutoBehavior())) {
         ASSERT(layer() && layer()->hasVerticalScrollbar());
         return verticalScrollbarWidth();
     }
 
-    if (!isHorizontalWritingMode() && (style().overflowX() == OSCROLL && !hasHorizontalScrollbarWithAutoBehavior())) {
+    if (!isHorizontalWritingMode() && (style().overflowX() == Overflow::Scroll && !hasHorizontalScrollbarWithAutoBehavior())) {
         ASSERT(layer() && layer()->hasHorizontalScrollbar());
         return horizontalScrollbarHeight();
     }
@@ -940,14 +940,14 @@ void RenderBox::panScroll(const IntPoint& source)
 
 bool RenderBox::hasVerticalScrollbarWithAutoBehavior() const
 {
-    bool overflowScrollActsLikeAuto = style().overflowY() == OSCROLL && !style().hasPseudoStyle(SCROLLBAR) && ScrollbarTheme::theme().usesOverlayScrollbars();
-    return hasOverflowClip() && (style().overflowY() == OAUTO || style().overflowY() == OOVERLAY || overflowScrollActsLikeAuto);
+    bool overflowScrollActsLikeAuto = style().overflowY() == Overflow::Scroll && !style().hasPseudoStyle(SCROLLBAR) && ScrollbarTheme::theme().usesOverlayScrollbars();
+    return hasOverflowClip() && (style().overflowY() == Overflow::Auto || style().overflowY() == Overflow::Overlay || overflowScrollActsLikeAuto);
 }
 
 bool RenderBox::hasHorizontalScrollbarWithAutoBehavior() const
 {
-    bool overflowScrollActsLikeAuto = style().overflowX() == OSCROLL && !style().hasPseudoStyle(SCROLLBAR) && ScrollbarTheme::theme().usesOverlayScrollbars();
-    return hasOverflowClip() && (style().overflowX() == OAUTO || style().overflowX() == OOVERLAY || overflowScrollActsLikeAuto);
+    bool overflowScrollActsLikeAuto = style().overflowX() == Overflow::Scroll && !style().hasPseudoStyle(SCROLLBAR) && ScrollbarTheme::theme().usesOverlayScrollbars();
+    return hasOverflowClip() && (style().overflowX() == Overflow::Auto || style().overflowX() == Overflow::Overlay || overflowScrollActsLikeAuto);
 }
 
 bool RenderBox::needsPreferredWidthsRecalculation() const
@@ -1126,7 +1126,7 @@ void RenderBox::clearOverrideContainingBlockContentLogicalHeight()
 LayoutUnit RenderBox::adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width) const
 {
     LayoutUnit bordersPlusPadding = borderAndPaddingLogicalWidth();
-    if (style().boxSizing() == CONTENT_BOX)
+    if (style().boxSizing() == BoxSizing::ContentBox)
         return width + bordersPlusPadding;
     return std::max(width, bordersPlusPadding);
 }
@@ -1134,14 +1134,14 @@ LayoutUnit RenderBox::adjustBorderBoxLogicalWidthForBoxSizing(LayoutUnit width)
 LayoutUnit RenderBox::adjustBorderBoxLogicalHeightForBoxSizing(LayoutUnit height) const
 {
     LayoutUnit bordersPlusPadding = borderAndPaddingLogicalHeight();
-    if (style().boxSizing() == CONTENT_BOX)
+    if (style().boxSizing() == BoxSizing::ContentBox)
         return height + bordersPlusPadding;
     return std::max(height, bordersPlusPadding);
 }
 
 LayoutUnit RenderBox::adjustContentBoxLogicalWidthForBoxSizing(LayoutUnit width) const
 {
-    if (style().boxSizing() == BORDER_BOX)
+    if (style().boxSizing() == BoxSizing::BorderBox)
         width -= borderAndPaddingLogicalWidth();
     return std::max<LayoutUnit>(0, width);
 }
@@ -1151,7 +1151,7 @@ LayoutUnit RenderBox::adjustContentBoxLogicalHeightForBoxSizing(std::optional<La
     if (!height)
         return 0;
     LayoutUnit result = height.value();
-    if (style().boxSizing() == BORDER_BOX)
+    if (style().boxSizing() == BoxSizing::BorderBox)
         result -= borderAndPaddingLogicalHeight();
     return std::max(LayoutUnit(), result);
 }
@@ -1378,13 +1378,13 @@ bool RenderBox::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) c
         return false;
     LayoutRect backgroundRect;
     switch (style().backgroundClip()) {
-    case BorderFillBox:
+    case FillBox::Border:
         backgroundRect = borderBoxRect();
         break;
-    case PaddingFillBox:
+    case FillBox::Padding:
         backgroundRect = paddingBoxRect();
         break;
-    case ContentFillBox:
+    case FillBox::Content:
         backgroundRect = contentBoxRect();
         break;
     default:
@@ -1396,7 +1396,7 @@ bool RenderBox::backgroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect) c
 static bool isCandidateForOpaquenessTest(const RenderBox& childBox)
 {
     const RenderStyle& childStyle = childBox.style();
-    if (childStyle.position() != StaticPosition && childBox.containingBlock() != childBox.parent())
+    if (childStyle.position() != PositionType::Static && childBox.containingBlock() != childBox.parent())
         return false;
     if (childStyle.visibility() != VISIBLE)
         return false;
@@ -1433,7 +1433,7 @@ bool RenderBox::foregroundIsKnownToBeOpaqueInRect(const LayoutRect& localRect, u
         childLocalRect.moveBy(-childLocation);
         if (childLocalRect.y() < 0 || childLocalRect.x() < 0) {
             // If there is unobscured area above/left of a static positioned box then the rect is probably not covered.
-            if (childBox.style().position() == StaticPosition)
+            if (childBox.style().position() == PositionType::Static)
                 return false;
             continue;
         }
@@ -1470,11 +1470,11 @@ bool RenderBox::computeBackgroundIsKnownToBeObscured(const LayoutPoint& paintOff
 bool RenderBox::backgroundHasOpaqueTopLayer() const
 {
     auto& fillLayer = style().backgroundLayers();
-    if (fillLayer.clip() != BorderFillBox)
+    if (fillLayer.clip() != FillBox::Border)
         return false;
 
     // Clipped with local scrolling
-    if (hasOverflowClip() && fillLayer.attachment() == LocalBackgroundAttachment)
+    if (hasOverflowClip() && fillLayer.attachment() == FillAttachment::LocalBackground)
         return false;
 
     if (fillLayer.hasOpaqueImage(*this) && fillLayer.hasRepeatXY() && fillLayer.image()->canRender(this, style().effectiveZoom()))
@@ -2141,7 +2141,7 @@ LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const Render
     LayoutRect adjustedRect = rect;
     const RenderStyle& styleToUse = style();
     // Paint offset cache is only valid for root-relative, non-fixed position repainting
-    if (view().frameView().layoutContext().isPaintOffsetCacheEnabled() && !repaintContainer && styleToUse.position() != FixedPosition) {
+    if (view().frameView().layoutContext().isPaintOffsetCacheEnabled() && !repaintContainer && styleToUse.position() != PositionType::Fixed) {
         auto* layoutState = view().frameView().layoutContext().layoutState();
 
         if (layer() && layer()->transform())
@@ -2179,8 +2179,8 @@ LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const Render
     // us to add the height twice.
     // The same logic applies for elements flowed directly into the flow thread. Their topLeft member
     // will already contain the portion rect of the fragment.
-    EPosition position = styleToUse.position();
-    if (container->isOutOfFlowRenderFragmentedFlow() && position != AbsolutePosition && containingBlock() != enclosingFragmentedFlow()) {
+    auto position = styleToUse.position();
+    if (container->isOutOfFlowRenderFragmentedFlow() && position != PositionType::Absolute && containingBlock() != enclosingFragmentedFlow()) {
         RenderFragmentContainer* firstFragment = nullptr;
         RenderFragmentContainer* lastFragment = nullptr;
         if (downcast<RenderFragmentedFlow>(*container).getFragmentRangeForBox(this, firstFragment, lastFragment))
@@ -2222,14 +2222,14 @@ LayoutRect RenderBox::computeRectForRepaint(const LayoutRect& rect, const Render
     // We are now in our parent container's coordinate space. Apply our transform to obtain a bounding box
     // in the parent's coordinate space that encloses us.
     if (hasLayer() && layer()->transform()) {
-        context.m_hasPositionFixedDescendant = position == FixedPosition;
+        context.m_hasPositionFixedDescendant = position == PositionType::Fixed;
         adjustedRect = LayoutRect(encloseRectToDevicePixels(layer()->transform()->mapRect(adjustedRect), document().deviceScaleFactor()));
         topLeft = adjustedRect.location();
         topLeft.move(locationOffset);
-    } else if (position == FixedPosition)
+    } else if (position == PositionType::Fixed)
         context.m_hasPositionFixedDescendant = true;
 
-    if (position == AbsolutePosition && container->isInFlowPositioned() && is<RenderInline>(*container))
+    if (position == PositionType::Absolute && container->isInFlowPositioned() && is<RenderInline>(*container))
         topLeft += downcast<RenderInline>(*container).offsetForInFlowPositionedInline(this);
     else if (styleToUse.hasInFlowPosition() && layer()) {
         // Apply the relative position offset when invalidating a rectangle.  The layer
@@ -2319,8 +2319,8 @@ void RenderBox::computeLogicalWidthInFragment(LogicalExtentComputedValues& compu
 
     // FIXME: Account for block-flow in flexible boxes.
     // https://bugs.webkit.org/show_bug.cgi?id=46418
-    bool inVerticalBox = parent()->isDeprecatedFlexibleBox() && (parent()->style().boxOrient() == VERTICAL);
-    bool stretching = (parent()->style().boxAlign() == BSTRETCH);
+    bool inVerticalBox = parent()->isDeprecatedFlexibleBox() && (parent()->style().boxOrient() == BoxOrient::Vertical);
+    bool stretching = (parent()->style().boxAlign() == BoxAlignment::Stretch);
     // FIXME: Stretching is the only reason why we don't want the box to be treated as a replaced element, so we could perhaps
     // refactor all this logic, not only for flex and grid since alignment is intended to be applied to any block.
     bool treatAsReplaced = shouldComputeSizeAsReplaced() && (!inVerticalBox || !stretching);
@@ -2459,16 +2459,16 @@ bool RenderBox::columnFlexItemHasStretchAlignment() const
     ASSERT(parentStyle.isColumnFlexDirection());
     if (style().marginStart().isAuto() || style().marginEnd().isAuto())
         return false;
-    return style().resolvedAlignSelf(&parentStyle, containingBlock()->selfAlignmentNormalBehavior()).position() == ItemPositionStretch;
+    return style().resolvedAlignSelf(&parentStyle, containingBlock()->selfAlignmentNormalBehavior()).position() == ItemPosition::Stretch;
 }
 
 bool RenderBox::isStretchingColumnFlexItem() const
 {
-    if (parent()->isDeprecatedFlexibleBox() && parent()->style().boxOrient() == VERTICAL && parent()->style().boxAlign() == BSTRETCH)
+    if (parent()->isDeprecatedFlexibleBox() && parent()->style().boxOrient() == BoxOrient::Vertical && parent()->style().boxAlign() == BoxAlignment::Stretch)
         return true;
 
     // We don't stretch multiline flexboxes because they need to apply line spacing (align-content) first.
-    if (parent()->isFlexibleBox() && parent()->style().flexWrap() == FlexNoWrap && parent()->style().isColumnFlexDirection() && columnFlexItemHasStretchAlignment())
+    if (parent()->isFlexibleBox() && parent()->style().flexWrap() == FlexWrap::NoWrap && parent()->style().isColumnFlexDirection() && columnFlexItemHasStretchAlignment())
         return true;
     return false;
 }
@@ -2486,8 +2486,8 @@ bool RenderBox::hasStretchedLogicalWidth() const
         return false;
     }
     if (containingBlock->isHorizontalWritingMode() != isHorizontalWritingMode())
-        return style.resolvedAlignSelf(&containingBlock->style(), containingBlock->selfAlignmentNormalBehavior(this)).position() == ItemPositionStretch;
-    return style.resolvedJustifySelf(&containingBlock->style(), containingBlock->selfAlignmentNormalBehavior(this)).position() == ItemPositionStretch;
+        return style.resolvedAlignSelf(&containingBlock->style(), containingBlock->selfAlignmentNormalBehavior(this)).position() == ItemPosition::Stretch;
+    return style.resolvedJustifySelf(&containingBlock->style(), containingBlock->selfAlignmentNormalBehavior(this)).position() == ItemPosition::Stretch;
 }
 
 bool RenderBox::sizesLogicalWidthToFitContent(SizeType widthType) const
@@ -2528,7 +2528,7 @@ bool RenderBox::sizesLogicalWidthToFitContent(SizeType widthType) const
     // to avoid an extra layout when applying alignment.
     if (parent()->isFlexibleBox()) {
         // For multiline columns, we need to apply align-content first, so we can't stretch now.
-        if (!parent()->style().isColumnFlexDirection() || parent()->style().flexWrap() != FlexNoWrap)
+        if (!parent()->style().isColumnFlexDirection() || parent()->style().flexWrap() != FlexWrap::NoWrap)
             return true;
         if (!columnFlexItemHasStretchAlignment())
             return true;
@@ -2538,7 +2538,7 @@ bool RenderBox::sizesLogicalWidthToFitContent(SizeType widthType) const
     // that don't stretch their kids lay out their children at their intrinsic widths.
     // FIXME: Think about block-flow here.
     // https://bugs.webkit.org/show_bug.cgi?id=46473
-    if (parent()->isDeprecatedFlexibleBox() && (parent()->style().boxOrient() == HORIZONTAL || parent()->style().boxAlign() != BSTRETCH))
+    if (parent()->isDeprecatedFlexibleBox() && (parent()->style().boxOrient() == BoxOrient::Horizontal || parent()->style().boxAlign() != BoxAlignment::Stretch))
         return true;
 
     // Button, input, select, textarea, and legend treat width value of 'auto' as 'intrinsic' unless it's in a
@@ -2707,8 +2707,8 @@ RenderBox::LogicalExtentComputedValues RenderBox::computeLogicalHeight(LayoutUni
 
         // FIXME: Account for block-flow in flexible boxes.
         // https://bugs.webkit.org/show_bug.cgi?id=46418
-        bool inHorizontalBox = parent()->isDeprecatedFlexibleBox() && parent()->style().boxOrient() == HORIZONTAL;
-        bool stretching = parent()->style().boxAlign() == BSTRETCH;
+        bool inHorizontalBox = parent()->isDeprecatedFlexibleBox() && parent()->style().boxOrient() == BoxOrient::Horizontal;
+        bool stretching = parent()->style().boxAlign() == BoxAlignment::Stretch;
         bool treatAsReplaced = shouldComputeSizeAsReplaced() && (!inHorizontalBox || !stretching);
         bool checkMinMaxHeight = false;
 
@@ -2728,7 +2728,7 @@ RenderBox::LogicalExtentComputedValues RenderBox::computeLogicalHeight(LayoutUni
         // Block children of horizontal flexible boxes fill the height of the box.
         // FIXME: Account for block-flow in flexible boxes.
         // https://bugs.webkit.org/show_bug.cgi?id=46418
-        if (h.isAuto() && is<RenderDeprecatedFlexibleBox>(*parent()) && parent()->style().boxOrient() == HORIZONTAL
+        if (h.isAuto() && is<RenderDeprecatedFlexibleBox>(*parent()) && parent()->style().boxOrient() == BoxOrient::Horizontal
                 && downcast<RenderDeprecatedFlexibleBox>(*parent()).isStretchingChildren()) {
             h = Length(parentBox()->contentLogicalHeight() - marginBefore() - marginAfter() - borderAndPaddingLogicalHeight(), Fixed);
             checkMinMaxHeight = false;
@@ -2807,7 +2807,7 @@ std::optional<LayoutUnit> RenderBox::computeIntrinsicLogicalContentHeightUsing(L
     if (logicalHeightLength.isMinContent() || logicalHeightLength.isMaxContent() || logicalHeightLength.isFitContent()) {
         if (!intrinsicContentHeight)
             return intrinsicContentHeight;
-        if (style().boxSizing() == BORDER_BOX)
+        if (style().boxSizing() == BoxSizing::BorderBox)
             return intrinsicContentHeight.value() + borderAndPaddingLogicalHeight();
         return intrinsicContentHeight;
     }
@@ -4453,7 +4453,7 @@ bool RenderBox::createsNewFormattingContext() const
 {
     return isInlineBlockOrInlineTable() || isFloatingOrOutOfFlowPositioned() || hasOverflowClip() || isFlexItemIncludingDeprecated()
         || isTableCell() || isTableCaption() || isFieldset() || isWritingModeRoot() || isDocumentElementRenderer() || isRenderFragmentedFlow() || isRenderFragmentContainer()
-        || isGridItem() || style().specifiesColumns() || style().columnSpan();
+        || isGridItem() || style().specifiesColumns() || style().columnSpan() == ColumnSpan::All;
 }
 
 bool RenderBox::avoidsFloats() const
index 1187716..92e37dd 100644 (file)
@@ -459,8 +459,8 @@ public:
     bool hasHorizontalScrollbarWithAutoBehavior() const;
 
     bool scrollsOverflow() const { return scrollsOverflowX() || scrollsOverflowY(); }
-    bool scrollsOverflowX() const { return hasOverflowClip() && (style().overflowX() == OSCROLL || hasHorizontalScrollbarWithAutoBehavior()); }
-    bool scrollsOverflowY() const { return hasOverflowClip() && (style().overflowY() == OSCROLL || hasVerticalScrollbarWithAutoBehavior()); }
+    bool scrollsOverflowX() const { return hasOverflowClip() && (style().overflowX() == Overflow::Scroll || hasHorizontalScrollbarWithAutoBehavior()); }
+    bool scrollsOverflowY() const { return hasOverflowClip() && (style().overflowY() == Overflow::Scroll || hasVerticalScrollbarWithAutoBehavior()); }
 
     bool hasHorizontalOverflow() const { return scrollWidth() != roundToInt(clientWidth()); }
     bool hasVerticalOverflow() const { return scrollHeight() != roundToInt(clientHeight()); }
@@ -633,7 +633,7 @@ protected:
 
     bool createsNewFormattingContext() const;
 
-    virtual ItemPosition selfAlignmentNormalBehavior(const RenderBox* = nullptr) const { return ItemPositionStretch; }
+    virtual ItemPosition selfAlignmentNormalBehavior(const RenderBox* = nullptr) const { return ItemPosition::Stretch; }
 
     // Returns false if it could not cheaply compute the extent (e.g. fixed background), in which case the returned rect may be incorrect.
     bool getBackgroundPaintedExtent(const LayoutPoint& paintOffset, LayoutRect&) const;
index 5d1dfd4..f32be14 100644 (file)
@@ -749,8 +749,8 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
     bool includeRightEdge = box ? box->includeLogicalRightEdge() : true;
 
     bool hasRoundedBorder = style().hasBorderRadius() && (includeLeftEdge || includeRightEdge);
-    bool clippedWithLocalScrolling = hasOverflowClip() && bgLayer.attachment() == LocalBackgroundAttachment;
-    bool isBorderFill = bgLayer.clip() == BorderFillBox;
+    bool clippedWithLocalScrolling = hasOverflowClip() && bgLayer.attachment() == FillAttachment::LocalBackground;
+    bool isBorderFill = bgLayer.clip() == FillBox::Border;
     bool isRoot = this->isDocumentElementRenderer();
 
     Color bgColor = color;
@@ -759,7 +759,7 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
     
     bool forceBackgroundToWhite = false;
     if (document().printing()) {
-        if (style().printColorAdjust() == PrintColorAdjustEconomy)
+        if (style().printColorAdjust() == PrintColorAdjust::Economy)
             forceBackgroundToWhite = true;
         if (settings().shouldPrintBackgrounds())
             forceBackgroundToWhite = false;
@@ -816,17 +816,17 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
         return;
     }
 
-    // BorderFillBox radius clipping is taken care of by BackgroundBleedUseTransparencyLayer
+    // FillBox::Border radius clipping is taken care of by BackgroundBleedUseTransparencyLayer
     bool clipToBorderRadius = hasRoundedBorder && !(isBorderFill && bleedAvoidance == BackgroundBleedUseTransparencyLayer);
     GraphicsContextStateSaver clipToBorderStateSaver(context, clipToBorderRadius);
     if (clipToBorderRadius) {
         RoundedRect border = isBorderFill ? backgroundRoundedRectAdjustedForBleedAvoidance(context, rect, bleedAvoidance, box, boxSize, includeLeftEdge, includeRightEdge) : getBackgroundRoundedRect(rect, box, boxSize.width(), boxSize.height(), includeLeftEdge, includeRightEdge);
 
         // Clip to the padding or content boxes as necessary.
-        if (bgLayer.clip() == ContentFillBox) {
+        if (bgLayer.clip() == FillBox::Content) {
             border = style().getRoundedInnerBorderFor(border.rect(),
                 paddingTop() + borderTop(), paddingBottom() + borderBottom(), paddingLeft() + borderLeft(), paddingRight() + borderRight(), includeLeftEdge, includeRightEdge);
-        } else if (bgLayer.clip() == PaddingFillBox)
+        } else if (bgLayer.clip() == FillBox::Padding)
             border = style().getRoundedInnerBorderFor(border.rect(), includeLeftEdge, includeRightEdge);
 
         clipRoundedInnerRect(context, pixelSnappedRect, border.pixelSnappedRoundedRectForPainting(deviceScaleFactor));
@@ -854,10 +854,10 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
     std::unique_ptr<ImageBuffer> maskImage;
     IntRect maskRect;
 
-    if (bgLayer.clip() == PaddingFillBox || bgLayer.clip() == ContentFillBox) {
+    if (bgLayer.clip() == FillBox::Padding || bgLayer.clip() == FillBox::Content) {
         // Clip to the padding or content boxes as necessary.
         if (!clipToBorderRadius) {
-            bool includePadding = bgLayer.clip() == ContentFillBox;
+            bool includePadding = bgLayer.clip() == FillBox::Content;
             LayoutRect clipRect = LayoutRect(scrolledPaintRect.x() + bLeft + (includePadding ? pLeft : LayoutUnit()),
                 scrolledPaintRect.y() + borderTop() + (includePadding ? paddingTop() : LayoutUnit()),
                 scrolledPaintRect.width() - bLeft - bRight - (includePadding ? pLeft + pRight : LayoutUnit()),
@@ -865,7 +865,7 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
             backgroundClipStateSaver.save();
             context.clip(clipRect);
         }
-    } else if (bgLayer.clip() == TextFillBox) {
+    } else if (bgLayer.clip() == FillBox::Text) {
         // We have to draw our text into a mask that can then be used to clip background drawing.
         // First figure out how big the mask has to be.  It should be no bigger than what we need
         // to actually render, so we should intersect the dirty rect with the border box of the background.
@@ -954,7 +954,7 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
         RefPtr<Image> image;
         if (!geometry.destRect().isEmpty() && (image = bgImage->image(backgroundObject ? backgroundObject : this, geometry.tileSize()))) {
             auto compositeOp = op == CompositeSourceOver ? bgLayer.composite() : op;
-            context.setDrawLuminanceMask(bgLayer.maskSourceType() == MaskLuminance);
+            context.setDrawLuminanceMask(bgLayer.maskSourceType() == MaskSourceType::Luminance);
 
             if (is<BitmapImage>(image))
                 downcast<BitmapImage>(*image).updateFromSettings(settings());
@@ -969,7 +969,7 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
         }
     }
 
-    if (maskImage && bgLayer.clip() == TextFillBox) {
+    if (maskImage && bgLayer.clip() == FillBox::Text) {
         context.drawConsumingImageBuffer(WTFMove(maskImage), maskRect, CompositeDestinationIn);
         context.endTransparencyLayer();
     }
@@ -1069,7 +1069,7 @@ LayoutSize RenderBoxModelObject::calculateImageIntrinsicDimensions(StyleImage* i
 LayoutSize RenderBoxModelObject::calculateFillTileSize(const FillLayer& fillLayer, const LayoutSize& positioningAreaSize) const
 {
     StyleImage* image = fillLayer.image();
-    EFillSizeType type = fillLayer.size().type;
+    FillSizeType type = fillLayer.size().type;
 
     LayoutSize imageIntrinsicSize;
     if (image) {
@@ -1079,60 +1079,60 @@ LayoutSize RenderBoxModelObject::calculateFillTileSize(const FillLayer& fillLaye
         imageIntrinsicSize = positioningAreaSize;
 
     switch (type) {
-        case SizeLength: {
-            LayoutSize tileSize = positioningAreaSize;
+    case FillSizeType::Size: {
+        LayoutSize tileSize = positioningAreaSize;
 
-            Length layerWidth = fillLayer.size().size.width;
-            Length layerHeight = fillLayer.size().size.height;
+        Length layerWidth = fillLayer.size().size.width;
+        Length layerHeight = fillLayer.size().size.height;
 
-            if (layerWidth.isFixed())
-                tileSize.setWidth(layerWidth.value());
-            else if (layerWidth.isPercentOrCalculated())
-                tileSize.setWidth(valueForLength(layerWidth, positioningAreaSize.width()));
-            
-            if (layerHeight.isFixed())
-                tileSize.setHeight(layerHeight.value());
-            else if (layerHeight.isPercentOrCalculated())
-                tileSize.setHeight(valueForLength(layerHeight, positioningAreaSize.height()));
-
-            // If one of the values is auto we have to use the appropriate
-            // scale to maintain our aspect ratio.
-            if (layerWidth.isAuto() && !layerHeight.isAuto()) {
-                if (imageIntrinsicSize.height())
-                    tileSize.setWidth(imageIntrinsicSize.width() * tileSize.height() / imageIntrinsicSize.height());
-            } else if (!layerWidth.isAuto() && layerHeight.isAuto()) {
-                if (imageIntrinsicSize.width())
-                    tileSize.setHeight(imageIntrinsicSize.height() * tileSize.width() / imageIntrinsicSize.width());
-            } else if (layerWidth.isAuto() && layerHeight.isAuto()) {
-                // If both width and height are auto, use the image's intrinsic size.
-                tileSize = imageIntrinsicSize;
-            }
-
-            tileSize.clampNegativeToZero();
-            return tileSize;
+        if (layerWidth.isFixed())
+            tileSize.setWidth(layerWidth.value());
+        else if (layerWidth.isPercentOrCalculated())
+            tileSize.setWidth(valueForLength(layerWidth, positioningAreaSize.width()));
+        
+        if (layerHeight.isFixed())
+            tileSize.setHeight(layerHeight.value());
+        else if (layerHeight.isPercentOrCalculated())
+            tileSize.setHeight(valueForLength(layerHeight, positioningAreaSize.height()));
+
+        // If one of the values is auto we have to use the appropriate
+        // scale to maintain our aspect ratio.
+        if (layerWidth.isAuto() && !layerHeight.isAuto()) {
+            if (imageIntrinsicSize.height())
+                tileSize.setWidth(imageIntrinsicSize.width() * tileSize.height() / imageIntrinsicSize.height());
+ &nb