Attachment 346029 Details for Bug 188147 – Patch

[patch] Patch

bug-188147-20180729083050.patch (text/plain), 134.74 KB, created by Simon Fraser (smfr) on 2018-07-29 08:30:52 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Simon Fraser (smfr)

Created: 2018-07-29 08:30:52 PDT

Size: 134.74 KB

patch

obsolete

>Subversion Revision: 234343
>diff --git a/Source/WebCore/ChangeLog b/Source/WebCore/ChangeLog
>index 2adfc11b9ff0b6efa8cbbcbb2d3888bdd45caff9..6b60cbd0c978547c950aae7b2b7e187ddfeafffc 100644
>--- a/Source/WebCore/ChangeLog
>+++ b/Source/WebCore/ChangeLog
>@@ -1,3 +1,174 @@
>+2018-07-29  Simon Fraser  <simon.fraser@apple.com>
>+
>+        Make CompositeOperator and BlendMode into 8-bit enum classes
>+        https://bugs.webkit.org/show_bug.cgi?id=188147
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        These enums can both be shrunk to be 8-bit. Requires some static_cast<>ing
>+        in various places.
>+
>+        * css/CSSPrimitiveValueMappings.h:
>+        (WebCore::CSSPrimitiveValue::CSSPrimitiveValue):
>+        (WebCore::CSSPrimitiveValue::operator CompositeOperator const):
>+        (WebCore::CSSPrimitiveValue::operator BlendMode const):
>+        * html/HTMLImageElement.cpp:
>+        (WebCore::HTMLImageElement::HTMLImageElement):
>+        (WebCore::HTMLImageElement::parseAttribute):
>+        * html/canvas/CanvasRenderingContext2D.cpp:
>+        (WebCore::CanvasRenderingContext2D::drawTextInternal):
>+        * html/canvas/CanvasRenderingContext2DBase.cpp:
>+        (WebCore::CanvasRenderingContext2DBase::State::State):
>+        (WebCore::CanvasRenderingContext2DBase::setGlobalCompositeOperation):
>+        (WebCore::CanvasRenderingContext2DBase::isFullCanvasCompositeMode):
>+        (WebCore::CanvasRenderingContext2DBase::fillInternal):
>+        (WebCore::CanvasRenderingContext2DBase::strokeInternal):
>+        (WebCore::CanvasRenderingContext2DBase::clearRect):
>+        (WebCore::CanvasRenderingContext2DBase::fillRect):
>+        (WebCore::CanvasRenderingContext2DBase::strokeRect):
>+        (WebCore::CanvasRenderingContext2DBase::drawImage):
>+        (WebCore::CanvasRenderingContext2DBase::drawImageFromRect):
>+        (WebCore::CanvasRenderingContext2DBase::fullCanvasCompositedDrawImage):
>+        * platform/graphics/BitmapImage.h:
>+        * platform/graphics/CrossfadeGeneratedImage.cpp:
>+        (WebCore::drawCrossfadeSubimage):
>+        (WebCore::CrossfadeGeneratedImage::drawCrossfade):
>+        * platform/graphics/GraphicsContext.h:
>+        (WebCore::ImagePaintingOptions::ImagePaintingOptions):
>+        * platform/graphics/GraphicsContextImpl.h:
>+        * platform/graphics/GraphicsLayer.cpp:
>+        (WebCore::GraphicsLayer::dumpProperties const):
>+        * platform/graphics/GraphicsLayer.h:
>+        * platform/graphics/GraphicsTypes.cpp:
>+        (WebCore::parseBlendMode):
>+        (WebCore::parseCompositeAndBlendOperator):
>+        (WebCore::compositeOperatorName):
>+        (WebCore::blendModeName):
>+        (WebCore::operator<<):
>+        * platform/graphics/GraphicsTypes.h:
>+        * platform/graphics/Image.cpp:
>+        (WebCore::Image::fillWithSolidColor):
>+        (WebCore::Image::drawTiled):
>+        * platform/graphics/Image.h:
>+        * platform/graphics/ImageBuffer.h:
>+        * platform/graphics/ShadowBlur.cpp:
>+        (WebCore::ShadowBlur::blurAndColorShadowBuffer):
>+        * platform/graphics/ca/cocoa/PlatformCAFiltersCocoa.mm:
>+        (PlatformCAFilters::setBlendingFiltersOnLayer):
>+        * platform/graphics/cairo/CairoOperations.cpp:
>+        (WebCore::Cairo::drawShadowLayerBuffer):
>+        (WebCore::Cairo::drawNativeImage):
>+        * platform/graphics/cairo/CairoOperations.h:
>+        * platform/graphics/cairo/CairoUtilities.cpp:
>+        (WebCore::toCairoCompositeOperator):
>+        (WebCore::toCairoOperator):
>+        * platform/graphics/cairo/CairoUtilities.h:
>+        * platform/graphics/cairo/GraphicsContextImplCairo.cpp:
>+        (WebCore::GraphicsContextImplCairo::fillRect):
>+        (WebCore::GraphicsContextImplCairo::fillRoundedRect):
>+        * platform/graphics/cairo/GraphicsContextImplCairo.h:
>+        * platform/graphics/cg/GraphicsContext3DCG.cpp:
>+        (WebCore::GraphicsContext3D::paintToCanvas):
>+        * platform/graphics/cg/GraphicsContextCG.cpp:
>+        (WebCore::selectCGBlendMode):
>+        * platform/graphics/cpu/arm/filters/FEBlendNEON.h:
>+        (WebCore::FEBlend::platformApplyNEON):
>+        * platform/graphics/displaylists/DisplayListItems.h:
>+        * platform/graphics/displaylists/DisplayListRecorder.h:
>+        * platform/graphics/filters/FEBlend.cpp:
>+        (WebCore::FEBlend::platformApplySoftware):
>+        (WebCore::FEBlend::externalRepresentation const):
>+        * platform/graphics/filters/FEComposite.cpp:
>+        (WebCore::FEComposite::platformApplySoftware):
>+        * platform/graphics/filters/FEDropShadow.cpp:
>+        (WebCore::FEDropShadow::platformApplySoftware):
>+        * platform/graphics/filters/SourceAlpha.cpp:
>+        (WebCore::SourceAlpha::platformApplySoftware):
>+        * platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp:
>+        (WebCore::MediaPlayerPrivateGStreamerBase::paint):
>+        * platform/graphics/nicosia/NicosiaPaintingEngineBasic.cpp:
>+        (Nicosia::PaintingEngineBasic::paint):
>+        * platform/graphics/nicosia/NicosiaPaintingEngineThreaded.cpp:
>+        (Nicosia::paintLayer):
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp:
>+        (Nicosia::CairoOperationRecorder::fillRect):
>+        (Nicosia::CairoOperationRecorder::fillRoundedRect):
>+        * platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h:
>+        * platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp:
>+        (WebCore::CoordinatedImageBacking::update):
>+        * platform/graphics/win/GraphicsContextDirect2D.cpp:
>+        (WebCore::GraphicsContext::setPlatformCompositeOperation):
>+        * platform/graphics/win/ImageCGWin.cpp:
>+        (WebCore::BitmapImage::getHBITMAPOfSize):
>+        (WebCore::BitmapImage::drawFrameMatchingSourceSize):
>+        * platform/graphics/win/ImageCairoWin.cpp:
>+        (WebCore::BitmapImage::getHBITMAPOfSize):
>+        (WebCore::BitmapImage::drawFrameMatchingSourceSize):
>+        * platform/graphics/win/ImageDirect2D.cpp:
>+        (WebCore::BitmapImage::drawFrameMatchingSourceSize):
>+        * rendering/InlineFlowBox.cpp:
>+        (WebCore::InlineFlowBox::paintBoxDecorations):
>+        (WebCore::InlineFlowBox::paintMask):
>+        * rendering/InlineFlowBox.h:
>+        * rendering/RenderBox.cpp:
>+        (WebCore::RenderBox::paintRootBoxFillLayers):
>+        (WebCore::RenderBox::paintBackground):
>+        (WebCore::RenderBox::paintMaskImages):
>+        (WebCore::RenderBox::paintFillLayers):
>+        * rendering/RenderBox.h:
>+        * rendering/RenderBoxModelObject.cpp:
>+        (WebCore::RenderBoxModelObject::paintFillLayerExtended):
>+        * rendering/RenderBoxModelObject.h:
>+        * rendering/RenderEmbeddedObject.cpp:
>+        (WebCore::RenderEmbeddedObject::paintReplaced):
>+        * rendering/RenderImage.cpp:
>+        (WebCore::RenderImage::paintIntoRect):
>+        * rendering/RenderLayer.cpp:
>+        (WebCore::RenderLayer::RenderLayer):
>+        (WebCore::RenderLayer::updateBlendMode):
>+        (WebCore::RenderLayer::beginTransparencyLayers):
>+        * rendering/RenderLayer.h:
>+        * rendering/RenderLayerBacking.cpp:
>+        (WebCore::RenderLayerBacking::updateBlendMode):
>+        (WebCore::supportsDirectlyCompositedBoxDecorations):
>+        * rendering/RenderTableCell.cpp:
>+        (WebCore::RenderTableCell::paintBackgroundsBehindCell):
>+        * rendering/RenderThemeMac.mm:
>+        (WebCore::RenderThemeMac::paintSnapshottedPluginOverlay):
>+        * rendering/RenderTreeAsText.cpp:
>+        (WebCore::writeLayer):
>+        * rendering/RenderView.cpp:
>+        (WebCore::RenderView::paintBoxDecorations):
>+        * rendering/style/FillLayer.cpp:
>+        (WebCore::FillLayer::FillLayer):
>+        (WebCore::FillLayer::hasOpaqueImage const):
>+        * rendering/style/FillLayer.h:
>+        (WebCore::FillLayer::initialFillComposite):
>+        (WebCore::FillLayer::initialFillBlendMode):
>+        * rendering/style/RenderStyle.h:
>+        (WebCore::RenderStyle::setBlendMode):
>+        (WebCore::RenderStyle::hasBlendMode const):
>+        (WebCore::RenderStyle::blendMode const):
>+        (WebCore::RenderStyle::initialBlendMode):
>+        * rendering/style/StyleRareNonInheritedData.cpp:
>+        (WebCore::StyleRareNonInheritedData::StyleRareNonInheritedData):
>+        * rendering/style/StyleRareNonInheritedData.h:
>+        * rendering/svg/SVGRenderingContext.cpp:
>+        (WebCore::SVGRenderingContext::prepareToRenderSVGContent):
>+        * svg/SVGAnimatedEnumeration.cpp:
>+        (WebCore::enumerationValueForTargetAttribute):
>+        * svg/SVGFEBlendElement.cpp:
>+        (WebCore::SVGFEBlendElement::SVGFEBlendElement):
>+        (WebCore::SVGFEBlendElement::parseAttribute):
>+        * svg/SVGFEBlendElement.h:
>+        (WebCore::SVGPropertyTraits<BlendMode>::highestEnumValue):
>+        (WebCore::SVGPropertyTraits<BlendMode>::toString):
>+        * svg/graphics/SVGImage.cpp:
>+        (WebCore::SVGImage::nativeImageForCurrentFrame):
>+        (WebCore::SVGImage::nativeImage):
>+        (WebCore::SVGImage::drawPatternForContainer):
>+        (WebCore::SVGImage::draw):
>+
> 2018-07-28  Simon Fraser  <simon.fraser@apple.com>
> 
>         Shrink GraphicsLayer by making m_transform and m_childrenTransform be unique_ptrs
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index edeee374dbe7d0cacbd63c6ebfc8f9dda556109f..4f11a3a04baffc06ad6cbf3668f92813701a42ce 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,19 @@
>+2018-07-29  Simon Fraser  <simon.fraser@apple.com>
>+
>+        Make CompositeOperator and BlendMode into 8-bit enum classes
>+        https://bugs.webkit.org/show_bug.cgi?id=188147
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        These enums can both be shrunk to be 8-bit. Requires some static_cast<>ing
>+        in various places.
>+
>+        * Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm:
>+        (WebKit::RemoteLayerTreeTransaction::LayerProperties::LayerProperties):
>+        * WebProcess/Plugins/PluginProxy.cpp:
>+        (WebKit::PluginProxy::paint):
>+        (WebKit::PluginProxy::update):
>+
> 2018-07-28  Simon Fraser  <simon.fraser@apple.com>
> 
>         Shrink GraphicsLayerCA
>diff --git a/Source/WebCore/css/CSSPrimitiveValueMappings.h b/Source/WebCore/css/CSSPrimitiveValueMappings.h
>index d14a451bf31c1b091196c6c057d3895b63f3159c..87e1c34a9194d184331ab6c376777deb2571001e 100644
>--- a/Source/WebCore/css/CSSPrimitiveValueMappings.h
>+++ b/Source/WebCore/css/CSSPrimitiveValueMappings.h
>@@ -334,46 +334,46 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(CompositeOperator e)
> {
>     m_primitiveUnitType = CSS_VALUE_ID;
>     switch (e) {
>-    case CompositeClear:
>+    case CompositeOperator::Clear:
>         m_value.valueID = CSSValueClear;
>         break;
>-    case CompositeCopy:
>+    case CompositeOperator::Copy:
>         m_value.valueID = CSSValueCopy;
>         break;
>-    case CompositeSourceOver:
>+    case CompositeOperator::SourceOver:
>         m_value.valueID = CSSValueSourceOver;
>         break;
>-    case CompositeSourceIn:
>+    case CompositeOperator::SourceIn:
>         m_value.valueID = CSSValueSourceIn;
>         break;
>-    case CompositeSourceOut:
>+    case CompositeOperator::SourceOut:
>         m_value.valueID = CSSValueSourceOut;
>         break;
>-    case CompositeSourceAtop:
>+    case CompositeOperator::SourceAtop:
>         m_value.valueID = CSSValueSourceAtop;
>         break;
>-    case CompositeDestinationOver:
>+    case CompositeOperator::DestinationOver:
>         m_value.valueID = CSSValueDestinationOver;
>         break;
>-    case CompositeDestinationIn:
>+    case CompositeOperator::DestinationIn:
>         m_value.valueID = CSSValueDestinationIn;
>         break;
>-    case CompositeDestinationOut:
>+    case CompositeOperator::DestinationOut:
>         m_value.valueID = CSSValueDestinationOut;
>         break;
>-    case CompositeDestinationAtop:
>+    case CompositeOperator::DestinationAtop:
>         m_value.valueID = CSSValueDestinationAtop;
>         break;
>-    case CompositeXOR:
>+    case CompositeOperator::XOR:
>         m_value.valueID = CSSValueXor;
>         break;
>-    case CompositePlusDarker:
>+    case CompositeOperator::PlusDarker:
>         m_value.valueID = CSSValuePlusDarker;
>         break;
>-    case CompositePlusLighter:
>+    case CompositeOperator::PlusLighter:
>         m_value.valueID = CSSValuePlusLighter;
>         break;
>-    case CompositeDifference:
>+    case CompositeOperator::Difference:
>         ASSERT_NOT_REACHED();
>         break;
>     }
>@@ -385,37 +385,37 @@ template<> inline CSSPrimitiveValue::operator CompositeOperator() const
> 
>     switch (m_value.valueID) {
>     case CSSValueClear:
>-        return CompositeClear;
>+        return CompositeOperator::Clear;
>     case CSSValueCopy:
>-        return CompositeCopy;
>+        return CompositeOperator::Copy;
>     case CSSValueSourceOver:
>-        return CompositeSourceOver;
>+        return CompositeOperator::SourceOver;
>     case CSSValueSourceIn:
>-        return CompositeSourceIn;
>+        return CompositeOperator::SourceIn;
>     case CSSValueSourceOut:
>-        return CompositeSourceOut;
>+        return CompositeOperator::SourceOut;
>     case CSSValueSourceAtop:
>-        return CompositeSourceAtop;
>+        return CompositeOperator::SourceAtop;
>     case CSSValueDestinationOver:
>-        return CompositeDestinationOver;
>+        return CompositeOperator::DestinationOver;
>     case CSSValueDestinationIn:
>-        return CompositeDestinationIn;
>+        return CompositeOperator::DestinationIn;
>     case CSSValueDestinationOut:
>-        return CompositeDestinationOut;
>+        return CompositeOperator::DestinationOut;
>     case CSSValueDestinationAtop:
>-        return CompositeDestinationAtop;
>+        return CompositeOperator::DestinationAtop;
>     case CSSValueXor:
>-        return CompositeXOR;
>+        return CompositeOperator::XOR;
>     case CSSValuePlusDarker:
>-        return CompositePlusDarker;
>+        return CompositeOperator::PlusDarker;
>     case CSSValuePlusLighter:
>-        return CompositePlusLighter;
>+        return CompositeOperator::PlusLighter;
>     default:
>         break;
>     }
> 
>     ASSERT_NOT_REACHED();
>-    return CompositeClear;
>+    return CompositeOperator::Clear;
> }
> 
> template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ControlPart e)
>@@ -3903,58 +3903,58 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(BlendMode blendMode)
> {
>     m_primitiveUnitType = CSS_VALUE_ID;
>     switch (blendMode) {
>-    case BlendModeNormal:
>+    case BlendMode::Normal:
>         m_value.valueID = CSSValueNormal;
>         break;
>-    case BlendModeMultiply:
>+    case BlendMode::Multiply:
>         m_value.valueID = CSSValueMultiply;
>         break;
>-    case BlendModeScreen:
>+    case BlendMode::Screen:
>         m_value.valueID = CSSValueScreen;
>         break;
>-    case BlendModeOverlay:
>+    case BlendMode::Overlay:
>         m_value.valueID = CSSValueOverlay;
>         break;
>-    case BlendModeDarken:
>+    case BlendMode::Darken:
>         m_value.valueID = CSSValueDarken;
>         break;
>-    case BlendModeLighten:
>+    case BlendMode::Lighten:
>         m_value.valueID = CSSValueLighten;
>         break;
>-    case BlendModeColorDodge:
>+    case BlendMode::ColorDodge:
>         m_value.valueID = CSSValueColorDodge;
>         break;
>-    case BlendModeColorBurn:
>+    case BlendMode::ColorBurn:
>         m_value.valueID = CSSValueColorBurn;
>         break;
>-    case BlendModeHardLight:
>+    case BlendMode::HardLight:
>         m_value.valueID = CSSValueHardLight;
>         break;
>-    case BlendModeSoftLight:
>+    case BlendMode::SoftLight:
>         m_value.valueID = CSSValueSoftLight;
>         break;
>-    case BlendModeDifference:
>+    case BlendMode::Difference:
>         m_value.valueID = CSSValueDifference;
>         break;
>-    case BlendModeExclusion:
>+    case BlendMode::Exclusion:
>         m_value.valueID = CSSValueExclusion;
>         break;
>-    case BlendModeHue:
>+    case BlendMode::Hue:
>         m_value.valueID = CSSValueHue;
>         break;
>-    case BlendModeSaturation:
>+    case BlendMode::Saturation:
>         m_value.valueID = CSSValueSaturation;
>         break;
>-    case BlendModeColor:
>+    case BlendMode::Color:
>         m_value.valueID = CSSValueColor;
>         break;
>-    case BlendModeLuminosity:
>+    case BlendMode::Luminosity:
>         m_value.valueID = CSSValueLuminosity;
>         break;
>-    case BlendModePlusDarker:
>+    case BlendMode::PlusDarker:
>         m_value.valueID = CSSValuePlusDarker;
>         break;
>-    case BlendModePlusLighter:
>+    case BlendMode::PlusLighter:
>         m_value.valueID = CSSValuePlusLighter;
>         break;
>     }
>@@ -3966,47 +3966,47 @@ template<> inline CSSPrimitiveValue::operator BlendMode() const
> 
>     switch (m_value.valueID) {
>     case CSSValueNormal:
>-        return BlendModeNormal;
>+        return BlendMode::Normal;
>     case CSSValueMultiply:
>-        return BlendModeMultiply;
>+        return BlendMode::Multiply;
>     case CSSValueScreen:
>-        return BlendModeScreen;
>+        return BlendMode::Screen;
>     case CSSValueOverlay:
>-        return BlendModeOverlay;
>+        return BlendMode::Overlay;
>     case CSSValueDarken:
>-        return BlendModeDarken;
>+        return BlendMode::Darken;
>     case CSSValueLighten:
>-        return BlendModeLighten;
>+        return BlendMode::Lighten;
>     case CSSValueColorDodge:
>-        return BlendModeColorDodge;
>+        return BlendMode::ColorDodge;
>     case CSSValueColorBurn:
>-        return BlendModeColorBurn;
>+        return BlendMode::ColorBurn;
>     case CSSValueHardLight:
>-        return BlendModeHardLight;
>+        return BlendMode::HardLight;
>     case CSSValueSoftLight:
>-        return BlendModeSoftLight;
>+        return BlendMode::SoftLight;
>     case CSSValueDifference:
>-        return BlendModeDifference;
>+        return BlendMode::Difference;
>     case CSSValueExclusion:
>-        return BlendModeExclusion;
>+        return BlendMode::Exclusion;
>     case CSSValueHue:
>-        return BlendModeHue;
>+        return BlendMode::Hue;
>     case CSSValueSaturation:
>-        return BlendModeSaturation;
>+        return BlendMode::Saturation;
>     case CSSValueColor:
>-        return BlendModeColor;
>+        return BlendMode::Color;
>     case CSSValueLuminosity:
>-        return BlendModeLuminosity;
>+        return BlendMode::Luminosity;
>     case CSSValuePlusDarker:
>-        return BlendModePlusDarker;
>+        return BlendMode::PlusDarker;
>     case CSSValuePlusLighter:
>-        return BlendModePlusLighter;
>+        return BlendMode::PlusLighter;
>     default:
>         break;
>     }
> 
>     ASSERT_NOT_REACHED();
>-    return BlendModeNormal;
>+    return BlendMode::Normal;
> }
> 
> template<> inline CSSPrimitiveValue::CSSPrimitiveValue(Isolation isolation)
>diff --git a/Source/WebCore/html/HTMLImageElement.cpp b/Source/WebCore/html/HTMLImageElement.cpp
>index 128f907eb985721487550f9800893491ca5babe5..886977ad22b998c47f55a4bcc8ed3a03763c5b1d 100644
>--- a/Source/WebCore/html/HTMLImageElement.cpp
>+++ b/Source/WebCore/html/HTMLImageElement.cpp
>@@ -67,7 +67,7 @@ HTMLImageElement::HTMLImageElement(const QualifiedName& tagName, Document& docum
>     , m_imageLoader(*this)
>     , m_form(nullptr)
>     , m_formSetByParser(form)
>-    , m_compositeOperator(CompositeSourceOver)
>+    , m_compositeOperator(CompositeOperator::SourceOver)
>     , m_imageDevicePixelRatio(1.0f)
> #if ENABLE(SERVICE_CONTROLS)
>     , m_experimentalImageMenuEnabled(false)
>@@ -221,9 +221,9 @@ void HTMLImageElement::parseAttribute(const QualifiedName& name, const AtomicStr
>             treeScope().addImageElementByUsemap(*m_parsedUsemap.impl(), *this);
>     } else if (name == compositeAttr) {
>         // FIXME: images don't support blend modes in their compositing attribute.
>-        BlendMode blendOp = BlendModeNormal;
>+        BlendMode blendOp = BlendMode::Normal;
>         if (!parseCompositeAndBlendOperator(value, m_compositeOperator, blendOp))
>-            m_compositeOperator = CompositeSourceOver;
>+            m_compositeOperator = CompositeOperator::SourceOver;
> #if ENABLE(SERVICE_CONTROLS)
>     } else if (name == webkitimagemenuAttr) {
>         m_experimentalImageMenuEnabled = !value.isNull();
>diff --git a/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp b/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp
>index e9ae63c4980d53925222f41959482e98145d77e6..df971c596d8aa3790071a23b678c83dca6f3859f 100644
>--- a/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp
>+++ b/Source/WebCore/html/canvas/CanvasRenderingContext2D.cpp
>@@ -578,7 +578,7 @@ void CanvasRenderingContext2D::drawTextInternal(const String& text, float x, flo
>         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
>         endCompositeLayer();
>         didDrawEntireCanvas();
>-    } else if (state().globalComposite == CompositeCopy) {
>+    } else if (state().globalComposite == CompositeOperator::Copy) {
>         clearCanvas();
>         fontProxy.drawBidiText(*c, textRun, location, FontCascade::UseFallbackIfFontNotReady);
>         didDrawEntireCanvas();
>diff --git a/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp b/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp
>index 6202ea59f8e8e12f7ae2b8970ecd0ed1ada9838c..ebf84d9a7f3ed1a5806d51fe9129359a73c66487 100644
>--- a/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp
>+++ b/Source/WebCore/html/canvas/CanvasRenderingContext2DBase.cpp
>@@ -198,8 +198,8 @@ CanvasRenderingContext2DBase::State::State()
>     , shadowBlur(0)
>     , shadowColor(Color::transparent)
>     , globalAlpha(1)
>-    , globalComposite(CompositeSourceOver)
>-    , globalBlend(BlendModeNormal)
>+    , globalComposite(CompositeOperator::SourceOver)
>+    , globalBlend(BlendMode::Normal)
>     , hasInvertibleTransform(true)
>     , lineDashOffset(0)
>     , imageSmoothingEnabled(true)
>@@ -773,8 +773,8 @@ String CanvasRenderingContext2DBase::globalCompositeOperation() const
> 
> void CanvasRenderingContext2DBase::setGlobalCompositeOperation(const String& operation)
> {
>-    CompositeOperator op = CompositeSourceOver;
>-    BlendMode blendMode = BlendModeNormal;
>+    CompositeOperator op = CompositeOperator::SourceOver;
>+    BlendMode blendMode = BlendMode::Normal;
>     if (!parseCompositeAndBlendOperator(operation, op, blendMode))
>         return;
>     if ((state().globalComposite == op) && (state().globalBlend == blendMode))
>@@ -1039,9 +1039,9 @@ static bool validateRectForCanvas(float& x, float& y, float& width, float& heigh
> bool CanvasRenderingContext2DBase::isFullCanvasCompositeMode(CompositeOperator op)
> {
>     // See 4.8.11.1.3 Compositing
>-    // CompositeSourceAtop and CompositeDestinationOut are not listed here as the platforms already
>+    // CompositeOperator::SourceAtop and CompositeOperator::DestinationOut are not listed here as the platforms already
>     // implement the specification's behavior.
>-    return op == CompositeSourceIn || op == CompositeSourceOut || op == CompositeDestinationIn || op == CompositeDestinationAtop;
>+    return op == CompositeOperator::SourceIn || op == CompositeOperator::SourceOut || op == CompositeOperator::DestinationIn || op == CompositeOperator::DestinationAtop;
> }
> 
> static WindRule toWindRule(CanvasFillRule rule)
>@@ -1104,7 +1104,7 @@ void CanvasRenderingContext2DBase::fillInternal(const Path& path, CanvasFillRule
>             c->fillPath(path);
>             endCompositeLayer();
>             didDrawEntireCanvas();
>-        } else if (state().globalComposite == CompositeCopy) {
>+        } else if (state().globalComposite == CompositeOperator::Copy) {
>             clearCanvas();
>             c->fillPath(path);
>             didDrawEntireCanvas();
>@@ -1136,7 +1136,7 @@ void CanvasRenderingContext2DBase::strokeInternal(const Path& path)
>             c->strokePath(path);
>             endCompositeLayer();
>             didDrawEntireCanvas();
>-        } else if (state().globalComposite == CompositeCopy) {
>+        } else if (state().globalComposite == CompositeOperator::Copy) {
>             clearCanvas();
>             c->strokePath(path);
>             didDrawEntireCanvas();
>@@ -1251,12 +1251,12 @@ void CanvasRenderingContext2DBase::clearRect(float x, float y, float width, floa
>         }
>         context->setAlpha(1);
>     }
>-    if (state().globalComposite != CompositeSourceOver) {
>+    if (state().globalComposite != CompositeOperator::SourceOver) {
>         if (!saved) {
>             context->save();
>             saved = true;
>         }
>-        context->setCompositeOperation(CompositeSourceOver);
>+        context->setCompositeOperation(CompositeOperator::SourceOver);
>     }
>     context->clearRect(rect);
>     if (saved)
>@@ -1292,7 +1292,7 @@ void CanvasRenderingContext2DBase::fillRect(float x, float y, float width, float
>         c->fillRect(rect);
>         endCompositeLayer();
>         didDrawEntireCanvas();
>-    } else if (state().globalComposite == CompositeCopy) {
>+    } else if (state().globalComposite == CompositeOperator::Copy) {
>         clearCanvas();
>         c->fillRect(rect);
>         didDrawEntireCanvas();
>@@ -1326,7 +1326,7 @@ void CanvasRenderingContext2DBase::strokeRect(float x, float y, float width, flo
>         c->strokeRect(rect, state().lineWidth);
>         endCompositeLayer();
>         didDrawEntireCanvas();
>-    } else if (state().globalComposite == CompositeCopy) {
>+    } else if (state().globalComposite == CompositeOperator::Copy) {
>         clearCanvas();
>         c->strokeRect(rect, state().lineWidth);
>         didDrawEntireCanvas();
>@@ -1548,7 +1548,7 @@ ExceptionOr<void> CanvasRenderingContext2DBase::drawImage(HTMLImageElement& imag
>     } else if (isFullCanvasCompositeMode(op)) {
>         fullCanvasCompositedDrawImage(*image, normalizedDstRect, normalizedSrcRect, op);
>         didDrawEntireCanvas();
>-    } else if (op == CompositeCopy) {
>+    } else if (op == CompositeOperator::Copy) {
>         clearCanvas();
>         c->drawImage(*image, normalizedDstRect, normalizedSrcRect, ImagePaintingOptions(op, blendMode));
>         didDrawEntireCanvas();
>@@ -1608,7 +1608,7 @@ ExceptionOr<void> CanvasRenderingContext2DBase::drawImage(HTMLCanvasElement& sou
>     } else if (isFullCanvasCompositeMode(state().globalComposite)) {
>         fullCanvasCompositedDrawImage(*buffer, dstRect, srcRect, state().globalComposite);
>         didDrawEntireCanvas();
>-    } else if (state().globalComposite == CompositeCopy) {
>+    } else if (state().globalComposite == CompositeOperator::Copy) {
>         clearCanvas();
>         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
>         didDrawEntireCanvas();
>@@ -1699,7 +1699,7 @@ ExceptionOr<void> CanvasRenderingContext2DBase::drawImage(ImageBitmap& imageBitm
>     } else if (isFullCanvasCompositeMode(state().globalComposite)) {
>         fullCanvasCompositedDrawImage(*buffer, dstRect, srcRect, state().globalComposite);
>         didDrawEntireCanvas();
>-    } else if (state().globalComposite == CompositeCopy) {
>+    } else if (state().globalComposite == CompositeOperator::Copy) {
>         clearCanvas();
>         c->drawImageBuffer(*buffer, dstRect, srcRect, ImagePaintingOptions(state().globalComposite, state().globalBlend));
>         didDrawEntireCanvas();
>@@ -1714,10 +1714,10 @@ ExceptionOr<void> CanvasRenderingContext2DBase::drawImage(ImageBitmap& imageBitm
> void CanvasRenderingContext2DBase::drawImageFromRect(HTMLImageElement& imageElement, float sx, float sy, float sw, float sh, float dx, float dy, float dw, float dh, const String& compositeOperation)
> {
>     CompositeOperator op;
>-    auto blendOp = BlendModeNormal;
>-    if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != BlendModeNormal)
>-        op = CompositeSourceOver;
>-    drawImage(imageElement, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh }, op, BlendModeNormal);
>+    auto blendOp = BlendMode::Normal;
>+    if (!parseCompositeAndBlendOperator(compositeOperation, op, blendOp) || blendOp != BlendMode::Normal)
>+        op = CompositeOperator::SourceOver;
>+    drawImage(imageElement, FloatRect { sx, sy, sw, sh }, FloatRect { dx, dy, dw, dh }, op, BlendMode::Normal);
> }
> 
> void CanvasRenderingContext2DBase::clearCanvas()
>@@ -1835,7 +1835,7 @@ template<class T> void CanvasRenderingContext2DBase::fullCanvasCompositedDrawIma
>     buffer->context().translate(-transformedAdjustedRect.location());
>     buffer->context().translate(croppedOffset);
>     buffer->context().concatCTM(effectiveTransform);
>-    drawImageToContext(image, buffer->context(), adjustedDest, src, CompositeSourceOver);
>+    drawImageToContext(image, buffer->context(), adjustedDest, src, CompositeOperator::SourceOver);
> 
>     compositeBuffer(*buffer, bufferRect, op);
> }
>diff --git a/Source/WebCore/platform/graphics/BitmapImage.h b/Source/WebCore/platform/graphics/BitmapImage.h
>index 5a6c3d920abae16f6923e237e80e6961afb5af0b..729d57dee81e213777bd35d7a3dd2ec8d99798a9 100644
>--- a/Source/WebCore/platform/graphics/BitmapImage.h
>+++ b/Source/WebCore/platform/graphics/BitmapImage.h
>@@ -162,7 +162,7 @@ protected:
>     void destroyDecodedDataIfNecessary(bool destroyAll = true);
> 
>     ImageDrawResult draw(GraphicsContext&, const FloatRect& dstRect, const FloatRect& srcRect, CompositeOperator, BlendMode, DecodingMode, ImageOrientationDescription) override;
>-    void drawPattern(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal) override;
>+    void drawPattern(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendMode::Normal) override;
> #if PLATFORM(WIN)
>     void drawFrameMatchingSourceSize(GraphicsContext&, const FloatRect& dstRect, const IntSize& srcSize, CompositeOperator) override;
> #endif
>diff --git a/Source/WebCore/platform/graphics/CrossfadeGeneratedImage.cpp b/Source/WebCore/platform/graphics/CrossfadeGeneratedImage.cpp
>index ec856c8f7ada2e2485bf4d90343f9249862b0682..f191eac8aa1ffc59940d60f22d3d05ba98770b0f 100644
>--- a/Source/WebCore/platform/graphics/CrossfadeGeneratedImage.cpp
>+++ b/Source/WebCore/platform/graphics/CrossfadeGeneratedImage.cpp
>@@ -56,7 +56,7 @@ static void drawCrossfadeSubimage(GraphicsContext& context, Image& image, Compos
>     if (useTransparencyLayer) {
>         context.setCompositeOperation(operation);
>         context.beginTransparencyLayer(opacity);
>-        drawImageOperation = CompositeSourceOver;
>+        drawImageOperation = CompositeOperator::SourceOver;
>     } else
>         context.setAlpha(opacity);
> 
>@@ -80,8 +80,8 @@ void CrossfadeGeneratedImage::drawCrossfade(GraphicsContext& context)
>     context.clip(FloatRect(FloatPoint(), m_crossfadeSize));
>     context.beginTransparencyLayer(1);
> 
>-    drawCrossfadeSubimage(context, m_fromImage.get(), CompositeSourceOver, 1 - m_percentage, m_crossfadeSize);
>-    drawCrossfadeSubimage(context, m_toImage.get(), CompositePlusLighter, m_percentage, m_crossfadeSize);
>+    drawCrossfadeSubimage(context, m_fromImage.get(), CompositeOperator::SourceOver, 1 - m_percentage, m_crossfadeSize);
>+    drawCrossfadeSubimage(context, m_toImage.get(), CompositeOperator::PlusLighter, m_percentage, m_crossfadeSize);
> 
>     context.endTransparencyLayer();
> }
>diff --git a/Source/WebCore/platform/graphics/GraphicsContext.h b/Source/WebCore/platform/graphics/GraphicsContext.h
>index ccc2d03e7eaf1fbbec2a121f583594b69014e12c..6456e21af0c0f79bdc4dda8e81c1d380b7aecea3 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContext.h
>+++ b/Source/WebCore/platform/graphics/GraphicsContext.h
>@@ -183,8 +183,8 @@ struct GraphicsContextState {
>     WindRule fillRule { WindRule::NonZero };
> 
>     float alpha { 1 };
>-    CompositeOperator compositeOperator { CompositeSourceOver };
>-    BlendMode blendMode { BlendModeNormal };
>+    CompositeOperator compositeOperator { CompositeOperator::SourceOver };
>+    BlendMode blendMode { BlendMode::Normal };
>     InterpolationQuality imageInterpolationQuality { InterpolationDefault };
> 
>     bool shouldAntialias : 1;
>@@ -198,7 +198,7 @@ struct GraphicsContextState {
> };
> 
> struct ImagePaintingOptions {
>-    ImagePaintingOptions(CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal, DecodingMode decodingMode = DecodingMode::Synchronous, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), InterpolationQuality interpolationQuality = InterpolationDefault)
>+    ImagePaintingOptions(CompositeOperator compositeOperator = CompositeOperator::SourceOver, BlendMode blendMode = BlendMode::Normal, DecodingMode decodingMode = DecodingMode::Synchronous, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), InterpolationQuality interpolationQuality = InterpolationDefault)
>         : m_compositeOperator(compositeOperator)
>         , m_blendMode(blendMode)
>         , m_decodingMode(decodingMode)
>@@ -207,7 +207,7 @@ struct ImagePaintingOptions {
>     {
>     }
> 
>-    ImagePaintingOptions(ImageOrientationDescription orientationDescription, InterpolationQuality interpolationQuality = InterpolationDefault, CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal, DecodingMode decodingMode = DecodingMode::Synchronous)
>+    ImagePaintingOptions(ImageOrientationDescription orientationDescription, InterpolationQuality interpolationQuality = InterpolationDefault, CompositeOperator compositeOperator = CompositeOperator::SourceOver, BlendMode blendMode = BlendMode::Normal, DecodingMode decodingMode = DecodingMode::Synchronous)
>         : m_compositeOperator(compositeOperator)
>         , m_blendMode(blendMode)
>         , m_decodingMode(decodingMode)
>@@ -216,7 +216,7 @@ struct ImagePaintingOptions {
>     {
>     }
> 
>-    ImagePaintingOptions(InterpolationQuality interpolationQuality, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), CompositeOperator compositeOperator = CompositeSourceOver, BlendMode blendMode = BlendModeNormal, DecodingMode decodingMode = DecodingMode::Synchronous)
>+    ImagePaintingOptions(InterpolationQuality interpolationQuality, ImageOrientationDescription orientationDescription = ImageOrientationDescription(), CompositeOperator compositeOperator = CompositeOperator::SourceOver, BlendMode blendMode = BlendMode::Normal, DecodingMode decodingMode = DecodingMode::Synchronous)
>         : m_compositeOperator(compositeOperator)
>         , m_blendMode(blendMode)
>         , m_decodingMode(decodingMode)
>@@ -326,7 +326,7 @@ public:
>     const GraphicsContextState& state() const { return m_state; }
> 
> #if USE(CG) || USE(DIRECT2D) || USE(CAIRO)
>-    WEBCORE_EXPORT void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal, ImageOrientation = ImageOrientation());
>+    WEBCORE_EXPORT void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator = CompositeOperator::SourceOver, BlendMode = BlendMode::Normal, ImageOrientation = ImageOrientation());
> #endif
> 
> #if USE(CG) || USE(DIRECT2D)
>@@ -364,8 +364,8 @@ public:
>     WEBCORE_EXPORT void fillRect(const FloatRect&);
>     WEBCORE_EXPORT void fillRect(const FloatRect&, const Color&);
>     void fillRect(const FloatRect&, Gradient&);
>-    void fillRect(const FloatRect&, const Color&, CompositeOperator, BlendMode = BlendModeNormal);
>-    void fillRoundedRect(const FloatRoundedRect&, const Color&, BlendMode = BlendModeNormal);
>+    void fillRect(const FloatRect&, const Color&, CompositeOperator, BlendMode = BlendMode::Normal);
>+    void fillRoundedRect(const FloatRoundedRect&, const Color&, BlendMode = BlendMode::Normal);
>     void fillRectWithRoundedHole(const FloatRect&, const FloatRoundedRect& roundedHoleRect, const Color&);
> 
>     WEBCORE_EXPORT void clearRect(const FloatRect&);
>@@ -384,7 +384,7 @@ public:
>     void drawImageBuffer(ImageBuffer&, const FloatRect& destination, const ImagePaintingOptions& = ImagePaintingOptions());
>     void drawImageBuffer(ImageBuffer&, const FloatRect& destination, const FloatRect& source, const ImagePaintingOptions& = ImagePaintingOptions());
> 
>-    void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal);
>+    void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendMode::Normal);
> 
>     WEBCORE_EXPORT void drawConsumingImageBuffer(std::unique_ptr<ImageBuffer>, const FloatPoint& destination, const ImagePaintingOptions& = ImagePaintingOptions());
>     void drawConsumingImageBuffer(std::unique_ptr<ImageBuffer>, const FloatRect& destination, const ImagePaintingOptions& = ImagePaintingOptions());
>@@ -456,7 +456,7 @@ public:
>     void setAlpha(float);
>     float alpha() const { return m_state.alpha; }
> 
>-    WEBCORE_EXPORT void setCompositeOperation(CompositeOperator, BlendMode = BlendModeNormal);
>+    WEBCORE_EXPORT void setCompositeOperation(CompositeOperator, BlendMode = BlendMode::Normal);
>     CompositeOperator compositeOperation() const { return m_state.compositeOperator; }
>     BlendMode blendModeOperation() const { return m_state.blendMode; }
> 
>@@ -614,7 +614,7 @@ private:
>     void clearPlatformShadow();
> 
>     void setPlatformAlpha(float);
>-    void setPlatformCompositeOperation(CompositeOperator, BlendMode = BlendModeNormal);
>+    void setPlatformCompositeOperation(CompositeOperator, BlendMode = BlendMode::Normal);
> 
>     void beginPlatformTransparencyLayer(float opacity);
>     void endPlatformTransparencyLayer();
>diff --git a/Source/WebCore/platform/graphics/GraphicsContextImpl.h b/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>index 6bcf768adfd89ee0b196a3ea62ee0680c8ad18ee..47fb4a42ee43b4efd16fbbb4448ec1d91f8da377 100644
>--- a/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>+++ b/Source/WebCore/platform/graphics/GraphicsContextImpl.h
>@@ -74,7 +74,7 @@ public:
> #if USE(CG) || USE(CAIRO)
>     virtual void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientation) = 0;
> #endif
>-    virtual void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal) = 0;
>+    virtual void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendMode::Normal) = 0;
> 
>     virtual void drawRect(const FloatRect&, float borderThickness) = 0;
>     virtual void drawLine(const FloatPoint&, const FloatPoint&) = 0;
>diff --git a/Source/WebCore/platform/graphics/GraphicsLayer.cpp b/Source/WebCore/platform/graphics/GraphicsLayer.cpp
>index 817d97526487b54a5dc818514baa7f73ab8a77f3..7676c4f012ed5237cafc89027b4198dc827c59c9 100644
>--- a/Source/WebCore/platform/graphics/GraphicsLayer.cpp
>+++ b/Source/WebCore/platform/graphics/GraphicsLayer.cpp
>@@ -767,8 +767,8 @@ void GraphicsLayer::dumpProperties(TextStream& ts, LayerTreeAsTextBehavior behav
>         ts << indent << "(opacity " << m_opacity << ")\n";
> 
> #if ENABLE(CSS_COMPOSITING)
>-    if (m_blendMode != BlendModeNormal)
>-        ts << indent << "(blendMode " << compositeOperatorName(CompositeSourceOver, m_blendMode) << ")\n";
>+    if (m_blendMode != BlendMode::Normal)
>+        ts << indent << "(blendMode " << compositeOperatorName(CompositeOperator::SourceOver, m_blendMode) << ")\n";
> #endif
> 
>     if (type() == Type::Normal && tiledBacking())
>diff --git a/Source/WebCore/platform/graphics/GraphicsLayer.h b/Source/WebCore/platform/graphics/GraphicsLayer.h
>index f11ca942c5cd2f7594e260432b194776218bb6ac..b4922423521be8ebccceccc5547fe86349660acb 100644
>--- a/Source/WebCore/platform/graphics/GraphicsLayer.h
>+++ b/Source/WebCore/platform/graphics/GraphicsLayer.h
>@@ -651,7 +651,7 @@ protected:
>     FilterOperations m_backdropFilters;
> 
> #if ENABLE(CSS_COMPOSITING)
>-    BlendMode m_blendMode { BlendModeNormal };
>+    BlendMode m_blendMode { BlendMode::Normal };
> #endif
> 
>     const Type m_type;
>diff --git a/Source/WebCore/platform/graphics/GraphicsTypes.cpp b/Source/WebCore/platform/graphics/GraphicsTypes.cpp
>index 5ff1542e620362233a33a0f4d6b89f5d23a9e320..1aaf07e9f1064b9b4f4fa6bd98a8775ab5b2a312 100644
>--- a/Source/WebCore/platform/graphics/GraphicsTypes.cpp
>+++ b/Source/WebCore/platform/graphics/GraphicsTypes.cpp
>@@ -78,7 +78,7 @@ bool parseBlendMode(const String& s, BlendMode& blendMode)
> {
>     for (int i = 0; i < numBlendOperatorNames; i++) {
>         if (s == blendOperatorNames[i]) {
>-            blendMode = static_cast<BlendMode>(i + BlendModeNormal);
>+            blendMode = static_cast<BlendMode>(i + static_cast<unsigned>(BlendMode::Normal));
>             return true;
>         }
>     }
>@@ -91,14 +91,14 @@ bool parseCompositeAndBlendOperator(const String& s, CompositeOperator& op, Blen
>     for (int i = 0; i < numCompositeOperatorNames; i++) {
>         if (s == compositeOperatorNames[i]) {
>             op = static_cast<CompositeOperator>(i);
>-            blendOp = BlendModeNormal;
>+            blendOp = BlendMode::Normal;
>             return true;
>         }
>     }
>     
>     if (parseBlendMode(s, blendOp)) {
>         // For now, blending will always assume source-over. This will be fixed in the future
>-        op = CompositeSourceOver;
>+        op = CompositeOperator::SourceOver;
>         return true;
>     }
>     
>@@ -109,25 +109,24 @@ bool parseCompositeAndBlendOperator(const String& s, CompositeOperator& op, Blen
> // this routine needs to be updated.
> String compositeOperatorName(CompositeOperator op, BlendMode blendOp)
> {
>-    ASSERT(op >= 0);
>-    ASSERT(op < numCompositeOperatorNames);
>-    ASSERT(blendOp >= BlendModeNormal);
>-    ASSERT(blendOp <= numBlendOperatorNames);
>-    if (blendOp > BlendModeNormal)
>-        return blendOperatorNames[blendOp - BlendModeNormal];
>-    return compositeOperatorNames[op];
>+    ASSERT(static_cast<unsigned>(op) < numCompositeOperatorNames);
>+    ASSERT(blendOp >= BlendMode::Normal);
>+    ASSERT(static_cast<unsigned>(blendOp) <= numBlendOperatorNames);
>+    if (blendOp > BlendMode::Normal)
>+        return blendOperatorNames[static_cast<unsigned>(blendOp) - static_cast<unsigned>(BlendMode::Normal)];
>+    return compositeOperatorNames[static_cast<unsigned>(op)];
> }
> 
> String blendModeName(BlendMode blendOp)
> {
>-    ASSERT(blendOp >= BlendModeNormal);
>-    ASSERT(blendOp <= BlendModePlusLighter);
>-    return blendOperatorNames[blendOp - BlendModeNormal];
>+    ASSERT(blendOp >= BlendMode::Normal);
>+    ASSERT(blendOp <= BlendMode::PlusLighter);
>+    return blendOperatorNames[static_cast<unsigned>(blendOp) - static_cast<unsigned>(BlendMode::Normal)];
> }
> 
> TextStream& operator<<(TextStream& ts, CompositeOperator op)
> {
>-    return ts << compositeOperatorName(op, BlendModeNormal);
>+    return ts << compositeOperatorName(op, BlendMode::Normal);
> }
> 
> TextStream& operator<<(TextStream& ts, BlendMode blendMode)
>diff --git a/Source/WebCore/platform/graphics/GraphicsTypes.h b/Source/WebCore/platform/graphics/GraphicsTypes.h
>index 9f76cd9de49afe8b0b270c5c78b140d788f60663..29eb523a0b2ca4f1b67862e3475af325c5d5d0b9 100644
>--- a/Source/WebCore/platform/graphics/GraphicsTypes.h
>+++ b/Source/WebCore/platform/graphics/GraphicsTypes.h
>@@ -34,42 +34,42 @@ class TextStream;
> 
> namespace WebCore {
> 
>-enum CompositeOperator {
>-    CompositeClear,
>-    CompositeCopy,
>-    CompositeSourceOver,
>-    CompositeSourceIn,
>-    CompositeSourceOut,
>-    CompositeSourceAtop,
>-    CompositeDestinationOver,
>-    CompositeDestinationIn,
>-    CompositeDestinationOut,
>-    CompositeDestinationAtop,
>-    CompositeXOR,
>-    CompositePlusDarker,
>-    CompositePlusLighter,
>-    CompositeDifference
>+enum class CompositeOperator : uint8_t {
>+    Clear,
>+    Copy,
>+    SourceOver,
>+    SourceIn,
>+    SourceOut,
>+    SourceAtop,
>+    DestinationOver,
>+    DestinationIn,
>+    DestinationOut,
>+    DestinationAtop,
>+    XOR,
>+    PlusDarker,
>+    PlusLighter,
>+    Difference
> };
> 
>-enum BlendMode {
>-    BlendModeNormal = 1, // Start with 1 to match SVG's blendmode enumeration.
>-    BlendModeMultiply,
>-    BlendModeScreen,
>-    BlendModeDarken,
>-    BlendModeLighten,
>-    BlendModeOverlay,
>-    BlendModeColorDodge,
>-    BlendModeColorBurn,
>-    BlendModeHardLight,
>-    BlendModeSoftLight,
>-    BlendModeDifference,
>-    BlendModeExclusion,
>-    BlendModeHue,
>-    BlendModeSaturation,
>-    BlendModeColor,
>-    BlendModeLuminosity,
>-    BlendModePlusDarker,
>-    BlendModePlusLighter
>+enum class BlendMode : uint8_t {
>+    Normal = 1, // Start with 1 to match SVG's blendmode enumeration.
>+    Multiply,
>+    Screen,
>+    Darken,
>+    Lighten,
>+    Overlay,
>+    ColorDodge,
>+    ColorBurn,
>+    HardLight,
>+    SoftLight,
>+    Difference,
>+    Exclusion,
>+    Hue,
>+    Saturation,
>+    Color,
>+    Luminosity,
>+    PlusDarker,
>+    PlusLighter
> };
> 
> enum GradientSpreadMethod {
>diff --git a/Source/WebCore/platform/graphics/Image.cpp b/Source/WebCore/platform/graphics/Image.cpp
>index 97ed869f93a492d0749dec257d4650974327d75c..dca5a45c93d31cf86c78d8d01f266940a5abd438 100644
>--- a/Source/WebCore/platform/graphics/Image.cpp
>+++ b/Source/WebCore/platform/graphics/Image.cpp
>@@ -132,7 +132,7 @@ void Image::fillWithSolidColor(GraphicsContext& ctxt, const FloatRect& dstRect,
>         return;
>     
>     CompositeOperator previousOperator = ctxt.compositeOperation();
>-    ctxt.setCompositeOperation(color.isOpaque() && op == CompositeSourceOver ? CompositeCopy : op);
>+    ctxt.setCompositeOperation(color.isOpaque() && op == CompositeOperator::SourceOver ? CompositeOperator::Copy : op);
>     ctxt.fillRect(dstRect, color);
>     ctxt.setCompositeOperation(previousOperator);
> }
>@@ -196,7 +196,7 @@ ImageDrawResult Image::drawTiled(GraphicsContext& ctxt, const FloatRect& destRec
>             visibleSrcRect.setY((destRect.y() - oneTileRect.y()) / scale.height());
>             visibleSrcRect.setWidth(1);
>             visibleSrcRect.setHeight(destRect.height() / scale.height());
>-            return draw(ctxt, destRect, visibleSrcRect, op, BlendModeNormal, decodingMode, ImageOrientationDescription());
>+            return draw(ctxt, destRect, visibleSrcRect, op, BlendMode::Normal, decodingMode, ImageOrientationDescription());
>         }
>         if (size().height() == 1 && intersection(oneTileRect, destRect).width() == destRect.width()) {
>             FloatRect visibleSrcRect;
>@@ -204,7 +204,7 @@ ImageDrawResult Image::drawTiled(GraphicsContext& ctxt, const FloatRect& destRec
>             visibleSrcRect.setY(0);
>             visibleSrcRect.setWidth(destRect.width() / scale.width());
>             visibleSrcRect.setHeight(1);
>-            return draw(ctxt, destRect, visibleSrcRect, op, BlendModeNormal, decodingMode, ImageOrientationDescription());
>+            return draw(ctxt, destRect, visibleSrcRect, op, BlendMode::Normal, decodingMode, ImageOrientationDescription());
>         }
>     }
> #endif
>@@ -236,7 +236,7 @@ ImageDrawResult Image::drawTiled(GraphicsContext& ctxt, const FloatRect& destRec
>                 FloatRect fromRect(toFloatPoint(currentTileRect.location() - oneTileRect.location()), currentTileRect.size());
>                 fromRect.scale(1 / scale.width(), 1 / scale.height());
> 
>-                result = draw(ctxt, toRect, fromRect, op, BlendModeNormal, decodingMode, ImageOrientationDescription());
>+                result = draw(ctxt, toRect, fromRect, op, BlendMode::Normal, decodingMode, ImageOrientationDescription());
>                 if (result == ImageDrawResult::DidRequestDecoding)
>                     return result;
>                 toX += currentTileRect.width();
>diff --git a/Source/WebCore/platform/graphics/Image.h b/Source/WebCore/platform/graphics/Image.h
>index eaaac5287e83ceb9029ab63aaf9e4533c9249c32..5f220be4ef06f3fc1e79349fdeb330ed91e74ac9 100644
>--- a/Source/WebCore/platform/graphics/Image.h
>+++ b/Source/WebCore/platform/graphics/Image.h
>@@ -174,7 +174,7 @@ public:
> #endif
> 
>     virtual void drawPattern(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform,
>-        const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal);
>+        const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendMode::Normal);
> 
> #if !ASSERT_DISABLED
>     virtual bool notSolidColor() { return true; }
>diff --git a/Source/WebCore/platform/graphics/ImageBuffer.h b/Source/WebCore/platform/graphics/ImageBuffer.h
>index 987580e6bdc39123770921c57e7dc7dabd74a165..5fbecbc63c4ad4fd913ba3b3901653a7942e5a67 100644
>--- a/Source/WebCore/platform/graphics/ImageBuffer.h
>+++ b/Source/WebCore/platform/graphics/ImageBuffer.h
>@@ -144,10 +144,10 @@ private:
>     void flushContext() const;
> #endif
>     
>-    void draw(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1), CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal);
>-    void drawPattern(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal);
>+    void draw(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1), CompositeOperator = CompositeOperator::SourceOver, BlendMode = BlendMode::Normal);
>+    void drawPattern(GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform& patternTransform, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendMode::Normal);
> 
>-    static void drawConsuming(std::unique_ptr<ImageBuffer>, GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1), CompositeOperator = CompositeSourceOver, BlendMode = BlendModeNormal);
>+    static void drawConsuming(std::unique_ptr<ImageBuffer>, GraphicsContext&, const FloatRect& destRect, const FloatRect& srcRect = FloatRect(0, 0, -1, -1), CompositeOperator = CompositeOperator::SourceOver, BlendMode = BlendMode::Normal);
> 
>     inline void genericConvertToLuminanceMask();
> 
>diff --git a/Source/WebCore/platform/graphics/ShadowBlur.cpp b/Source/WebCore/platform/graphics/ShadowBlur.cpp
>index fe049a4b8e6703d61bc1adb5006885fcc7ed3fa5..4cdac556b3a164d9c4bff9dad2b07f581b44b488 100644
>--- a/Source/WebCore/platform/graphics/ShadowBlur.cpp
>+++ b/Source/WebCore/platform/graphics/ShadowBlur.cpp
>@@ -936,7 +936,7 @@ void ShadowBlur::blurAndColorShadowBuffer(const IntSize& templateSize)
>     // Mask the image with the shadow color.
>     GraphicsContext& shadowContext = m_layerImage->context();
>     GraphicsContextStateSaver stateSaver(shadowContext);
>-    shadowContext.setCompositeOperation(CompositeSourceIn);
>+    shadowContext.setCompositeOperation(CompositeOperator::SourceIn);
>     shadowContext.setFillColor(m_color);
>     shadowContext.fillRect(FloatRect(0, 0, templateSize.width(), templateSize.height()));
> }
>diff --git a/Source/WebCore/platform/graphics/ca/cocoa/PlatformCAFiltersCocoa.mm b/Source/WebCore/platform/graphics/ca/cocoa/PlatformCAFiltersCocoa.mm
>index 890d65e1e9063c3baefd7d57bb7771a113bc5da1..0b5f6fbe0b60e4f803dff12a6c7943e55478bf3d 100644
>--- a/Source/WebCore/platform/graphics/ca/cocoa/PlatformCAFiltersCocoa.mm
>+++ b/Source/WebCore/platform/graphics/ca/cocoa/PlatformCAFiltersCocoa.mm
>@@ -556,52 +556,52 @@ void PlatformCAFilters::setBlendingFiltersOnLayer(PlatformLayer* layer, const Bl
>     CAFilter* filter = nil;
> 
>     switch (blendMode) {
>-    case BlendModeNormal:
>+    case BlendMode::Normal:
>         // No need to set an actual filter object in this case.
>         break;
>-    case BlendModeOverlay:
>+    case BlendMode::Overlay:
>         filter = [CAFilter filterWithType:kCAFilterOverlayBlendMode];
>         break;
>-    case BlendModeColorDodge:
>+    case BlendMode::ColorDodge:
>         filter = [CAFilter filterWithType:kCAFilterColorDodgeBlendMode];
>         break;
>-    case BlendModeColorBurn:
>+    case BlendMode::ColorBurn:
>         filter = [CAFilter filterWithType:kCAFilterColorBurnBlendMode];
>         break;
>-    case BlendModeDarken:
>+    case BlendMode::Darken:
>         filter = [CAFilter filterWithType:kCAFilterDarkenBlendMode];
>         break;
>-    case BlendModeDifference:
>+    case BlendMode::Difference:
>         filter = [CAFilter filterWithType:kCAFilterDifferenceBlendMode];
>         break;
>-    case BlendModeExclusion:
>+    case BlendMode::Exclusion:
>         filter = [CAFilter filterWithType:kCAFilterExclusionBlendMode];
>         break;
>-    case BlendModeHardLight:
>+    case BlendMode::HardLight:
>         filter = [CAFilter filterWithType:kCAFilterHardLightBlendMode];
>         break;
>-    case BlendModeMultiply:
>+    case BlendMode::Multiply:
>         filter = [CAFilter filterWithType:kCAFilterMultiplyBlendMode];
>         break;
>-    case BlendModeLighten:
>+    case BlendMode::Lighten:
>         filter = [CAFilter filterWithType:kCAFilterLightenBlendMode];
>         break;
>-    case BlendModeSoftLight:
>+    case BlendMode::SoftLight:
>         filter = [CAFilter filterWithType:kCAFilterSoftLightBlendMode];
>         break;
>-    case BlendModeScreen:
>+    case BlendMode::Screen:
>         filter = [CAFilter filterWithType:kCAFilterScreenBlendMode];
>         break;
>-    case BlendModePlusDarker:
>+    case BlendMode::PlusDarker:
>         filter = [CAFilter filterWithType:kCAFilterPlusD];
>         break;
>-    case BlendModePlusLighter:
>+    case BlendMode::PlusLighter:
>         filter = [CAFilter filterWithType:kCAFilterPlusL];
>         break;
>-    case BlendModeHue:
>-    case BlendModeSaturation:
>-    case BlendModeColor:
>-    case BlendModeLuminosity:
>+    case BlendMode::Hue:
>+    case BlendMode::Saturation:
>+    case BlendMode::Color:
>+    case BlendMode::Luminosity:
>         // FIXME: CA does't support non-separable blend modes on compositing filters.
>         break;
>     default:
>diff --git a/Source/WebCore/platform/graphics/cairo/CairoOperations.cpp b/Source/WebCore/platform/graphics/cairo/CairoOperations.cpp
>index c4ecd910fc57212850d47eaf6ce34f94d760b6fa..1ff6fc3abc01061aebcec36852fd846b56845f14 100644
>--- a/Source/WebCore/platform/graphics/cairo/CairoOperations.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/CairoOperations.cpp
>@@ -179,7 +179,7 @@ static void drawShadowLayerBuffer(PlatformContextCairo& platformContext, ImageBu
> 
>     if (auto surface = image->nativeImageForCurrentFrame()) {
>         drawNativeImage(platformContext, surface.get(), FloatRect(roundedIntPoint(layerOrigin), layerSize), FloatRect(FloatPoint(), layerSize),
>-            shadowState.globalCompositeOperator, BlendModeNormal, ImageOrientation(),
>+            shadowState.globalCompositeOperator, BlendMode::Normal, ImageOrientation(),
>             InterpolationDefault, shadowState.globalAlpha, ShadowState());
>     }
> }
>@@ -837,8 +837,8 @@ void drawNativeImage(PlatformContextCairo& platformContext, cairo_surface_t* sur
>     platformContext.save();
> 
>     // Set the compositing operation.
>-    if (compositeOperator == CompositeSourceOver && blendMode == BlendModeNormal && !cairoSurfaceHasAlpha(surface))
>-        Cairo::State::setCompositeOperation(platformContext, CompositeCopy, BlendModeNormal);
>+    if (compositeOperator == CompositeOperator::SourceOver && blendMode == BlendMode::Normal && !cairoSurfaceHasAlpha(surface))
>+        Cairo::State::setCompositeOperation(platformContext, CompositeOperator::Copy, BlendMode::Normal);
>     else
>         Cairo::State::setCompositeOperation(platformContext, compositeOperator, blendMode);
> 
>diff --git a/Source/WebCore/platform/graphics/cairo/CairoOperations.h b/Source/WebCore/platform/graphics/cairo/CairoOperations.h
>index 39b52a721224e0b003ea334289d2a007a92c47eb..75652f5655ccb198362bff1264ada771b23c4091 100644
>--- a/Source/WebCore/platform/graphics/cairo/CairoOperations.h
>+++ b/Source/WebCore/platform/graphics/cairo/CairoOperations.h
>@@ -118,7 +118,7 @@ struct ShadowState {
>     bool ignoreTransforms { false };
> 
>     float globalAlpha { 1.0 };
>-    CompositeOperator globalCompositeOperator { CompositeSourceOver };
>+    CompositeOperator globalCompositeOperator { CompositeOperator::SourceOver };
> };
> 
> void setLineCap(PlatformContextCairo&, LineCap);
>diff --git a/Source/WebCore/platform/graphics/cairo/CairoUtilities.cpp b/Source/WebCore/platform/graphics/cairo/CairoUtilities.cpp
>index 04d682f947f5e41b683643259f3504df1d9fea6c..62f6ba881b8e3272e860ed348228c30074dc0ba8 100644
>--- a/Source/WebCore/platform/graphics/cairo/CairoUtilities.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/CairoUtilities.cpp
>@@ -128,33 +128,33 @@ void appendRegionToCairoContext(cairo_t* to, const cairo_region_t* region)
> static cairo_operator_t toCairoCompositeOperator(CompositeOperator op)
> {
>     switch (op) {
>-    case CompositeClear:
>+    case CompositeOperator::Clear:
>         return CAIRO_OPERATOR_CLEAR;
>-    case CompositeCopy:
>+    case CompositeOperator::Copy:
>         return CAIRO_OPERATOR_SOURCE;
>-    case CompositeSourceOver:
>+    case CompositeOperator::SourceOver:
>         return CAIRO_OPERATOR_OVER;
>-    case CompositeSourceIn:
>+    case CompositeOperator::SourceIn:
>         return CAIRO_OPERATOR_IN;
>-    case CompositeSourceOut:
>+    case CompositeOperator::SourceOut:
>         return CAIRO_OPERATOR_OUT;
>-    case CompositeSourceAtop:
>+    case CompositeOperator::SourceAtop:
>         return CAIRO_OPERATOR_ATOP;
>-    case CompositeDestinationOver:
>+    case CompositeOperator::DestinationOver:
>         return CAIRO_OPERATOR_DEST_OVER;
>-    case CompositeDestinationIn:
>+    case CompositeOperator::DestinationIn:
>         return CAIRO_OPERATOR_DEST_IN;
>-    case CompositeDestinationOut:
>+    case CompositeOperator::DestinationOut:
>         return CAIRO_OPERATOR_DEST_OUT;
>-    case CompositeDestinationAtop:
>+    case CompositeOperator::DestinationAtop:
>         return CAIRO_OPERATOR_DEST_ATOP;
>-    case CompositeXOR:
>+    case CompositeOperator::XOR:
>         return CAIRO_OPERATOR_XOR;
>-    case CompositePlusDarker:
>+    case CompositeOperator::PlusDarker:
>         return CAIRO_OPERATOR_DARKEN;
>-    case CompositePlusLighter:
>+    case CompositeOperator::PlusLighter:
>         return CAIRO_OPERATOR_ADD;
>-    case CompositeDifference:
>+    case CompositeOperator::Difference:
>         return CAIRO_OPERATOR_DIFFERENCE;
>     default:
>         return CAIRO_OPERATOR_SOURCE;
>@@ -164,37 +164,37 @@ static cairo_operator_t toCairoCompositeOperator(CompositeOperator op)
> cairo_operator_t toCairoOperator(CompositeOperator op, BlendMode blendOp)
> {
>     switch (blendOp) {
>-    case BlendModeNormal:
>+    case BlendMode::Normal:
>         return toCairoCompositeOperator(op);
>-    case BlendModeMultiply:
>+    case BlendMode::Multiply:
>         return CAIRO_OPERATOR_MULTIPLY;
>-    case BlendModeScreen:
>+    case BlendMode::Screen:
>         return CAIRO_OPERATOR_SCREEN;
>-    case BlendModeOverlay:
>+    case BlendMode::Overlay:
>         return CAIRO_OPERATOR_OVERLAY;
>-    case BlendModeDarken:
>+    case BlendMode::Darken:
>         return CAIRO_OPERATOR_DARKEN;
>-    case BlendModeLighten:
>+    case BlendMode::Lighten:
>         return CAIRO_OPERATOR_LIGHTEN;
>-    case BlendModeColorDodge:
>+    case BlendMode::ColorDodge:
>         return CAIRO_OPERATOR_COLOR_DODGE;
>-    case BlendModeColorBurn:
>+    case BlendMode::ColorBurn:
>         return CAIRO_OPERATOR_COLOR_BURN;
>-    case BlendModeHardLight:
>+    case BlendMode::HardLight:
>         return CAIRO_OPERATOR_HARD_LIGHT;
>-    case BlendModeSoftLight:
>+    case BlendMode::SoftLight:
>         return CAIRO_OPERATOR_SOFT_LIGHT;
>-    case BlendModeDifference:
>+    case BlendMode::Difference:
>         return CAIRO_OPERATOR_DIFFERENCE;
>-    case BlendModeExclusion:
>+    case BlendMode::Exclusion:
>         return CAIRO_OPERATOR_EXCLUSION;
>-    case BlendModeHue:
>+    case BlendMode::Hue:
>         return CAIRO_OPERATOR_HSL_HUE;
>-    case BlendModeSaturation:
>+    case BlendMode::Saturation:
>         return CAIRO_OPERATOR_HSL_SATURATION;
>-    case BlendModeColor:
>+    case BlendMode::Color:
>         return CAIRO_OPERATOR_HSL_COLOR;
>-    case BlendModeLuminosity:
>+    case BlendMode::Luminosity:
>         return CAIRO_OPERATOR_HSL_LUMINOSITY;
>     default:
>         return CAIRO_OPERATOR_OVER;
>diff --git a/Source/WebCore/platform/graphics/cairo/CairoUtilities.h b/Source/WebCore/platform/graphics/cairo/CairoUtilities.h
>index 381d3c8eebc7cdc040b022761d15ca7a51139676..1f13e5e3c9c0180ecabf243a24ce3762def326f6 100644
>--- a/Source/WebCore/platform/graphics/cairo/CairoUtilities.h
>+++ b/Source/WebCore/platform/graphics/cairo/CairoUtilities.h
>@@ -80,7 +80,7 @@ void appendPathToCairoContext(cairo_t* to, cairo_t* from);
> void setPathOnCairoContext(cairo_t* to, cairo_t* from);
> void appendWebCorePathToCairoContext(cairo_t* context, const Path& path);
> void appendRegionToCairoContext(cairo_t*, const cairo_region_t*);
>-cairo_operator_t toCairoOperator(CompositeOperator, BlendMode = BlendModeNormal);
>+cairo_operator_t toCairoOperator(CompositeOperator, BlendMode = BlendMode::Normal);
> void drawPatternToCairoContext(cairo_t* cr, cairo_surface_t* image, const IntSize& imageSize, const FloatRect& tileRect,
>                                const AffineTransform& patternTransform, const FloatPoint& phase, cairo_operator_t op, const FloatRect& destRect);
> RefPtr<cairo_surface_t> copyCairoImageSurface(cairo_surface_t*);
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>index e06e4031d879d190369aac83876804984c65a7cd..627fd57c0a830d5e4b822c73a87d409af43b4306 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.cpp
>@@ -164,7 +164,7 @@ void GraphicsContextImplCairo::fillRect(const FloatRect& rect, const Color& colo
> 
>     Cairo::State::setCompositeOperation(m_platformContext, compositeOperator, blendMode);
>     Cairo::fillRect(m_platformContext, rect, color, Cairo::ShadowState(state));
>-    Cairo::State::setCompositeOperation(m_platformContext, previousOperator, BlendModeNormal);
>+    Cairo::State::setCompositeOperation(m_platformContext, previousOperator, BlendMode::Normal);
> }
> 
> void GraphicsContextImplCairo::fillRoundedRect(const FloatRoundedRect& rect, const Color& color, BlendMode blendMode)
>@@ -180,7 +180,7 @@ void GraphicsContextImplCairo::fillRoundedRect(const FloatRoundedRect& rect, con
>     else
>         Cairo::fillRect(m_platformContext, rect.rect(), color, shadowState);
> 
>-    Cairo::State::setCompositeOperation(m_platformContext, previousOperator, BlendModeNormal);
>+    Cairo::State::setCompositeOperation(m_platformContext, previousOperator, BlendMode::Normal);
> }
> 
> void GraphicsContextImplCairo::fillRectWithRoundedHole(const FloatRect& rect, const FloatRoundedRect& roundedHoleRect, const Color&)
>diff --git a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>index 997cbdda51c3f1c0c52d50fccea4e58595b8a79b..30d3ec64331a26d07d44766bc4920eb745d0c3f8 100644
>--- a/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>+++ b/Source/WebCore/platform/graphics/cairo/GraphicsContextImplCairo.h
>@@ -75,7 +75,7 @@ public:
>     ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatPoint&, const FloatSize&, const FloatSize&, const ImagePaintingOptions&) override;
>     ImageDrawResult drawTiledImage(Image&, const FloatRect&, const FloatRect&, const FloatSize&, Image::TileRule, Image::TileRule, const ImagePaintingOptions&) override;
>     void drawNativeImage(const NativeImagePtr&, const FloatSize&, const FloatRect&, const FloatRect&, CompositeOperator, BlendMode, ImageOrientation) override;
>-    void drawPattern(Image&, const FloatRect&, const FloatRect&, const AffineTransform&, const FloatPoint&, const FloatSize&, CompositeOperator, BlendMode = BlendModeNormal) override;
>+    void drawPattern(Image&, const FloatRect&, const FloatRect&, const AffineTransform&, const FloatPoint&, const FloatSize&, CompositeOperator, BlendMode = BlendMode::Normal) override;
> 
>     void drawRect(const FloatRect&, float) override;
>     void drawLine(const FloatPoint&, const FloatPoint&) override;
>diff --git a/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp b/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp
>index ddb744eee5b2b98a8f33eac56e82551b8979f853..a430f05519d47b7dc16276479cc308a103b886df 100644
>--- a/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/GraphicsContext3DCG.cpp
>@@ -532,7 +532,7 @@ void GraphicsContext3D::paintToCanvas(const unsigned char* imagePixels, const In
>     context.scale(FloatSize(1, -1));
>     context.translate(0, -imageSize.height());
>     context.setImageInterpolationQuality(InterpolationNone);
>-    context.drawNativeImage(cgImage, imageSize, canvasRect, FloatRect(FloatPoint(), imageSize), CompositeCopy);
>+    context.drawNativeImage(cgImage, imageSize, canvasRect, FloatRect(FloatPoint(), imageSize), CompositeOperator::Copy);
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp b/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>index d29507178cb00e569df1b1c66b99fda79ad247cf..e43420408eb769c3881a786dbf2de101be144ba2 100644
>--- a/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>+++ b/Source/WebCore/platform/graphics/cg/GraphicsContextCG.cpp
>@@ -158,71 +158,71 @@ static InterpolationQuality convertInterpolationQuality(CGInterpolationQuality q
> static CGBlendMode selectCGBlendMode(CompositeOperator compositeOperator, BlendMode blendMode)
> {
>     switch (blendMode) {
>-    case BlendModeNormal:
>+    case BlendMode::Normal:
>         switch (compositeOperator) {
>-        case CompositeClear:
>+        case CompositeOperator::Clear:
>             return kCGBlendModeClear;
>-        case CompositeCopy:
>+        case CompositeOperator::Copy:
>             return kCGBlendModeCopy;
>-        case CompositeSourceOver:
>+        case CompositeOperator::SourceOver:
>             return kCGBlendModeNormal;
>-        case CompositeSourceIn:
>+        case CompositeOperator::SourceIn:
>             return kCGBlendModeSourceIn;
>-        case CompositeSourceOut:
>+        case CompositeOperator::SourceOut:
>             return kCGBlendModeSourceOut;
>-        case CompositeSourceAtop:
>+        case CompositeOperator::SourceAtop:
>             return kCGBlendModeSourceAtop;
>-        case CompositeDestinationOver:
>+        case CompositeOperator::DestinationOver:
>             return kCGBlendModeDestinationOver;
>-        case CompositeDestinationIn:
>+        case CompositeOperator::DestinationIn:
>             return kCGBlendModeDestinationIn;
>-        case CompositeDestinationOut:
>+        case CompositeOperator::DestinationOut:
>             return kCGBlendModeDestinationOut;
>-        case CompositeDestinationAtop:
>+        case CompositeOperator::DestinationAtop:
>             return kCGBlendModeDestinationAtop;
>-        case CompositeXOR:
>+        case CompositeOperator::XOR:
>             return kCGBlendModeXOR;
>-        case CompositePlusDarker:
>+        case CompositeOperator::PlusDarker:
>             return kCGBlendModePlusDarker;
>-        case CompositePlusLighter:
>+        case CompositeOperator::PlusLighter:
>             return kCGBlendModePlusLighter;
>-        case CompositeDifference:
>+        case CompositeOperator::Difference:
>             return kCGBlendModeDifference;
>         }
>         break;
>-    case BlendModeMultiply:
>+    case BlendMode::Multiply:
>         return kCGBlendModeMultiply;
>-    case BlendModeScreen:
>+    case BlendMode::Screen:
>         return kCGBlendModeScreen;
>-    case BlendModeOverlay:
>+    case BlendMode::Overlay:
>         return kCGBlendModeOverlay;
>-    case BlendModeDarken:
>+    case BlendMode::Darken:
>         return kCGBlendModeDarken;
>-    case BlendModeLighten:
>+    case BlendMode::Lighten:
>         return kCGBlendModeLighten;
>-    case BlendModeColorDodge:
>+    case BlendMode::ColorDodge:
>         return kCGBlendModeColorDodge;
>-    case BlendModeColorBurn:
>+    case BlendMode::ColorBurn:
>         return kCGBlendModeColorBurn;
>-    case BlendModeHardLight:
>+    case BlendMode::HardLight:
>         return kCGBlendModeHardLight;
>-    case BlendModeSoftLight:
>+    case BlendMode::SoftLight:
>         return kCGBlendModeSoftLight;
>-    case BlendModeDifference:
>+    case BlendMode::Difference:
>         return kCGBlendModeDifference;
>-    case BlendModeExclusion:
>+    case BlendMode::Exclusion:
>         return kCGBlendModeExclusion;
>-    case BlendModeHue:
>+    case BlendMode::Hue:
>         return kCGBlendModeHue;
>-    case BlendModeSaturation:
>+    case BlendMode::Saturation:
>         return kCGBlendModeSaturation;
>-    case BlendModeColor:
>+    case BlendMode::Color:
>         return kCGBlendModeColor;
>-    case BlendModeLuminosity:
>+    case BlendMode::Luminosity:
>         return kCGBlendModeLuminosity;
>-    case BlendModePlusDarker:
>+    case BlendMode::PlusDarker:
>         return kCGBlendModePlusDarker;
>-    case BlendModePlusLighter:
>+    case BlendMode::PlusLighter:
>         return kCGBlendModePlusLighter;
>     }
> 
>diff --git a/Source/WebCore/platform/graphics/cpu/arm/filters/FEBlendNEON.h b/Source/WebCore/platform/graphics/cpu/arm/filters/FEBlendNEON.h
>index a561df66f66c151ce008d07c528ddb161a6a55f4..fd8e5e8e2e94e7054896f9abbba7a46f502141c9 100644
>--- a/Source/WebCore/platform/graphics/cpu/arm/filters/FEBlendNEON.h
>+++ b/Source/WebCore/platform/graphics/cpu/arm/filters/FEBlendNEON.h
>@@ -163,19 +163,19 @@ void FEBlend::platformApplyNEON(unsigned char* srcPixelArrayA, unsigned char* sr
> 
>         uint16x8_t result;
>         switch (m_mode) {
>-        case BlendModeNormal:
>+        case BlendMode::Normal:
>             result = FEBlendUtilitiesNEON::normal(doubblePixelA, doubblePixelB, alphaA, alphaB, sixteenConst255, sixteenConstOne);
>             break;
>-        case BlendModeMultiply:
>+        case BlendMode::Multiply:
>             result = FEBlendUtilitiesNEON::multiply(doubblePixelA, doubblePixelB, alphaA, alphaB, sixteenConst255, sixteenConstOne);
>             break;
>-        case BlendModeScreen:
>+        case BlendMode::Screen:
>             result = FEBlendUtilitiesNEON::screen(doubblePixelA, doubblePixelB, alphaA, alphaB, sixteenConst255, sixteenConstOne);
>             break;
>-        case BlendModeDarken:
>+        case BlendMode::Darken:
>             result = FEBlendUtilitiesNEON::darken(doubblePixelA, doubblePixelB, alphaA, alphaB, sixteenConst255, sixteenConstOne);
>             break;
>-        case BlendModeLighten:
>+        case BlendMode::Lighten:
>             result = FEBlendUtilitiesNEON::lighten(doubblePixelA, doubblePixelB, alphaA, alphaB, sixteenConst255, sixteenConstOne);
>             break;
>         default:
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>index f00ea7e85cb1cd52469be1588d011e838473c13c..872e30dce8b73124f41d92781c52d4c6a6ea6880 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListItems.h
>@@ -685,7 +685,7 @@ public:
>     FloatSize spacing() const { return m_spacing; }
> 
> private:
>-    DrawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal);
>+    DrawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendMode::Normal);
> 
>     void apply(GraphicsContext&) const override;
> 
>diff --git a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>index c5ac7091395fa4fe83a31d2c88db1e88a7ada3e4..5c1c0660c7e57dd54ebaed2bac38047f1390f971 100644
>--- a/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>+++ b/Source/WebCore/platform/graphics/displaylists/DisplayListRecorder.h
>@@ -93,7 +93,7 @@ private:
> #if USE(CG) || USE(CAIRO)
>     void drawNativeImage(const NativeImagePtr&, const FloatSize& selfSize, const FloatRect& destRect, const FloatRect& srcRect, CompositeOperator, BlendMode, ImageOrientation) override;
> #endif
>-    void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendModeNormal) override;
>+    void drawPattern(Image&, const FloatRect& destRect, const FloatRect& srcRect, const AffineTransform&, const FloatPoint& phase, const FloatSize& spacing, CompositeOperator, BlendMode = BlendMode::Normal) override;
> 
>     void drawRect(const FloatRect&, float borderThickness) override;
>     void drawLine(const FloatPoint&, const FloatPoint&) override;
>diff --git a/Source/WebCore/platform/graphics/filters/FEBlend.cpp b/Source/WebCore/platform/graphics/filters/FEBlend.cpp
>index 535f00a398d09e8fd5e5f3f8995f26550a72b9d1..547998b374aa27544f40f23f86749666f0cd0c32 100644
>--- a/Source/WebCore/platform/graphics/filters/FEBlend.cpp
>+++ b/Source/WebCore/platform/graphics/filters/FEBlend.cpp
>@@ -70,7 +70,7 @@ void FEBlend::platformApplySoftware()
>         return;
> 
>     filterContext.drawImageBuffer(*imageBuffer2, drawingRegionOfInputImage(in2->absolutePaintRect()));
>-    filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), ImagePaintingOptions(CompositeSourceOver, m_mode));
>+    filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), ImagePaintingOptions(CompositeOperator::SourceOver, m_mode));
> }
> #endif
> 
>@@ -78,7 +78,7 @@ TextStream& FEBlend::externalRepresentation(TextStream& ts, RepresentationType r
> {
>     ts << indent << "[feBlend";
>     FilterEffect::externalRepresentation(ts, representation);
>-    ts << " mode=\"" << (m_mode == BlendModeNormal ? "normal" : compositeOperatorName(CompositeSourceOver, m_mode)) << "\"]\n";
>+    ts << " mode=\"" << (m_mode == BlendMode::Normal ? "normal" : compositeOperatorName(CompositeOperator::SourceOver, m_mode)) << "\"]\n";
> 
>     TextStream::IndentScope indentScope(ts);
>     inputEffect(0)->externalRepresentation(ts, representation);
>diff --git a/Source/WebCore/platform/graphics/filters/FEComposite.cpp b/Source/WebCore/platform/graphics/filters/FEComposite.cpp
>index 5323bedaa570a4b2124168c465b4951c041f439a..445857851b914d000b1aa68e315e3d99b799ac65 100644
>--- a/Source/WebCore/platform/graphics/filters/FEComposite.cpp
>+++ b/Source/WebCore/platform/graphics/filters/FEComposite.cpp
>@@ -271,24 +271,24 @@ void FEComposite::platformApplySoftware()
>         IntRect sourceRect = destinationRect - in->absolutePaintRect().location();
>         IntRect source2Rect = destinationRect - in2->absolutePaintRect().location();
>         filterContext.drawImageBuffer(*imageBuffer2, adjustedDestinationRect, source2Rect);
>-        filterContext.drawImageBuffer(*imageBuffer, adjustedDestinationRect, sourceRect, CompositeSourceIn);
>+        filterContext.drawImageBuffer(*imageBuffer, adjustedDestinationRect, sourceRect, CompositeOperator::SourceIn);
>         break;
>     }
>     case FECOMPOSITE_OPERATOR_OUT:
>         filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()));
>-        filterContext.drawImageBuffer(*imageBuffer2, drawingRegionOfInputImage(in2->absolutePaintRect()), IntRect(IntPoint(), imageBuffer2->logicalSize()), CompositeDestinationOut);
>+        filterContext.drawImageBuffer(*imageBuffer2, drawingRegionOfInputImage(in2->absolutePaintRect()), IntRect(IntPoint(), imageBuffer2->logicalSize()), CompositeOperator::DestinationOut);
>         break;
>     case FECOMPOSITE_OPERATOR_ATOP:
>         filterContext.drawImageBuffer(*imageBuffer2, drawingRegionOfInputImage(in2->absolutePaintRect()));
>-        filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), CompositeSourceAtop);
>+        filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), CompositeOperator::SourceAtop);
>         break;
>     case FECOMPOSITE_OPERATOR_XOR:
>         filterContext.drawImageBuffer(*imageBuffer2, drawingRegionOfInputImage(in2->absolutePaintRect()));
>-        filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), CompositeXOR);
>+        filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), CompositeOperator::XOR);
>         break;
>     case FECOMPOSITE_OPERATOR_LIGHTER:
>         filterContext.drawImageBuffer(*imageBuffer2, drawingRegionOfInputImage(in2->absolutePaintRect()));
>-        filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), CompositePlusLighter);
>+        filterContext.drawImageBuffer(*imageBuffer, drawingRegionOfInputImage(in->absolutePaintRect()), IntRect(IntPoint(), imageBuffer->logicalSize()), CompositeOperator::PlusLighter);
>         break;
>     default:
>         break;
>diff --git a/Source/WebCore/platform/graphics/filters/FEDropShadow.cpp b/Source/WebCore/platform/graphics/filters/FEDropShadow.cpp
>index a3744fa15e0f3f9a03b8696706d28c1458616c42..52d5e18d860aa206ef491b82e37269828cce03ae 100644
>--- a/Source/WebCore/platform/graphics/filters/FEDropShadow.cpp
>+++ b/Source/WebCore/platform/graphics/filters/FEDropShadow.cpp
>@@ -108,9 +108,9 @@ void FEDropShadow::platformApplySoftware()
> 
>     resultImage->putByteArray(*srcPixelArray, AlphaPremultiplication::Premultiplied, shadowArea.size(), shadowArea, IntPoint(), ImageBuffer::BackingStoreCoordinateSystem);
> 
>-    resultContext.setCompositeOperation(CompositeSourceIn);
>+    resultContext.setCompositeOperation(CompositeOperator::SourceIn);
>     resultContext.fillRect(FloatRect(FloatPoint(), absolutePaintRect().size()), m_shadowColor);
>-    resultContext.setCompositeOperation(CompositeDestinationOver);
>+    resultContext.setCompositeOperation(CompositeOperator::DestinationOver);
> 
>     resultImage->context().drawImageBuffer(*sourceImage, drawingRegion);
> }
>diff --git a/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp b/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp
>index acb73823a7a9e7b8120d879fa4581cbd47f1b559..7b202446e785c2be1dc0fe86d817900c7267aa01 100644
>--- a/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp
>+++ b/Source/WebCore/platform/graphics/filters/SourceAlpha.cpp
>@@ -60,7 +60,7 @@ void SourceAlpha::platformApplySoftware()
> 
>     FloatRect imageRect(FloatPoint(), absolutePaintRect().size());
>     filterContext.fillRect(imageRect, Color::black);
>-    filterContext.drawImageBuffer(*imageBuffer, IntPoint(), CompositeDestinationIn);
>+    filterContext.drawImageBuffer(*imageBuffer, IntPoint(), CompositeOperator::DestinationIn);
> }
> 
> TextStream& SourceAlpha::externalRepresentation(TextStream& ts, RepresentationType) const
>diff --git a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
>index e3635d221f936af993fc1932b4eb7ac37057d022..c5968c67667714f56782ab8954b9096e71c0a185 100644
>--- a/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
>+++ b/Source/WebCore/platform/graphics/gstreamer/MediaPlayerPrivateGStreamerBase.cpp
>@@ -907,7 +907,7 @@ void MediaPlayerPrivateGStreamerBase::paint(GraphicsContext& context, const Floa
>     if (!GST_IS_SAMPLE(m_sample.get()))
>         return;
> 
>-    ImagePaintingOptions paintingOptions(CompositeCopy);
>+    ImagePaintingOptions paintingOptions(CompositeOperator::Copy);
>     if (m_renderingCanBeAccelerated)
>         paintingOptions.m_orientationDescription.setImageOrientationEnum(m_videoSourceOrientation);
> 
>diff --git a/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineBasic.cpp b/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineBasic.cpp
>index 3a164c28a6fc5b80270507d291263db9e0049183..558894109ce64e9b077bfe63b7ae87ec0792362b 100644
>--- a/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineBasic.cpp
>+++ b/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineBasic.cpp
>@@ -55,9 +55,9 @@ bool PaintingEngineBasic::paint(GraphicsLayer& layer, Ref<Buffer>&& buffer, cons
>             context.translate(targetRect.x(), targetRect.y());
> 
>             if (supportsAlpha) {
>-                context.setCompositeOperation(CompositeCopy);
>+                context.setCompositeOperation(CompositeOperator::Copy);
>                 context.fillRect(IntRect(IntPoint::zero(), sourceRect.size()), Color::transparent);
>-                context.setCompositeOperation(CompositeSourceOver);
>+                context.setCompositeOperation(CompositeOperator::SourceOver);
>             }
> 
>             context.translate(-sourceRect.x(), -sourceRect.y());
>diff --git a/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineThreaded.cpp b/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineThreaded.cpp
>index 9705e62e017ee4c770fa2fe25dcbf489fea0a807..303c6ff93a77cfdcb00fab30dcc6cb277226434a 100644
>--- a/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineThreaded.cpp
>+++ b/Source/WebCore/platform/graphics/nicosia/NicosiaPaintingEngineThreaded.cpp
>@@ -46,9 +46,9 @@ static void paintLayer(GraphicsContext& context, GraphicsLayer& layer, const Int
>     context.translate(targetRect.x(), targetRect.y());
> 
>     if (supportsAlpha) {
>-        context.setCompositeOperation(CompositeCopy);
>+        context.setCompositeOperation(CompositeOperator::Copy);
>         context.fillRect(IntRect(IntPoint::zero(), sourceRect.size()), Color::transparent);
>-        context.setCompositeOperation(CompositeSourceOver);
>+        context.setCompositeOperation(CompositeOperator::SourceOver);
>     }
> 
>     context.translate(-sourceRect.x(), -sourceRect.y());
>diff --git a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>index 9a954e22b94bbae9cb175feafc042fffeb5afe1d..85d3ec30f82bddbc71657b5746c06d1184c6b17d 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.cpp
>@@ -305,7 +305,7 @@ void CairoOperationRecorder::fillRect(const FloatRect& rect, const Color& color,
> 
>             Cairo::State::setCompositeOperation(platformContext, arg<2>(), arg<3>());
>             Cairo::fillRect(platformContext, arg<0>(), arg<1>(), arg<4>());
>-            Cairo::State::setCompositeOperation(platformContext, arg<5>(), BlendModeNormal);
>+            Cairo::State::setCompositeOperation(platformContext, arg<5>(), BlendMode::Normal);
>         }
> 
>         void dump(TextStream& ts) override
>@@ -335,7 +335,7 @@ void CairoOperationRecorder::fillRoundedRect(const FloatRoundedRect& roundedRect
>             else
>                 Cairo::fillRect(platformContext, rect.rect(), arg<1>(), arg<4>());
> 
>-            Cairo::State::setCompositeOperation(platformContext, arg<2>(), BlendModeNormal);
>+            Cairo::State::setCompositeOperation(platformContext, arg<2>(), BlendMode::Normal);
>         }
> 
>         void dump(TextStream& ts) override
>diff --git a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>index dc4849e5cf4a8ca92f39a265cd99c143a98cd530..009eb22108c3e7ef67ea56657c2d7963c233eade 100644
>--- a/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>+++ b/Source/WebCore/platform/graphics/nicosia/cairo/NicosiaCairoOperationRecorder.h
>@@ -68,7 +68,7 @@ private:
>     WebCore::ImageDrawResult drawTiledImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatPoint&, const WebCore::FloatSize&, const WebCore::FloatSize&, const WebCore::ImagePaintingOptions&) override;
>     WebCore::ImageDrawResult drawTiledImage(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::FloatSize&, WebCore::Image::TileRule, WebCore::Image::TileRule, const WebCore::ImagePaintingOptions&) override;
>     void drawNativeImage(const WebCore::NativeImagePtr&, const WebCore::FloatSize&, const WebCore::FloatRect&, const WebCore::FloatRect&, WebCore::CompositeOperator, WebCore::BlendMode, WebCore::ImageOrientation) override;
>-    void drawPattern(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::AffineTransform&, const WebCore::FloatPoint&, const WebCore::FloatSize&, WebCore::CompositeOperator, WebCore::BlendMode = WebCore::BlendModeNormal) override;
>+    void drawPattern(WebCore::Image&, const WebCore::FloatRect&, const WebCore::FloatRect&, const WebCore::AffineTransform&, const WebCore::FloatPoint&, const WebCore::FloatSize&, WebCore::CompositeOperator, WebCore::BlendMode = WebCore::BlendMode::Normal) override;
> 
>     void drawRect(const WebCore::FloatRect&, float) override;
>     void drawLine(const WebCore::FloatPoint&, const WebCore::FloatPoint&) override;
>diff --git a/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp b/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp
>index 258ba5a6a24aa582f9056a0b0f6c878e375e67fd..926d6d1e02b79f57f626dc85d4c15f0be9bef15f 100644
>--- a/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp
>+++ b/Source/WebCore/platform/graphics/texmap/coordinated/CoordinatedImageBacking.cpp
>@@ -110,7 +110,7 @@ void CoordinatedImageBacking::update()
>         [this](GraphicsContext& context)
>         {
>             IntRect rect { { }, IntSize { m_image->size() } };
>-            context.drawImage(m_image, rect, rect, ImagePaintingOptions(CompositeCopy));
>+            context.drawImage(m_image, rect, rect, ImagePaintingOptions(CompositeOperator::Copy));
>         });
> 
>     m_client.updateImageBacking(m_id, WTFMove(buffer));
>diff --git a/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp b/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp
>index 029d079cc1c200398a7811e66f3e33e793961bac..2454385fc9964289eed0ece659d800b28b55ea22 100644
>--- a/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp
>+++ b/Source/WebCore/platform/graphics/win/GraphicsContextDirect2D.cpp
>@@ -1881,57 +1881,57 @@ void GraphicsContext::setPlatformCompositeOperation(CompositeOperator mode, Blen
>     D2D1_BLEND_MODE targetBlendMode = D2D1_BLEND_MODE_SCREEN;
>     D2D1_COMPOSITE_MODE targetCompositeMode = D2D1_COMPOSITE_MODE_SOURCE_ATOP; // ???
> 
>-    if (blendMode != BlendModeNormal) {
>+    if (blendMode != BlendMode::Normal) {
>         switch (blendMode) {
>-        case BlendModeMultiply:
>+        case BlendMode::Multiply:
>             targetBlendMode = D2D1_BLEND_MODE_MULTIPLY;
>             break;
>-        case BlendModeScreen:
>+        case BlendMode::Screen:
>             targetBlendMode = D2D1_BLEND_MODE_SCREEN;
>             break;
>-        case BlendModeOverlay:
>+        case BlendMode::Overlay:
>             targetBlendMode = D2D1_BLEND_MODE_OVERLAY;
>             break;
>-        case BlendModeDarken:
>+        case BlendMode::Darken:
>             targetBlendMode = D2D1_BLEND_MODE_DARKEN;
>             break;
>-        case BlendModeLighten:
>+        case BlendMode::Lighten:
>             targetBlendMode = D2D1_BLEND_MODE_LIGHTEN;
>             break;
>-        case BlendModeColorDodge:
>+        case BlendMode::ColorDodge:
>             targetBlendMode = D2D1_BLEND_MODE_COLOR_DODGE;
>             break;
>-        case BlendModeColorBurn:
>+        case BlendMode::ColorBurn:
>             targetBlendMode = D2D1_BLEND_MODE_COLOR_BURN;
>             break;
>-        case BlendModeHardLight:
>+        case BlendMode::HardLight:
>             targetBlendMode = D2D1_BLEND_MODE_HARD_LIGHT;
>             break;
>-        case BlendModeSoftLight:
>+        case BlendMode::SoftLight:
>             targetBlendMode = D2D1_BLEND_MODE_SOFT_LIGHT;
>             break;
>-        case BlendModeDifference:
>+        case BlendMode::Difference:
>             targetBlendMode = D2D1_BLEND_MODE_DIFFERENCE;
>             break;
>-        case BlendModeExclusion:
>+        case BlendMode::Exclusion:
>             targetBlendMode = D2D1_BLEND_MODE_EXCLUSION;
>             break;
>-        case BlendModeHue:
>+        case BlendMode::Hue:
>             targetBlendMode = D2D1_BLEND_MODE_HUE;
>             break;
>-        case BlendModeSaturation:
>+        case BlendMode::Saturation:
>             targetBlendMode = D2D1_BLEND_MODE_SATURATION;
>             break;
>-        case BlendModeColor:
>+        case BlendMode::Color:
>             targetBlendMode = D2D1_BLEND_MODE_COLOR;
>             break;
>-        case BlendModeLuminosity:
>+        case BlendMode::Luminosity:
>             targetBlendMode = D2D1_BLEND_MODE_LUMINOSITY;
>             break;
>-        case BlendModePlusDarker:
>+        case BlendMode::PlusDarker:
>             targetBlendMode = D2D1_BLEND_MODE_DARKER_COLOR;
>             break;
>-        case BlendModePlusLighter:
>+        case BlendMode::PlusLighter:
>             targetBlendMode = D2D1_BLEND_MODE_LIGHTER_COLOR;
>             break;
>         default:
>@@ -1939,46 +1939,46 @@ void GraphicsContext::setPlatformCompositeOperation(CompositeOperator mode, Blen
>         }
>     } else {
>         switch (mode) {
>-        case CompositeClear:
>+        case CompositeOperator::Clear:
>             // FIXME: targetBlendMode = D2D1_BLEND_MODE_CLEAR;
>             break;
>-        case CompositeCopy:
>+        case CompositeOperator::Copy:
>             // FIXME: targetBlendMode = D2D1_BLEND_MODE_COPY;
>             break;
>-        case CompositeSourceOver:
>+        case CompositeOperator::SourceOver:
>             // FIXME: kCGBlendModeNormal
>             break;
>-        case CompositeSourceIn:
>+        case CompositeOperator::SourceIn:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_SOURCE_IN;
>             break;
>-        case CompositeSourceOut:
>+        case CompositeOperator::SourceOut:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_SOURCE_OUT;
>             break;
>-        case CompositeSourceAtop:
>+        case CompositeOperator::SourceAtop:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_SOURCE_ATOP;
>             break;
>-        case CompositeDestinationOver:
>+        case CompositeOperator::DestinationOver:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_DESTINATION_OVER;
>             break;
>-        case CompositeDestinationIn:
>+        case CompositeOperator::DestinationIn:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_DESTINATION_IN;
>             break;
>-        case CompositeDestinationOut:
>+        case CompositeOperator::DestinationOut:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_DESTINATION_OUT;
>             break;
>-        case CompositeDestinationAtop:
>+        case CompositeOperator::DestinationAtop:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_DESTINATION_ATOP;
>             break;
>-        case CompositeXOR:
>+        case CompositeOperator::XOR:
>             targetCompositeMode = D2D1_COMPOSITE_MODE_XOR;
>             break;
>-        case CompositePlusDarker:
>+        case CompositeOperator::PlusDarker:
>             targetBlendMode = D2D1_BLEND_MODE_DARKER_COLOR;
>             break;
>-        case CompositePlusLighter:
>+        case CompositeOperator::PlusLighter:
>             targetBlendMode = D2D1_BLEND_MODE_LIGHTER_COLOR;
>             break;
>-        case CompositeDifference:
>+        case CompositeOperator::Difference:
>             targetBlendMode = D2D1_BLEND_MODE_DIFFERENCE;
>             break;
>         }
>diff --git a/Source/WebCore/platform/graphics/win/ImageCGWin.cpp b/Source/WebCore/platform/graphics/win/ImageCGWin.cpp
>index 06dc83a6e55534d89b39b897c7b94e23b2d9f77b..c6ff663f907bc3aa122921b6e6f1f9eba1f47d1d 100644
>--- a/Source/WebCore/platform/graphics/win/ImageCGWin.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageCGWin.cpp
>@@ -79,7 +79,7 @@ bool BitmapImage::getHBITMAPOfSize(HBITMAP bmp, const IntSize* size)
>     if (size)
>         drawFrameMatchingSourceSize(gc, FloatRect(0.0f, 0.0f, bmpInfo.bmWidth, bmpInfo.bmHeight), *size, CompositeCopy);
>     else
>-        draw(gc, FloatRect(0.0f, 0.0f, bmpInfo.bmWidth, bmpInfo.bmHeight), FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), CompositeCopy, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+        draw(gc, FloatRect(0.0f, 0.0f, bmpInfo.bmWidth, bmpInfo.bmHeight), FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), CompositeCopy, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
> 
>     // Do cleanup
>     CGContextRelease(cgContext);
>@@ -95,7 +95,7 @@ void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float
>         if (image && CGImageGetHeight(image) == static_cast<size_t>(srcSize.height()) && CGImageGetWidth(image) == static_cast<size_t>(srcSize.width())) {
>             size_t currentFrame = m_currentFrame;
>             m_currentFrame = i;
>-            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), compositeOp, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), compositeOp, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
>             m_currentFrame = currentFrame;
>             return;
>         }
>@@ -103,7 +103,7 @@ void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float
> 
>     // No image of the correct size was found, fallback to drawing the current frame
>     FloatSize imageSize = BitmapImage::size();
>-    draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), compositeOp, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+    draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), compositeOp, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/win/ImageCairoWin.cpp b/Source/WebCore/platform/graphics/win/ImageCairoWin.cpp
>index e927e10384ec7cb99125e68116211d5bc3e09abb..c93c56f1d621c14ea923d366b162ffe46e22dedd 100644
>--- a/Source/WebCore/platform/graphics/win/ImageCairoWin.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageCairoWin.cpp
>@@ -81,7 +81,7 @@ bool BitmapImage::getHBITMAPOfSize(HBITMAP bmp, const IntSize* size)
>     if (size)
>         drawFrameMatchingSourceSize(gc, FloatRect(0.0f, 0.0f, bmpInfo.bmWidth, bmpInfo.bmHeight), *size, CompositeCopy);
>     else
>-        draw(gc, FloatRect(0.0f, 0.0f, bmpInfo.bmWidth, bmpInfo.bmHeight), FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), CompositeCopy, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+        draw(gc, FloatRect(0.0f, 0.0f, bmpInfo.bmWidth, bmpInfo.bmHeight), FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), CompositeOperator::Copy, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
> 
>     // Do cleanup
>     cairo_destroy(targetRef);
>@@ -100,7 +100,7 @@ void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float
>         if (cairo_image_surface_get_height(surface.get()) == static_cast<size_t>(srcSize.height()) && cairo_image_surface_get_width(surface.get()) == static_cast<size_t>(srcSize.width())) {
>             size_t currentFrame = m_currentFrame;
>             m_currentFrame = i;
>-            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), compositeOp, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), compositeOp, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
>             m_currentFrame = currentFrame;
>             return;
>         }
>@@ -108,7 +108,7 @@ void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float
> 
>     // No image of the correct size was found, fallback to drawing the current frame
>     FloatSize imageSize = BitmapImage::size();
>-    draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), compositeOp, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+    draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), compositeOp, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/platform/graphics/win/ImageDirect2D.cpp b/Source/WebCore/platform/graphics/win/ImageDirect2D.cpp
>index a98fa738a3474a15b27a4b28ee18f22c8044d2e2..6eb437dbe9af61752f687fc8b9cbabf368be33b2 100644
>--- a/Source/WebCore/platform/graphics/win/ImageDirect2D.cpp
>+++ b/Source/WebCore/platform/graphics/win/ImageDirect2D.cpp
>@@ -81,7 +81,7 @@ void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float
>         if (image && clampTo<size_t>(imageSize.height) == static_cast<size_t>(srcSize.height()) && clampTo<size_t>(imageSize.width) == static_cast<size_t>(srcSize.width())) {
>             size_t currentFrame = m_currentFrame;
>             m_currentFrame = i;
>-            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), compositeOp, BlendModeNormal, ImageOrientationDescription());
>+            draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, srcSize.width(), srcSize.height()), compositeOp, BlendMode::Normal, ImageOrientationDescription());
>             m_currentFrame = currentFrame;
>             return;
>         }
>@@ -89,7 +89,7 @@ void BitmapImage::drawFrameMatchingSourceSize(GraphicsContext& ctxt, const Float
> 
>     // No image of the correct size was found, fallback to drawing the current frame
>     FloatSize imageSize = BitmapImage::size();
>-    draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), compositeOp, BlendModeNormal, ImageOrientationDescription());
>+    draw(ctxt, dstRect, FloatRect(0.0f, 0.0f, imageSize.width(), imageSize.height()), compositeOp, BlendMode::Normal, ImageOrientationDescription());
> }
> 
> } // namespace WebCore
>diff --git a/Source/WebCore/rendering/InlineFlowBox.cpp b/Source/WebCore/rendering/InlineFlowBox.cpp
>index ced364553a2d5d3027eb9ad8e3e9ab980c809cfd..a96e66349904f1b298c5124466940d8848f1d51a 100644
>--- a/Source/WebCore/rendering/InlineFlowBox.cpp
>+++ b/Source/WebCore/rendering/InlineFlowBox.cpp
>@@ -1362,9 +1362,9 @@ void InlineFlowBox::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint&
> 
>     Color color = lineStyle.visitedDependentColor(CSSPropertyBackgroundColor);
> 
>-    CompositeOperator compositeOp = CompositeSourceOver;
>+    CompositeOperator compositeOp = CompositeOperator::SourceOver;
>     if (renderer().document().settings().punchOutWhiteBackgroundsInDarkMode() && Color::isWhiteColor(color) && renderer().theme().usingDarkAppearance(renderer()))
>-        compositeOp = CompositeDestinationOut;
>+        compositeOp = CompositeOperator::DestinationOut;
> 
>     color = lineStyle.colorByApplyingColorFilter(color);
> 
>@@ -1432,16 +1432,16 @@ void InlineFlowBox::paintMask(PaintInfo& paintInfo, const LayoutPoint& paintOffs
>     bool pushTransparencyLayer = false;
>     bool compositedMask = renderer().hasLayer() && renderer().layer()->hasCompositedMask();
>     bool flattenCompositingLayers = renderer().view().frameView().paintBehavior() & PaintBehaviorFlattenCompositingLayers;
>-    CompositeOperator compositeOp = CompositeSourceOver;
>+    CompositeOperator compositeOp = CompositeOperator::SourceOver;
>     if (!compositedMask || flattenCompositingLayers) {
>         if ((maskBoxImage && renderer().style().maskLayers().hasImage()) || renderer().style().maskLayers().next())
>             pushTransparencyLayer = true;
>         
>-        compositeOp = CompositeDestinationIn;
>+        compositeOp = CompositeOperator::DestinationIn;
>         if (pushTransparencyLayer) {
>-            paintInfo.context().setCompositeOperation(CompositeDestinationIn);
>+            paintInfo.context().setCompositeOperation(CompositeOperator::DestinationIn);
>             paintInfo.context().beginTransparencyLayer(1.0f);
>-            compositeOp = CompositeSourceOver;
>+            compositeOp = CompositeOperator::SourceOver;
>         }
>     }
> 
>diff --git a/Source/WebCore/rendering/InlineFlowBox.h b/Source/WebCore/rendering/InlineFlowBox.h
>index 27c6229466ca51d47a82a5a32e3518a2bba47f35..20286c3b0124af38ab88f9740c3cd4e80d2e954b 100644
>--- a/Source/WebCore/rendering/InlineFlowBox.h
>+++ b/Source/WebCore/rendering/InlineFlowBox.h
>@@ -115,8 +115,8 @@ public:
> 
>     void paintBoxDecorations(PaintInfo&, const LayoutPoint&);
>     void paintMask(PaintInfo&, const LayoutPoint&);
>-    void paintFillLayers(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, CompositeOperator = CompositeSourceOver);
>-    void paintFillLayer(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, CompositeOperator = CompositeSourceOver);
>+    void paintFillLayers(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, CompositeOperator = CompositeOperator::SourceOver);
>+    void paintFillLayer(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, CompositeOperator = CompositeOperator::SourceOver);
>     void paintBoxShadow(const PaintInfo&, const RenderStyle&, ShadowStyle, const LayoutRect&);
>     void paint(PaintInfo&, const LayoutPoint&, LayoutUnit lineTop, LayoutUnit lineBottom) override;
>     bool nodeAtPoint(const HitTestRequest&, HitTestResult&, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, LayoutUnit lineTop, LayoutUnit lineBottom, HitTestAction) override;
>diff --git a/Source/WebCore/rendering/RenderBox.cpp b/Source/WebCore/rendering/RenderBox.cpp
>index b661f382d9ecc3a35ce87f0cdfd5cf2f0dfe3c03..d760f4c225d44dcb04f459e90c6e4f7dc9ba6f60 100644
>--- a/Source/WebCore/rendering/RenderBox.cpp
>+++ b/Source/WebCore/rendering/RenderBox.cpp
>@@ -1194,9 +1194,9 @@ void RenderBox::paintRootBoxFillLayers(const PaintInfo& paintInfo)
> 
>     auto color = style.visitedDependentColor(CSSPropertyBackgroundColor);
> 
>-    CompositeOperator compositeOp = CompositeSourceOver;
>+    CompositeOperator compositeOp = CompositeOperator::SourceOver;
>     if (document().settings().punchOutWhiteBackgroundsInDarkMode() && Color::isWhiteColor(color) && theme().usingDarkAppearance(*this))
>-        compositeOp = CompositeDestinationOut;
>+        compositeOp = CompositeOperator::DestinationOut;
> 
>     paintFillLayers(paintInfo, style.colorByApplyingColorFilter(color), style.backgroundLayers(), view().backgroundRect(), BackgroundBleedNone, compositeOp, rootBackgroundRenderer);
> }
>@@ -1328,9 +1328,9 @@ void RenderBox::paintBackground(const PaintInfo& paintInfo, const LayoutRect& pa
> 
>     Color backgroundColor = style().visitedDependentColor(CSSPropertyBackgroundColor);
> 
>-    CompositeOperator compositeOp = CompositeSourceOver;
>+    CompositeOperator compositeOp = CompositeOperator::SourceOver;
>     if (document().settings().punchOutWhiteBackgroundsInDarkMode() && Color::isWhiteColor(backgroundColor) && theme().usingDarkAppearance(*this))
>-        compositeOp = CompositeDestinationOut;
>+        compositeOp = CompositeOperator::DestinationOut;
> 
>     paintFillLayers(paintInfo, style().colorByApplyingColorFilter(backgroundColor), style().backgroundLayers(), paintRect, bleedAvoidance, compositeOp);
> }
>@@ -1523,7 +1523,7 @@ void RenderBox::paintMaskImages(const PaintInfo& paintInfo, const LayoutRect& pa
>     bool pushTransparencyLayer = false;
>     bool compositedMask = hasLayer() && layer()->hasCompositedMask();
>     bool flattenCompositingLayers = paintInfo.paintBehavior & PaintBehaviorFlattenCompositingLayers;
>-    CompositeOperator compositeOp = CompositeSourceOver;
>+    CompositeOperator compositeOp = CompositeOperator::SourceOver;
> 
>     bool allMaskImagesLoaded = true;
>     
>@@ -1536,9 +1536,9 @@ void RenderBox::paintMaskImages(const PaintInfo& paintInfo, const LayoutRect& pa
> 
>         allMaskImagesLoaded &= style().maskLayers().imagesAreLoaded();
> 
>-        paintInfo.context().setCompositeOperation(CompositeDestinationIn);
>+        paintInfo.context().setCompositeOperation(CompositeOperator::DestinationIn);
>         paintInfo.context().beginTransparencyLayer(1);
>-        compositeOp = CompositeSourceOver;
>+        compositeOp = CompositeOperator::SourceOver;
>     }
> 
>     if (allMaskImagesLoaded) {
>@@ -1581,7 +1581,7 @@ void RenderBox::paintFillLayers(const PaintInfo& paintInfo, const Color& color,
>     for (auto* layer = &fillLayer; layer; layer = layer->next()) {
>         layers.append(layer);
> 
>-        if (layer->blendMode() != BlendModeNormal)
>+        if (layer->blendMode() != BlendMode::Normal)
>             shouldDrawBackgroundInSeparateBuffer = true;
> 
>         // Stop traversal when an opaque layer is encountered.
>@@ -1593,7 +1593,7 @@ void RenderBox::paintFillLayers(const PaintInfo& paintInfo, const Color& color,
>         // and pass it down.
> 
>         // The clipOccludesNextLayers condition must be evaluated first to avoid short-circuiting.
>-        if (layer->clipOccludesNextLayers(layer == &fillLayer) && layer->hasOpaqueImage(*this) && layer->image()->canRender(this, style().effectiveZoom()) && layer->hasRepeatXY() && layer->blendMode() == BlendModeNormal)
>+        if (layer->clipOccludesNextLayers(layer == &fillLayer) && layer->hasOpaqueImage(*this) && layer->image()->canRender(this, style().effectiveZoom()) && layer->hasRepeatXY() && layer->blendMode() == BlendMode::Normal)
>             break;
>     }
> 
>diff --git a/Source/WebCore/rendering/RenderBox.h b/Source/WebCore/rendering/RenderBox.h
>index 3823db885f83c8d68b68d7557eb665eb51f61472..a7a0ece1e5483f110f02bb32f57fd1ab0e361f1e 100644
>--- a/Source/WebCore/rendering/RenderBox.h
>+++ b/Source/WebCore/rendering/RenderBox.h
>@@ -645,7 +645,7 @@ protected:
>     void paintBackground(const PaintInfo&, const LayoutRect&, BackgroundBleedAvoidance = BackgroundBleedNone);
>     
>     void paintFillLayer(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, BackgroundBleedAvoidance, CompositeOperator, RenderElement* backgroundObject, BaseBackgroundColorUsage = BaseBackgroundColorUse);
>-    void paintFillLayers(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, BackgroundBleedAvoidance = BackgroundBleedNone, CompositeOperator = CompositeSourceOver, RenderElement* backgroundObject = nullptr);
>+    void paintFillLayers(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, BackgroundBleedAvoidance = BackgroundBleedNone, CompositeOperator = CompositeOperator::SourceOver, RenderElement* backgroundObject = nullptr);
> 
>     void paintMaskImages(const PaintInfo&, const LayoutRect&);
> 
>diff --git a/Source/WebCore/rendering/RenderBoxModelObject.cpp b/Source/WebCore/rendering/RenderBoxModelObject.cpp
>index 70c228f5b67b5d3a7d0c4c457667ef19629c1fb5..0bb09958a0a2465769d4a7dd0761d34dcc32f77a 100644
>--- a/Source/WebCore/rendering/RenderBoxModelObject.cpp
>+++ b/Source/WebCore/rendering/RenderBoxModelObject.cpp
>@@ -952,14 +952,14 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
>             if (baseColor.isVisible()) {
>                 if (!baseBgColorOnly && bgColor.isVisible())
>                     baseColor = baseColor.blend(bgColor);
>-                context.fillRect(backgroundRectForPainting, baseColor, CompositeCopy);
>+                context.fillRect(backgroundRectForPainting, baseColor, CompositeOperator::Copy);
>             } else if (!baseBgColorOnly && bgColor.isVisible()) {
>                 auto operation = context.compositeOperation();
>                 if (shouldClearBackground) {
>-                    if (op == CompositeDestinationOut) // We're punching out the background.
>+                    if (op == CompositeOperator::DestinationOut) // We're punching out the background.
>                         operation = op;
>                     else
>-                        operation = CompositeCopy;
>+                        operation = CompositeOperator::Copy;
>                 }
>                 context.fillRect(backgroundRectForPainting, bgColor, operation);
>             } else if (shouldClearBackground)
>@@ -973,7 +973,7 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
>         geometry.clip(LayoutRect(pixelSnappedRect));
>         RefPtr<Image> image;
>         if (!geometry.destRect().isEmpty() && (image = bgImage->image(backgroundObject ? backgroundObject : this, geometry.tileSize()))) {
>-            auto compositeOp = op == CompositeSourceOver ? bgLayer.composite() : op;
>+            auto compositeOp = op == CompositeOperator::SourceOver ? bgLayer.composite() : op;
>             context.setDrawLuminanceMask(bgLayer.maskSourceType() == MaskSourceType::Luminance);
> 
>             if (is<BitmapImage>(image))
>@@ -990,7 +990,7 @@ void RenderBoxModelObject::paintFillLayerExtended(const PaintInfo& paintInfo, co
>     }
> 
>     if (maskImage && bgLayer.clip() == FillBox::Text) {
>-        context.drawConsumingImageBuffer(WTFMove(maskImage), maskRect, CompositeDestinationIn);
>+        context.drawConsumingImageBuffer(WTFMove(maskImage), maskRect, CompositeOperator::DestinationIn);
>         context.endTransparencyLayer();
>     }
> }
>diff --git a/Source/WebCore/rendering/RenderBoxModelObject.h b/Source/WebCore/rendering/RenderBoxModelObject.h
>index ec3b1cb85cd8ff5957d2ecf0f363a2cd07a1427a..7de2a34dbb028189ae6033478d95a1b5ead1f20c 100644
>--- a/Source/WebCore/rendering/RenderBoxModelObject.h
>+++ b/Source/WebCore/rendering/RenderBoxModelObject.h
>@@ -203,9 +203,9 @@ public:
>     virtual LayoutUnit containingBlockLogicalWidthForContent() const;
> 
>     void paintBorder(const PaintInfo&, const LayoutRect&, const RenderStyle&, BackgroundBleedAvoidance = BackgroundBleedNone, bool includeLogicalLeftEdge = true, bool includeLogicalRightEdge = true);
>-    bool paintNinePieceImage(GraphicsContext&, const LayoutRect&, const RenderStyle&, const NinePieceImage&, CompositeOperator = CompositeSourceOver);
>+    bool paintNinePieceImage(GraphicsContext&, const LayoutRect&, const RenderStyle&, const NinePieceImage&, CompositeOperator = CompositeOperator::SourceOver);
>     void paintBoxShadow(const PaintInfo&, const LayoutRect&, const RenderStyle&, ShadowStyle, bool includeLogicalLeftEdge = true, bool includeLogicalRightEdge = true);
>-    void paintFillLayerExtended(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, BackgroundBleedAvoidance, InlineFlowBox* = nullptr, const LayoutSize& = LayoutSize(), CompositeOperator = CompositeSourceOver, RenderElement* backgroundObject = nullptr, BaseBackgroundColorUsage = BaseBackgroundColorUse);
>+    void paintFillLayerExtended(const PaintInfo&, const Color&, const FillLayer&, const LayoutRect&, BackgroundBleedAvoidance, InlineFlowBox* = nullptr, const LayoutSize& = LayoutSize(), CompositeOperator = CompositeOperator::SourceOver, RenderElement* backgroundObject = nullptr, BaseBackgroundColorUsage = BaseBackgroundColorUse);
> 
>     virtual bool boxShadowShouldBeAppliedToBackground(const LayoutPoint& absolutePaintPostion, BackgroundBleedAvoidance, InlineFlowBox* = nullptr) const;
> 
>diff --git a/Source/WebCore/rendering/RenderEmbeddedObject.cpp b/Source/WebCore/rendering/RenderEmbeddedObject.cpp
>index b982504a7627d498950f081f32ff77edc2dc6ed7..a04ff4888273d83b193db1655264246d79a9ec97 100644
>--- a/Source/WebCore/rendering/RenderEmbeddedObject.cpp
>+++ b/Source/WebCore/rendering/RenderEmbeddedObject.cpp
>@@ -338,7 +338,7 @@ void RenderEmbeddedObject::paintReplaced(PaintInfo& paintInfo, const LayoutPoint
>         context.setFillColor(replacementTextColor());
>         context.fillEllipse(arrowRect);
> 
>-        context.setCompositeOperation(CompositeClear);
>+        context.setCompositeOperation(CompositeOperator::Clear);
>         drawReplacementArrow(context, arrowRect);
>         context.endTransparencyLayer();
>     }
>diff --git a/Source/WebCore/rendering/RenderImage.cpp b/Source/WebCore/rendering/RenderImage.cpp
>index 6c093a478edae2b2543b5c59f73c70c40b0bb6cb..84ed24bcbe92cd22a76c0c9a3d830c04ae4540b1 100644
>--- a/Source/WebCore/rendering/RenderImage.cpp
>+++ b/Source/WebCore/rendering/RenderImage.cpp
>@@ -601,7 +601,7 @@ ImageDrawResult RenderImage::paintIntoRect(PaintInfo& paintInfo, const FloatRect
>         return ImageDrawResult::DidNothing;
> 
>     HTMLImageElement* imageElement = is<HTMLImageElement>(element()) ? downcast<HTMLImageElement>(element()) : nullptr;
>-    CompositeOperator compositeOperator = imageElement ? imageElement->compositeOperator() : CompositeSourceOver;
>+    CompositeOperator compositeOperator = imageElement ? imageElement->compositeOperator() : CompositeOperator::SourceOver;
> 
>     // FIXME: Document when image != img.get().
>     Image* image = imageResource().image().get();
>@@ -617,7 +617,7 @@ ImageDrawResult RenderImage::paintIntoRect(PaintInfo& paintInfo, const FloatRect
> 
>     ImageOrientationDescription orientationDescription(shouldRespectImageOrientation(), style().imageOrientation());
>     auto decodingMode = decodingModeForImageDraw(*image, paintInfo);
>-    auto drawResult = paintInfo.context().drawImage(*img, rect, ImagePaintingOptions(compositeOperator, BlendModeNormal, decodingMode, orientationDescription, interpolation));
>+    auto drawResult = paintInfo.context().drawImage(*img, rect, ImagePaintingOptions(compositeOperator, BlendMode::Normal, decodingMode, orientationDescription, interpolation));
>     if (drawResult == ImageDrawResult::DidRequestDecoding)
>         imageResource().cachedImage()->addClientWaitingForAsyncDecoding(*this);
> 
>diff --git a/Source/WebCore/rendering/RenderLayer.cpp b/Source/WebCore/rendering/RenderLayer.cpp
>index d6cfd6a3a5d931714c830ed5f252c98b1bc6574c..a6b725522baee16fc2abad62bb241fc0c7e0ae51 100644
>--- a/Source/WebCore/rendering/RenderLayer.cpp
>+++ b/Source/WebCore/rendering/RenderLayer.cpp
>@@ -313,19 +313,12 @@ RenderLayer::RenderLayer(RenderLayerModelObject& rendererLayerModelObject)
> #endif
>     , m_hasFilterInfo(false)
> #if ENABLE(CSS_COMPOSITING)
>-    , m_blendMode(BlendModeNormal)
>+    , m_blendMode(static_cast<unsigned>(BlendMode::Normal))
>     , m_hasNotIsolatedCompositedBlendingDescendants(false)
>     , m_hasNotIsolatedBlendingDescendants(false)
>     , m_hasNotIsolatedBlendingDescendantsStatusDirty(false)
> #endif
>     , m_renderer(rendererLayerModelObject)
>-    , m_parent(nullptr)
>-    , m_previous(nullptr)
>-    , m_next(nullptr)
>-    , m_first(nullptr)
>-    , m_last(nullptr)
>-    , m_staticInlinePosition(0)
>-    , m_staticBlockPosition(0)
> {
>     m_isNormalFlowOnly = shouldBeNormalFlowOnly();
>     m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
>@@ -926,7 +919,7 @@ void RenderLayer::positionNewlyCreatedOverflowControls()
> 
> void RenderLayer::updateBlendMode()
> {
>-    bool hadBlendMode = m_blendMode != BlendModeNormal;
>+    bool hadBlendMode = blendMode() != BlendMode::Normal;
>     if (parent() && hadBlendMode != hasBlendMode()) {
>         if (hasBlendMode())
>             parent()->updateAncestorChainHasBlendingDescendants();
>@@ -935,8 +928,8 @@ void RenderLayer::updateBlendMode()
>     }
> 
>     BlendMode newBlendMode = renderer().style().blendMode();
>-    if (newBlendMode != m_blendMode)
>-        m_blendMode = newBlendMode;
>+    if (newBlendMode != blendMode())
>+        m_blendMode = static_cast<unsigned>(newBlendMode);
> }
> 
> void RenderLayer::updateAncestorChainHasBlendingDescendants()
>@@ -1827,7 +1820,7 @@ void RenderLayer::beginTransparencyLayers(GraphicsContext& context, const LayerP
> 
> #if ENABLE(CSS_COMPOSITING)
>         if (usesCompositeOperation)
>-            context.setCompositeOperation(context.compositeOperation(), BlendModeNormal);
>+            context.setCompositeOperation(context.compositeOperation(), BlendMode::Normal);
> #endif
> 
> #ifdef REVEAL_TRANSPARENCY_LAYERS
>diff --git a/Source/WebCore/rendering/RenderLayer.h b/Source/WebCore/rendering/RenderLayer.h
>index 47fff652cf9aa70f51546485b79668a36b669e6f..5db2cdb7f62b49f9b1d4ad714e486dae88dd364c 100644
>--- a/Source/WebCore/rendering/RenderLayer.h
>+++ b/Source/WebCore/rendering/RenderLayer.h
>@@ -1109,11 +1109,11 @@ private:
> 
>     RenderLayerModelObject& m_renderer;
> 
>-    RenderLayer* m_parent;
>-    RenderLayer* m_previous;
>-    RenderLayer* m_next;
>-    RenderLayer* m_first;
>-    RenderLayer* m_last;
>+    RenderLayer* m_parent { nullptr };
>+    RenderLayer* m_previous { nullptr };
>+    RenderLayer* m_next { nullptr };
>+    RenderLayer* m_first { nullptr };
>+    RenderLayer* m_last { nullptr };
> 
>     // Our current relative position offset.
>     LayoutSize m_offsetForInFlowPosition;
>diff --git a/Source/WebCore/rendering/RenderLayerBacking.cpp b/Source/WebCore/rendering/RenderLayerBacking.cpp
>index f92a20cc8822e676bad44b13734ae8b0a63fa747..f75aa7d799a2d09ca70f341d349e3ed4e1e629ae 100644
>--- a/Source/WebCore/rendering/RenderLayerBacking.cpp
>+++ b/Source/WebCore/rendering/RenderLayerBacking.cpp
>@@ -540,7 +540,7 @@ void RenderLayerBacking::updateBlendMode(const RenderStyle& style)
>     // FIXME: where is the blend mode updated when m_ancestorClippingLayers come and go?
>     if (m_ancestorClippingLayer) {
>         m_ancestorClippingLayer->setBlendMode(style.blendMode());
>-        m_graphicsLayer->setBlendMode(BlendModeNormal);
>+        m_graphicsLayer->setBlendMode(BlendMode::Normal);
>     } else
>         m_graphicsLayer->setBlendMode(style.blendMode());
> }
>@@ -2006,7 +2006,7 @@ static bool supportsDirectlyCompositedBoxDecorations(const RenderLayerModelObjec
>         return false;
> 
>     // FIXME: we should be able to allow backgroundComposite; However since this is not a common use case it has been deferred for now.
>-    if (style.backgroundComposite() != CompositeSourceOver)
>+    if (style.backgroundComposite() != CompositeOperator::SourceOver)
>         return false;
> 
>     return true;
>diff --git a/Source/WebCore/rendering/RenderTableCell.cpp b/Source/WebCore/rendering/RenderTableCell.cpp
>index 576a450ee2cac1d39e1bf18ccc358a82126a4423..6bb153943b1437f0b3f34f7ad43c9739846a5902 100644
>--- a/Source/WebCore/rendering/RenderTableCell.cpp
>+++ b/Source/WebCore/rendering/RenderTableCell.cpp
>@@ -1287,10 +1287,10 @@ void RenderTableCell::paintBackgroundsBehindCell(PaintInfo& paintInfo, const Lay
>     const auto& style = backgroundObject->style();
>     auto& bgLayer = style.backgroundLayers();
> 
>-    CompositeOperator compositeOp = CompositeSourceOver;
>+    CompositeOperator compositeOp = CompositeOperator::SourceOver;
>     Color color = style.visitedDependentColor(CSSPropertyBackgroundColor);
>     if (document().settings().punchOutWhiteBackgroundsInDarkMode() && Color::isWhiteColor(color) && theme().usingDarkAppearance(*this))
>-        compositeOp = CompositeDestinationOut;
>+        compositeOp = CompositeOperator::DestinationOut;
> 
>     color = style.colorByApplyingColorFilter(color);
> 
>diff --git a/Source/WebCore/rendering/RenderThemeMac.mm b/Source/WebCore/rendering/RenderThemeMac.mm
>index 37665fd32d24762371bdc8209ce6c2e740e2f0aa..4646035c88af98ac4d6b25a474336b4e15962316 100644
>--- a/Source/WebCore/rendering/RenderThemeMac.mm
>+++ b/Source/WebCore/rendering/RenderThemeMac.mm
>@@ -2120,7 +2120,7 @@ bool RenderThemeMac::paintSnapshottedPluginOverlay(const RenderObject& renderer,
>     if (alignedPluginRect.width() <= 0 || alignedPluginRect.height() <= 0)
>         return true;
> 
>-    context.drawImage(*snapshot, alignedPluginRect, CompositeSourceOver);
>+    context.drawImage(*snapshot, alignedPluginRect, CompositeOperator::SourceOver);
>     return false;
> }
> 
>diff --git a/Source/WebCore/rendering/RenderTreeAsText.cpp b/Source/WebCore/rendering/RenderTreeAsText.cpp
>index f822a84f0dac7a7a51f66baab82d8e8faf9a23e7..92127ca0b46790965ec54f2935833fa67343a820 100644
>--- a/Source/WebCore/rendering/RenderTreeAsText.cpp
>+++ b/Source/WebCore/rendering/RenderTreeAsText.cpp
>@@ -665,7 +665,7 @@ static void writeLayer(TextStream& ts, const RenderLayer& layer, const LayoutRec
>     if (layer.isolatesBlending())
>         ts << " isolatesBlending";
>     if (layer.hasBlendMode())
>-        ts << " blendMode: " << compositeOperatorName(CompositeSourceOver, layer.blendMode());
>+        ts << " blendMode: " << compositeOperatorName(CompositeOperator::SourceOver, layer.blendMode());
> #endif
>     
>     ts << "\n";
>diff --git a/Source/WebCore/rendering/RenderView.cpp b/Source/WebCore/rendering/RenderView.cpp
>index b6ecdcf1e2770bc62837e08c8326ac403d51907c..55fa98a45e26c29714036da5a49d5048a9c07f9d 100644
>--- a/Source/WebCore/rendering/RenderView.cpp
>+++ b/Source/WebCore/rendering/RenderView.cpp
>@@ -476,7 +476,7 @@ void RenderView::paintBoxDecorations(PaintInfo& paintInfo, const LayoutPoint&)
>         const Color& backgroundColor = (settings().backgroundShouldExtendBeyondPage() && documentBackgroundColor.isValid()) ? documentBackgroundColor : frameView().baseBackgroundColor();
>         if (backgroundColor.isVisible()) {
>             CompositeOperator previousOperator = paintInfo.context().compositeOperation();
>-            paintInfo.context().setCompositeOperation(CompositeCopy);
>+            paintInfo.context().setCompositeOperation(CompositeOperator::Copy);
>             paintInfo.context().fillRect(paintInfo.rect, backgroundColor);
>             paintInfo.context().setCompositeOperation(previousOperator);
>         } else
>diff --git a/Source/WebCore/rendering/style/FillLayer.cpp b/Source/WebCore/rendering/style/FillLayer.cpp
>index 63c058cfc51dbe0e5abe234db742248ddea80a5f..a9df7bb2ae298cef746946a9fb1c92c38a0db2cc 100644
>--- a/Source/WebCore/rendering/style/FillLayer.cpp
>+++ b/Source/WebCore/rendering/style/FillLayer.cpp
>@@ -52,9 +52,9 @@ FillLayer::FillLayer(FillLayerType type)
>     , m_origin(static_cast<unsigned>(FillLayer::initialFillOrigin(type)))
>     , m_repeatX(static_cast<unsigned>(FillLayer::initialFillRepeatX(type)))
>     , m_repeatY(static_cast<unsigned>(FillLayer::initialFillRepeatY(type)))
>-    , m_composite(FillLayer::initialFillComposite(type))
>+    , m_composite(static_cast<unsigned>(FillLayer::initialFillComposite(type)))
>     , m_sizeType(static_cast<unsigned>(FillSizeType::None))
>-    , m_blendMode(FillLayer::initialFillBlendMode(type))
>+    , m_blendMode(static_cast<unsigned>(FillLayer::initialFillBlendMode(type)))
>     , m_maskSourceType(static_cast<unsigned>(FillLayer::initialFillMaskSourceType(type)))
>     , m_imageSet(false)
>     , m_attachmentSet(false)
>@@ -354,10 +354,10 @@ bool FillLayer::hasOpaqueImage(const RenderElement& renderer) const
>     if (!m_image)
>         return false;
> 
>-    if (m_composite == CompositeClear || m_composite == CompositeCopy)
>+    if (composite() == CompositeOperator::Clear || composite() == CompositeOperator::Copy)
>         return true;
> 
>-    return m_blendMode == BlendModeNormal && m_composite == CompositeSourceOver && m_image->knownToBeOpaque(&renderer);
>+    return blendMode() == BlendMode::Normal && composite() == CompositeOperator::SourceOver && m_image->knownToBeOpaque(&renderer);
> }
> 
> bool FillLayer::hasRepeatXY() const
>diff --git a/Source/WebCore/rendering/style/FillLayer.h b/Source/WebCore/rendering/style/FillLayer.h
>index 3f56f7a5c6efd0ae372330ea8e43c4ca6f7e430f..51e7ea6e7e4c362b53f442b5c492099084fa63c4 100644
>--- a/Source/WebCore/rendering/style/FillLayer.h
>+++ b/Source/WebCore/rendering/style/FillLayer.h
>@@ -161,8 +161,8 @@ public:
>     static FillBox initialFillOrigin(FillLayerType type) { return type == FillLayerType::Background ? FillBox::Padding : FillBox::Border; }
>     static FillRepeat initialFillRepeatX(FillLayerType) { return FillRepeat::Repeat; }
>     static FillRepeat initialFillRepeatY(FillLayerType) { return FillRepeat::Repeat; }
>-    static CompositeOperator initialFillComposite(FillLayerType) { return CompositeSourceOver; }
>-    static BlendMode initialFillBlendMode(FillLayerType) { return BlendModeNormal; }
>+    static CompositeOperator initialFillComposite(FillLayerType) { return CompositeOperator::SourceOver; }
>+    static BlendMode initialFillBlendMode(FillLayerType) { return BlendMode::Normal; }
>     static FillSize initialFillSize(FillLayerType) { return { }; }
>     static Length initialFillXPosition(FillLayerType) { return Length(0.0f, Percent); }
>     static Length initialFillYPosition(FillLayerType) { return Length(0.0f, Percent); }
>diff --git a/Source/WebCore/rendering/style/RenderStyle.h b/Source/WebCore/rendering/style/RenderStyle.h
>index 327dd2b3de1edff827e3828324cbb4d409ffc15e..996f20c3846b41b4ad7d15128430b8eda5ade4d8 100644
>--- a/Source/WebCore/rendering/style/RenderStyle.h
>+++ b/Source/WebCore/rendering/style/RenderStyle.h
>@@ -766,14 +766,14 @@ public:
> 
> #if ENABLE(CSS_COMPOSITING)
>     BlendMode blendMode() const { return static_cast<BlendMode>(m_rareNonInheritedData->effectiveBlendMode); }
>-    void setBlendMode(BlendMode mode) { SET_VAR(m_rareNonInheritedData, effectiveBlendMode, mode); }
>-    bool hasBlendMode() const { return static_cast<BlendMode>(m_rareNonInheritedData->effectiveBlendMode) != BlendModeNormal; }
>+    void setBlendMode(BlendMode mode) { SET_VAR(m_rareNonInheritedData, effectiveBlendMode, static_cast<unsigned>(mode)); }
>+    bool hasBlendMode() const { return static_cast<BlendMode>(m_rareNonInheritedData->effectiveBlendMode) != BlendMode::Normal; }
> 
>     Isolation isolation() const { return static_cast<Isolation>(m_rareNonInheritedData->isolation); }
>     void setIsolation(Isolation isolation) { SET_VAR(m_rareNonInheritedData, isolation, static_cast<unsigned>(isolation)); }
>     bool hasIsolation() const { return isolation() != Isolation::Auto; }
> #else
>-    BlendMode blendMode() const { return BlendModeNormal; }
>+    BlendMode blendMode() const { return BlendMode::Normal; }
>     bool hasBlendMode() const { return false; }
> 
>     Isolation isolation() const { return Isolation::Auto; }
>@@ -1671,7 +1671,7 @@ public:
> #endif
> 
> #if ENABLE(CSS_COMPOSITING)
>-    static BlendMode initialBlendMode() { return BlendModeNormal; }
>+    static BlendMode initialBlendMode() { return BlendMode::Normal; }
>     static Isolation initialIsolation() { return Isolation::Auto; }
> #endif
> 
>diff --git a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp b/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp
>index d925fc6080f33a9291f86ec9bce7d8393d84c9a3..0aeac9750c66f55c00eaa086e5052933f0f4dd42 100644
>--- a/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp
>+++ b/Source/WebCore/rendering/style/StyleRareNonInheritedData.cpp
>@@ -91,7 +91,7 @@ StyleRareNonInheritedData::StyleRareNonInheritedData()
>     , textDecorationStyle(static_cast<unsigned>(RenderStyle::initialTextDecorationStyle()))
>     , aspectRatioType(static_cast<unsigned>(RenderStyle::initialAspectRatioType()))
> #if ENABLE(CSS_COMPOSITING)
>-    , effectiveBlendMode(RenderStyle::initialBlendMode())
>+    , effectiveBlendMode(static_cast<unsigned>(RenderStyle::initialBlendMode()))
>     , isolation(static_cast<unsigned>(RenderStyle::initialIsolation()))
> #endif
> #if ENABLE(APPLE_PAY)
>diff --git a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h b/Source/WebCore/rendering/style/StyleRareNonInheritedData.h
>index 089ccfa438cdf5f4e5e0396752741042b80dc138..eb678c7ff04325e8c94b585d9b7d36631f6f3e26 100644
>--- a/Source/WebCore/rendering/style/StyleRareNonInheritedData.h
>+++ b/Source/WebCore/rendering/style/StyleRareNonInheritedData.h
>@@ -192,7 +192,7 @@ public:
>     unsigned aspectRatioType : 2;
> 
> #if ENABLE(CSS_COMPOSITING)
>-    unsigned effectiveBlendMode: 5; // EBlendMode
>+    unsigned effectiveBlendMode: 5; // BlendMode
>     unsigned isolation : 1; // Isolation
> #endif
> 
>diff --git a/Source/WebCore/rendering/svg/SVGRenderingContext.cpp b/Source/WebCore/rendering/svg/SVGRenderingContext.cpp
>index 2baa2f1bbe31ba631f21673317a12b1b414f793f..a0f21c25d20c1ec6db5f48627db9989b06153000 100644
>--- a/Source/WebCore/rendering/svg/SVGRenderingContext.cpp
>+++ b/Source/WebCore/rendering/svg/SVGRenderingContext.cpp
>@@ -122,7 +122,7 @@ void SVGRenderingContext::prepareToRenderSVGContent(RenderElement& renderer, Pai
>             m_paintInfo->context().beginTransparencyLayer(opacity);
> 
>             if (hasBlendMode)
>-                m_paintInfo->context().setCompositeOperation(m_paintInfo->context().compositeOperation(), BlendModeNormal);
>+                m_paintInfo->context().setCompositeOperation(m_paintInfo->context().compositeOperation(), BlendMode::Normal);
> 
>             m_renderingFlags |= EndOpacityLayer;
>         }
>diff --git a/Source/WebCore/svg/SVGAnimatedEnumeration.cpp b/Source/WebCore/svg/SVGAnimatedEnumeration.cpp
>index 1b6159412f51d363d8bdb96293460d8753931a34..34b4ca29a330db3621ed782ee08b54b08d5f9772 100644
>--- a/Source/WebCore/svg/SVGAnimatedEnumeration.cpp
>+++ b/Source/WebCore/svg/SVGAnimatedEnumeration.cpp
>@@ -87,9 +87,9 @@ static inline unsigned enumerationValueForTargetAttribute(SVGElement* targetElem
>     }
> 
>     if (attrName == SVGNames::modeAttr) {
>-        BlendMode mode = BlendModeNormal;
>+        BlendMode mode = BlendMode::Normal;
>         parseBlendMode(value, mode);
>-        return mode;
>+        return static_cast<unsigned>(mode);
>     }
>     if (attrName == SVGNames::stitchTilesAttr)
>         return SVGPropertyTraits<SVGStitchOptions>::fromString(value);
>diff --git a/Source/WebCore/svg/SVGFEBlendElement.cpp b/Source/WebCore/svg/SVGFEBlendElement.cpp
>index 3b4a1105ec431095a5740761d1b3eb502fa50fe3..a7eba0865d35d8ab529ed3747a0c054a192f72f6 100644
>--- a/Source/WebCore/svg/SVGFEBlendElement.cpp
>+++ b/Source/WebCore/svg/SVGFEBlendElement.cpp
>@@ -46,7 +46,7 @@ END_REGISTER_ANIMATED_PROPERTIES
> 
> inline SVGFEBlendElement::SVGFEBlendElement(const QualifiedName& tagName, Document& document)
>     : SVGFilterPrimitiveStandardAttributes(tagName, document)
>-    , m_mode(BlendModeNormal)
>+    , m_mode(BlendMode::Normal)
> {
>     ASSERT(hasTagName(SVGNames::feBlendTag));
>     registerAnimatedPropertiesForSVGFEBlendElement();
>@@ -60,7 +60,7 @@ Ref<SVGFEBlendElement> SVGFEBlendElement::create(const QualifiedName& tagName, D
> void SVGFEBlendElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
> {
>     if (name == SVGNames::modeAttr) {
>-        BlendMode mode = BlendModeNormal;
>+        BlendMode mode = BlendMode::Normal;
>         if (parseBlendMode(value, mode))
>             setModeBaseValue(mode);
>         return;
>diff --git a/Source/WebCore/svg/SVGFEBlendElement.h b/Source/WebCore/svg/SVGFEBlendElement.h
>index 8f86f1eb6e6031261984df0562dec85953f164b6..339ca65e104c45d7fcffca7ed864c15ab5f95690 100644
>--- a/Source/WebCore/svg/SVGFEBlendElement.h
>+++ b/Source/WebCore/svg/SVGFEBlendElement.h
>@@ -29,11 +29,11 @@ namespace WebCore {
> 
> template<>
> struct SVGPropertyTraits<BlendMode> {
>-    static unsigned highestEnumValue() { return BlendModeLuminosity; }
>+    static unsigned highestEnumValue() { return static_cast<unsigned>(BlendMode::Luminosity); }
> 
>     static String toString(BlendMode type)
>     {
>-        if (type < BlendModePlusDarker)
>+        if (type < BlendMode::PlusDarker)
>             return blendModeName(type);
> 
>         return emptyString();
>diff --git a/Source/WebCore/svg/graphics/SVGImage.cpp b/Source/WebCore/svg/graphics/SVGImage.cpp
>index bd1f6321046a209eb70086599f2dbada05657608..eb45e448e4e297d30ea16d2327c5f2a9ceeb0246 100644
>--- a/Source/WebCore/svg/graphics/SVGImage.cpp
>+++ b/Source/WebCore/svg/graphics/SVGImage.cpp
>@@ -216,7 +216,7 @@ NativeImagePtr SVGImage::nativeImageForCurrentFrame(const GraphicsContext*)
>     if (!buffer) // failed to allocate image
>         return nullptr;
> 
>-    draw(buffer->context(), rect(), rect(), CompositeSourceOver, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+    draw(buffer->context(), rect(), rect(), CompositeOperator::SourceOver, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
> 
>     // FIXME: WK(Bug 113657): We should use DontCopyBackingStore here.
>     return buffer->copyImage(CopyBackingStore)->nativeImageForCurrentFrame();
>@@ -240,7 +240,7 @@ NativeImagePtr SVGImage::nativeImage(const GraphicsContext* targetContext)
> 
>     GraphicsContext localContext(nativeImageTarget.get());
> 
>-    draw(localContext, rect(), rect(), CompositeSourceOver, BlendModeNormal, DecodingMode::Synchronous, ImageOrientationDescription());
>+    draw(localContext, rect(), rect(), CompositeOperator::SourceOver, BlendMode::Normal, DecodingMode::Synchronous, ImageOrientationDescription());
> 
>     COMPtr<ID2D1Bitmap> nativeImage;
>     hr = nativeImageTarget->GetBitmap(&nativeImage);
>@@ -268,7 +268,7 @@ void SVGImage::drawPatternForContainer(GraphicsContext& context, const FloatSize
>     std::unique_ptr<ImageBuffer> buffer = ImageBuffer::createCompatibleBuffer(expandedIntSize(imageBufferSize.size()), 1, ColorSpaceSRGB, context);
>     if (!buffer) // Failed to allocate buffer.
>         return;
>-    drawForContainer(buffer->context(), containerSize, containerZoom, initialFragmentURL, imageBufferSize, zoomedContainerRect, CompositeSourceOver, BlendModeNormal);
>+    drawForContainer(buffer->context(), containerSize, containerZoom, initialFragmentURL, imageBufferSize, zoomedContainerRect, CompositeOperator::SourceOver, BlendMode::Normal);
>     if (context.drawLuminanceMask())
>         buffer->convertToLuminanceMask();
> 
>@@ -299,10 +299,10 @@ ImageDrawResult SVGImage::draw(GraphicsContext& context, const FloatRect& dstRec
>     context.clip(enclosingIntRect(dstRect));
> 
>     float alpha = context.alpha();
>-    bool compositingRequiresTransparencyLayer = compositeOp != CompositeSourceOver || blendMode != BlendModeNormal || alpha < 1;
>+    bool compositingRequiresTransparencyLayer = compositeOp != CompositeOperator::SourceOver || blendMode != BlendMode::Normal || alpha < 1;
>     if (compositingRequiresTransparencyLayer) {
>         context.beginTransparencyLayer(alpha);
>-        context.setCompositeOperation(CompositeSourceOver, BlendModeNormal);
>+        context.setCompositeOperation(CompositeOperator::SourceOver, BlendMode::Normal);
>     }
> 
>     FloatSize scale(dstRect.size() / srcRect.size());
>diff --git a/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm b/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm
>index c97d5e750cff83671f30deb06f219ccbc1e98697..4b8d59d2508e2e13af604dee745e5b3f8dfffd19 100644
>--- a/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm
>+++ b/Source/WebKit/Shared/RemoteLayerTree/RemoteLayerTreeTransaction.mm
>@@ -93,7 +93,7 @@ RemoteLayerTreeTransaction::LayerProperties::LayerProperties()
>     , customAppearance(GraphicsLayer::CustomAppearance::None)
>     , minificationFilter(PlatformCALayer::FilterType::Linear)
>     , magnificationFilter(PlatformCALayer::FilterType::Linear)
>-    , blendMode(BlendModeNormal)
>+    , blendMode(BlendMode::Normal)
>     , windRule(WindRule::NonZero)
>     , hidden(false)
>     , backingStoreAttached(true)
>diff --git a/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp b/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp
>index 38c372b260d8c04adfff612a49ba8a83e49ac68c..a80badc43e35339a6daba47d44d79eb57a829cf1 100644
>--- a/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp
>+++ b/Source/WebKit/WebProcess/Plugins/PluginProxy.cpp
>@@ -213,7 +213,7 @@ void PluginProxy::paint(GraphicsContext& graphicsContext, const IntRect& dirtyRe
>         // Blit the plug-in backing store into our own backing store.
>         auto graphicsContext = m_backingStore->createGraphicsContext();
>         graphicsContext->applyDeviceScaleFactor(contentsScaleFactor());
>-        graphicsContext->setCompositeOperation(CompositeCopy);
>+        graphicsContext->setCompositeOperation(CompositeOperator::Copy);
> 
>         m_pluginBackingStore->paint(*graphicsContext, contentsScaleFactor(), IntPoint(), pluginBounds());
> 
>@@ -723,7 +723,7 @@ void PluginProxy::update(const IntRect& paintedRect)
>         // Blit the plug-in backing store into our own backing store.
>         auto graphicsContext = m_backingStore->createGraphicsContext();
>         graphicsContext->applyDeviceScaleFactor(contentsScaleFactor());
>-        graphicsContext->setCompositeOperation(CompositeCopy);
>+        graphicsContext->setCompositeOperation(CompositeOperator::Copy);
>         m_pluginBackingStore->paint(*graphicsContext, contentsScaleFactor(), paintedRect.location(), paintedRect);
>     }
>

Flags:

darin: review+

Actions: View | Formatted Diff | Diff

Attachments on bug 188147: 346029 | 346063 | 346064 | 346065 | 346077 | 346079 | 346083 | 346094 | 346098 | 346099