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 43ab552a1e97453264e3da8c8090afc9382cced8..2ced559689f825cc7078740fe4b540ba65cab258 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 75a4171964bb7dcf18effd139599b399a045fc02..0e37ea6a5bdceb475bd5b68af93802de82d93489 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 f072af8dc19baf8854cf5a81ed977b30b9858e6c..5f7654428b62b06f71918d9ef7fa05c5bb563561 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 5f225f74abb55290acf11692c66cfb83b7bb3597..15c85606891b28d982e7d9859a23ec1a71e6eba9 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 eeae42667be3d3832c00d1cb98cf3a062a861adc..38ad56c151fc41fdeb353641d899b1967004bb17 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 15e1645c1bc82bd5c89b47500fdbeb452d67a74b..1c2a3dd6860c6b55babd9235628a3587eb0e3d17 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 ccd67d4691451944376a99e87aefc4c9aedf6140..cde4a403d934ab5c6da476df854d996b233efa5c 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 35205518efd254945adc826bbd890c94c627c6fd..e66ada24b707601db70f636152a7712067350330 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 143344476db891c4643e64b52e3eb62cc2811762..ae7f8b095a7384b507f9260062a68e5094a4e1b4 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 6c37c9fd33f72fcadd04a5302ffbc09edce8d30d..da83cc496aa1cb1375c992f9dbfdebe578d7a6c4 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 a0ee59deb3f5f1643f65934e4b1d53d760fe70ca..a74f9315800c0927f1f1f4c6cb48489a29e1a090 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 6bab457488da67861e6840f1c465730c93266a07..f567416381c606af25f164ed5acae1ae4a385e70 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 310b2e6a4e1d056fb9d0257e9d543e662709e6dd..6d66a625ba440dc09bac63a80e4109e1325ff73b 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 8b3d1df8d05fdafeef5d2e07b6185ed58e220a42..a8b46b0e3386a50848680285abff29223efcd883 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 1c4db86823c6e41ec5fc3ab3f20194516eaffa06..dffdac7ebfa9dc2c40e6a234dc9712cb134d8092 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 bba678a2a71b64e25b2f0077df9654cddb1fc60f..4504e408bf7a0378cf4980fdd7760633c28d32f6 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 89a506ff5017a36fe8ae69811b515d4e4c5bbf61..0b0a51802878f43a73a08714a4b1d56e8c04493c 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 a57a5e20b19efe48696ff89c12e690a76e625de9..dc1d66606122812851f6104f7c33be4935682ac9 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 89cd294f87308b8fc849865ce00c9ac47736e4db..d72d0cafc294abee443e907377fa62af5e045fc5 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 60967c2a50921a83d6be8278873e50a7d236b6d2..1bc9b40e6fe9ca797cbf67e76d6e6655eb0975a6 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 e79b646e228972005e58fe50fbc2953203cb7ae3..3abc4d921427414092c08a6ceb7c1adc62d7b5ee 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 3bf421383d85a014ecc7221c97a3452a31831756..6f1bc9ff79b0d278d89251669bbc0e29ae4b4cf0 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 9cb527668d2aac54724fc33c9886638d45386e49..8029333e59f481224a0537d2e6e12ca70b8fce1e 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 d6676e30a467f93be3ba6a707b09f2fb8d91f805..eba3021c68d3e060ad75c9e91af898ebc186a3a4 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 cc17dd63efcd06737a60de80963dc143378661ad..29b36d65b17d5f1aa5af92ecbba4dc2862dda906 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 6e2a0d652542663fa7b2f448c95f3096a4cb042c..d01daf3b069628cb8484633318e69978fb7b10cf 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 6b1397ebf737c1ef1749048fe2176850d426599f..9e3f92bad271286665747045e6cd4d0d62253b68 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 397879697ac359f0ac657edc811cbc298108d025..848eda5f00653098a58d9f34c6293243f77c6841 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 58f91aa905ebbd0034b6cbfda4717ab7c226754b..0adef0f38503e3265c714041cd798f8ba26b77d2 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 8df02e4e5c84267b36b057810be2c49adc80ee7a..6af94581c647831424443119e6ec2d43a1fcc568 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 68225990144f016bce88d21f2dbe94f59f718a5b..b79792f48d88bfb671be63043a78a8b855f9b70b 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 eb97a0b31b6a9a2a34c6863a75d971c369b1d313..f8bfdb4146176ee196d41ad0a886441e009cca38 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 83f8119e3dbafbb72dc723fa4dc13c041bfe86b7..b178bd4818b3b06c5c96dfc66125ad46a8381367 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 44797af8ec71a028e68baee13d31282f54f0f65a..0d15fdf86db80c6dde2ee210015abe0fc8508179 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 470555023ef993d145293def651cbd8c4f3f3763..6eb63bb85521fe9b49cbcf64c5c06c4d2150cd67 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 ab0a8ce21db4b2ee037b0750f79b361506a035e5..63bf3866e0ec37f8d604dfdc7dee72f4952e6949 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 bcaeeca8177d1c1d6d81a25d3d7cc8cef550fe41..d21a4e03ca0c64166e0d9ece9b200d60bcca1ba3 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 465c35b79e347789918bd1ab01d6d5539814f40c..763aea583b0335cb5f8b62f7b697129ed42ac508 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 e1b01853f20770a4d7e74f74241552f2846f73c1..3213c2bf7fdfd070c83d891a9e4f4c96ec8270e2 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 468f457f64c26692f2dffee9ea707217d9651bd0..830c3030cc089fffb356d8f2a72d04313c673c81 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 1f60c5cf7a492ab4540223bd8ac7028ca5a04f57..bb30f3d0c1bb55d4723a56494fb74f2730281f76 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 f439f58e7f81613650ca4a195aab921ca1e40ccc..782cad9c515a05b712049097f6e6f0bcbe1dcbd7 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 428920040b72723bf645009d4b4a762eb93d8484..9416919f8ab528d26800c5c9be07dc768760c030 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 f576dcf021b8498bad7d3567cafef54ba765b073..3f7db1b1f1ddcf0f6c80e1fb44c42bdcb5b991be 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 7d49e04cd754665d2fc7cb45f7f32809159be534..6543b3e1e102d16182f8faeda6fc6a5a580aab12 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 00e1b13b810631da567ac26d2904a72ee8b45dba..c091d8d06d68f0da34ebed147481269b9aba6e28 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 75415d023fc74c3dff4b797aba30fd4e53592de3..f3dbef95f7d98bb0a4f039d6cd4592f7e321963c 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 e93e9366b42c4f16f81328c0bf24bc50b8e94b6a..0d00e3ee17ede242a20426b55897604323bc9cc8 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 5f6d66d6fef73565aa733e2c7c841223239dea3d..1db82be1c9d212d1b69b71c73988e87ecd6c2bae 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 9cce7b2d71cbf3154ee124a9c7b45e5dca73fc32..5c4ecc9c3390a70b47e6d7d1f666eb99a868492c 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 a30bb39cb178028eb963ad01b4bb7c287310a7e6..a844ad63c5c05d137740e1fcd1fdbde963169e00 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 4fc17d987a6c594a801008752d45427809b4e214..f4a8f2fcd0cc09e5ab84fd713bca9554245622d1 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 c220bdbec06f92cb117c9a729f111102c32bc298..2b1cc42ed7063454bac182a14bebb7828559fa68 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 c1980a8a7232ec4e5d91b276df3e60633697fa21..065f80a3fdcee020bf0f1b66195f6ab43aa67e6a 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 832ae32231eb4d24cc0a5341bc31590e26442cda..192373d5ec64596c0aa66e296701d46ea9e337b8 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 1187716464e0aa70dd275f2e2297be0c693ede1b..92e37dd5b9156a542dc9a80f8299a0ee9abdea26 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 5d1dfd497b23e632749e2138035bd6040d14816d..f32be14541bd6d95a674072142449d04bb4f58a7 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());
+        } 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;
         }
-        case SizeNone: {
-            // If both values are ‘auto’ then the intrinsic width and/or height of the image should be used, if any.
-            if (!imageIntrinsicSize.isEmpty())
-                return imageIntrinsicSize;
 
-            // If the image has neither an intrinsic width nor an intrinsic height, its size is determined as for ‘contain’.
-            type = Contain;
-        }
-        FALLTHROUGH;
-        case Contain:
-        case Cover: {
-            // Scale computation needs higher precision than what LayoutUnit can offer.
-            FloatSize localImageIntrinsicSize = imageIntrinsicSize;
-            FloatSize localPositioningAreaSize = positioningAreaSize;
-
-            float horizontalScaleFactor = localImageIntrinsicSize.width() ? (localPositioningAreaSize.width() / localImageIntrinsicSize.width()) : 1;
-            float verticalScaleFactor = localImageIntrinsicSize.height() ? (localPositioningAreaSize.height() / localImageIntrinsicSize.height()) : 1;
-            float scaleFactor = type == Contain ? std::min(horizontalScaleFactor, verticalScaleFactor) : std::max(horizontalScaleFactor, verticalScaleFactor);
-            float deviceScaleFactor = document().deviceScaleFactor();
-            return LayoutSize(std::max<LayoutUnit>(1 / deviceScaleFactor, localImageIntrinsicSize.width() * scaleFactor),
-                std::max<LayoutUnit>(1 / deviceScaleFactor, localImageIntrinsicSize.height() * scaleFactor));
-       }
+        tileSize.clampNegativeToZero();
+        return tileSize;
+    }
+    case FillSizeType::None: {
+        // If both values are ‘auto’ then the intrinsic width and/or height of the image should be used, if any.
+        if (!imageIntrinsicSize.isEmpty())
+            return imageIntrinsicSize;
+
+        // If the image has neither an intrinsic width nor an intrinsic height, its size is determined as for ‘contain’.
+        type = FillSizeType::Contain;
+    }
+    FALLTHROUGH;
+    case FillSizeType::Contain:
+    case FillSizeType::Cover: {
+        // Scale computation needs higher precision than what LayoutUnit can offer.
+        FloatSize localImageIntrinsicSize = imageIntrinsicSize;
+        FloatSize localPositioningAreaSize = positioningAreaSize;
+
+        float horizontalScaleFactor = localImageIntrinsicSize.width() ? (localPositioningAreaSize.width() / localImageIntrinsicSize.width()) : 1;
+        float verticalScaleFactor = localImageIntrinsicSize.height() ? (localPositioningAreaSize.height() / localImageIntrinsicSize.height()) : 1;
+        float scaleFactor = type == FillSizeType::Contain ? std::min(horizontalScaleFactor, verticalScaleFactor) : std::max(horizontalScaleFactor, verticalScaleFactor);
+        float deviceScaleFactor = document().deviceScaleFactor();
+        return LayoutSize(std::max<LayoutUnit>(1 / deviceScaleFactor, localImageIntrinsicSize.width() * scaleFactor),
+            std::max<LayoutUnit>(1 / deviceScaleFactor, localImageIntrinsicSize.height() * scaleFactor));
+    }
     }
 
     ASSERT_NOT_REACHED();
@@ -1196,18 +1196,18 @@ BackgroundImageGeometry RenderBoxModelObject::calculateBackgroundImageGeometry(c
     // Destination rect will be adjusted later if the background is non-repeating.
     // FIXME: transforms spec says that fixed backgrounds behave like scroll inside transforms. https://bugs.webkit.org/show_bug.cgi?id=15679
     LayoutRect destinationRect(borderBoxRect);
-    bool fixedAttachment = fillLayer.attachment() == FixedBackgroundAttachment;
+    bool fixedAttachment = fillLayer.attachment() == FillAttachment::FixedBackground;
     float deviceScaleFactor = document().deviceScaleFactor();
     if (!fixedAttachment) {
         LayoutUnit right = 0;
         LayoutUnit bottom = 0;
         // Scroll and Local.
-        if (fillLayer.origin() != BorderFillBox) {
+        if (fillLayer.origin() != FillBox::Border) {
             left = borderLeft();
             right = borderRight();
             top = borderTop();
             bottom = borderBottom();
-            if (fillLayer.origin() == ContentFillBox) {
+            if (fillLayer.origin() == FillBox::Content) {
                 left += paddingLeft();
                 right += paddingRight();
                 top += paddingTop();
@@ -1281,8 +1281,8 @@ BackgroundImageGeometry RenderBoxModelObject::calculateBackgroundImageGeometry(c
     if (StyleImage* layerImage = fillLayer.image())
         layerImage->setContainerContextForRenderer(*clientForBackgroundImage, tileSize, style().effectiveZoom());
     
-    EFillRepeat backgroundRepeatX = fillLayer.repeatX();
-    EFillRepeat backgroundRepeatY = fillLayer.repeatY();
+    FillRepeat backgroundRepeatX = fillLayer.repeatX();
+    FillRepeat backgroundRepeatY = fillLayer.repeatY();
     LayoutUnit availableWidth = positioningAreaSize.width() - tileSize.width();
     LayoutUnit availableHeight = positioningAreaSize.height() - tileSize.height();
 
@@ -1290,9 +1290,9 @@ BackgroundImageGeometry RenderBoxModelObject::calculateBackgroundImageGeometry(c
     LayoutSize phase;