Attachment 346913 Details for Bug 188472 – patch

[patch] patch

optionset-renderlayer-4.patch (text/plain), 47.05 KB, created by Antti Koivisto on 2018-08-10 11:26:19 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Antti Koivisto

Created: 2018-08-10 11:26:19 PDT

Size: 47.05 KB

patch

obsolete

>Index: Source/WTF/ChangeLog
>===================================================================
>--- Source/WTF/ChangeLog	(revision 234755)
>+++ Source/WTF/ChangeLog	(working copy)
>@@ -1,3 +1,22 @@
>+2018-08-10  Antti Koivisto  <antti@apple.com>
>+
>+        Use OptionSet for various RenderLayer flags
>+        https://bugs.webkit.org/show_bug.cgi?id=188472
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        * wtf/MathExtras.h:
>+        (hasOneBitSet):
>+        (hasZeroOrOneBitsSet):
>+        (hasTwoOrMoreBitsSet):
>+
>+        Make constexpr.
>+
>+        * wtf/OptionSet.h:
>+        (WTF::OptionSet::OptionSet):
>+
>+        Always use constexpr, no need for separate debug versions with C++14.
>+
> 2018-08-09  Ben Richards  <benton_richards@apple.com>
> 
>         We should cache the compiled sandbox profile in a data vault
>Index: Source/WTF/wtf/MathExtras.h
>===================================================================
>--- Source/WTF/wtf/MathExtras.h	(revision 234753)
>+++ Source/WTF/wtf/MathExtras.h	(working copy)
>@@ -192,17 +192,17 @@ inline float normalizedFloat(float value
>     return value;
> }
> 
>-template<typename T> inline bool hasOneBitSet(T value)
>+template<typename T> constexpr bool hasOneBitSet(T value)
> {
>     return !((value - 1) & value) && value;
> }
> 
>-template<typename T> inline bool hasZeroOrOneBitsSet(T value)
>+template<typename T> constexpr bool hasZeroOrOneBitsSet(T value)
> {
>     return !((value - 1) & value);
> }
> 
>-template<typename T> inline bool hasTwoOrMoreBitsSet(T value)
>+template<typename T> constexpr bool hasTwoOrMoreBitsSet(T value)
> {
>     return !hasZeroOrOneBitsSet(value);
> }
>Index: Source/WTF/wtf/OptionSet.h
>===================================================================
>--- Source/WTF/wtf/OptionSet.h	(revision 234753)
>+++ Source/WTF/wtf/OptionSet.h	(working copy)
>@@ -73,32 +73,19 @@ public:
> 
>     constexpr OptionSet() = default;
> 
>-#if ASSERT_DISABLED
>     constexpr OptionSet(T t)
>         : m_storage(static_cast<StorageType>(t))
>     {
>+        ASSERT_WITH_MESSAGE(!m_storage || hasOneBitSet(m_storage), "Enumerator is not a zero or a positive power of two.");
>     }
> 
>     constexpr OptionSet(std::initializer_list<T> initializerList)
>     {
>-        for (auto& option : initializerList)
>-            m_storage |= static_cast<StorageType>(option);
>-    }
>-#else
>-    OptionSet(T t)
>-        : m_storage(static_cast<StorageType>(t))
>-    {
>-        ASSERT_WITH_MESSAGE(!m_storage || hasOneBitSet(static_cast<StorageType>(t)), "Enumerator is not a zero or a positive power of two.");
>-    }
>-
>-    OptionSet(std::initializer_list<T> initializerList)
>-    {
>         for (auto& option : initializerList) {
>             ASSERT_WITH_MESSAGE(hasOneBitSet(static_cast<StorageType>(option)), "Enumerator is not a positive power of two.");
>             m_storage |= static_cast<StorageType>(option);
>         }
>     }
>-#endif
> 
>     constexpr StorageType toRaw() const { return m_storage; }
> 
>Index: Source/WebCore/ChangeLog
>===================================================================
>--- Source/WebCore/ChangeLog	(revision 234753)
>+++ Source/WebCore/ChangeLog	(working copy)
>@@ -1,3 +1,78 @@
>+2018-08-10  Antti Koivisto  <antti@apple.com>
>+
>+        Use OptionSet for various RenderLayer flags
>+        https://bugs.webkit.org/show_bug.cgi?id=188472
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Typesafe flags.
>+
>+        * html/shadow/MediaControlElements.cpp:
>+        (WebCore::MediaControlTextTrackContainerElement::createTextTrackRepresentationImage):
>+        * page/FrameView.cpp:
>+        (WebCore::updateLayerPositionFlags):
>+        (WebCore::FrameView::paintContents):
>+        * rendering/RenderLayer.cpp:
>+        (WebCore::RenderLayer::updateLayerPositionsAfterLayout):
>+        (WebCore::RenderLayer::updateLayerPositions):
>+        (WebCore::RenderLayer::updateLayerPositionsAfterScroll):
>+        (WebCore::RenderLayer::paint):
>+        (WebCore::paintForFixedRootBackground):
>+        (WebCore::RenderLayer::paintLayer):
>+        (WebCore::RenderLayer::paintLayerContentsAndReflection):
>+        (WebCore::RenderLayer::filterPainter const):
>+        (WebCore::RenderLayer::hasFilterThatIsPainting const):
>+        (WebCore::RenderLayer::setupFilters):
>+        (WebCore::RenderLayer::paintLayerContents):
>+        (RenderLayer::paintLayerByApplyingTransform):
>+        (RenderLayer::paintList):
>+        (RenderLayer::updatePaintingInfoForFragments):
>+        (RenderLayer::paintTransformedLayerIntoFragments):
>+        (RenderLayer::calculateClipRects const):
>+        (WebCore::RenderLayer::paintLayerByApplyingTransform): Deleted.
>+        (WebCore::RenderLayer::paintList): Deleted.
>+        (WebCore::RenderLayer::enclosingPaginationLayerInSubtree const): Deleted.
>+        (WebCore::RenderLayer::collectFragments): Deleted.
>+        (WebCore::RenderLayer::updatePaintingInfoForFragments): Deleted.
>+        (WebCore::RenderLayer::paintTransformedLayerIntoFragments): Deleted.
>+        (WebCore::RenderLayer::paintBackgroundForFragments): Deleted.
>+        (WebCore::RenderLayer::paintForegroundForFragments): Deleted.
>+        (WebCore::RenderLayer::paintForegroundForFragmentsWithPhase): Deleted.
>+        (WebCore::RenderLayer::paintOutlineForFragments): Deleted.
>+        (WebCore::RenderLayer::paintMaskForFragments): Deleted.
>+        (WebCore::RenderLayer::paintChildClippingMaskForFragments): Deleted.
>+        (WebCore::RenderLayer::paintOverflowControlsForFragments): Deleted.
>+        (WebCore::RenderLayer::hitTest): Deleted.
>+        (WebCore::RenderLayer::enclosingElement const): Deleted.
>+        (WebCore::RenderLayer::enclosingFragmentedFlowAncestor const): Deleted.
>+        (WebCore::computeZOffset): Deleted.
>+        (WebCore::RenderLayer::createLocalTransformState const): Deleted.
>+        (WebCore::isHitCandidate): Deleted.
>+        (WebCore::RenderLayer::hitTestLayer): Deleted.
>+        (WebCore::RenderLayer::hitTestContentsForFragments const): Deleted.
>+        (WebCore::RenderLayer::hitTestResizerInFragments const): Deleted.
>+        (WebCore::RenderLayer::hitTestTransformedLayerInFragments): Deleted.
>+        (WebCore::RenderLayer::hitTestLayerByApplyingTransform): Deleted.
>+        (WebCore::RenderLayer::hitTestContents const): Deleted.
>+        (WebCore::RenderLayer::hitTestList): Deleted.
>+        (WebCore::RenderLayer::updateClipRects): Deleted.
>+        (WebCore::RenderLayer::clipRects const): Deleted.
>+        (WebCore::RenderLayer::calculateClipRects const): Deleted.
>+        (WebCore::showLayerTree): Deleted.
>+        * rendering/RenderLayer.h:
>+        * rendering/RenderLayerBacking.cpp:
>+        (WebCore::RenderLayerBacking::updateCompositedBounds):
>+        (WebCore::RenderLayerBacking::detachFromScrollingCoordinator):
>+        (WebCore::RenderLayerBacking::paintIntoLayer):
>+        * rendering/RenderLayerBacking.h:
>+        * rendering/RenderLayerCompositor.cpp:
>+        (WebCore::RenderLayerCompositor::updateScrollCoordinatedStatus):
>+        (WebCore::RenderLayerCompositor::detachScrollCoordinatedLayer):
>+        (WebCore::RenderLayerCompositor::updateScrollCoordinatedLayer):
>+        * rendering/RenderLayerCompositor.h:
>+        * rendering/RenderReplica.cpp:
>+        (WebCore::RenderReplica::paint):
>+
> 2018-08-09  Ben Richards  <benton_richards@apple.com>
> 
>         We should cache the compiled sandbox profile in a data vault
>Index: Source/WebCore/html/shadow/MediaControlElements.cpp
>===================================================================
>--- Source/WebCore/html/shadow/MediaControlElements.cpp	(revision 234753)
>+++ Source/WebCore/html/shadow/MediaControlElements.cpp	(working copy)
>@@ -1437,7 +1437,7 @@ RefPtr<Image> MediaControlTextTrackConta
>     if (!buffer)
>         return nullptr;
> 
>-    layer->paint(buffer->context(), paintingRect, LayoutSize(), OptionSet<PaintBehavior>(PaintBehavior::FlattenCompositingLayers) | PaintBehavior::Snapshotting, nullptr, RenderLayer::PaintLayerPaintingCompositingAllPhases);
>+    layer->paint(buffer->context(), paintingRect, LayoutSize(), { PaintBehavior::FlattenCompositingLayers, PaintBehavior::Snapshotting }, nullptr, RenderLayer::paintLayerPaintingCompositingAllPhasesFlags());
> 
>     return ImageBuffer::sinkIntoImage(WTFMove(buffer));
> }
>Index: Source/WebCore/page/FrameView.cpp
>===================================================================
>--- Source/WebCore/page/FrameView.cpp	(revision 234753)
>+++ Source/WebCore/page/FrameView.cpp	(working copy)
>@@ -136,11 +136,11 @@ static constexpr float defaultSignifican
> static constexpr unsigned mainArticleSignificantRenderedTextCharacterThreshold = 1500;
> static constexpr float mainArticleSignificantRenderedTextMeanLength = 25;
> 
>-static RenderLayer::UpdateLayerPositionsFlags updateLayerPositionFlags(RenderLayer* layer, bool isRelayoutingSubtree, bool didFullRepaint)
>+static OptionSet<RenderLayer::UpdateLayerPositionsFlag> updateLayerPositionFlags(RenderLayer* layer, bool isRelayoutingSubtree, bool didFullRepaint)
> {
>-    RenderLayer::UpdateLayerPositionsFlags flags = RenderLayer::defaultFlags;
>+    auto flags = RenderLayer::updateLayerPositionsDefaultFlags();
>     if (didFullRepaint) {
>-        flags &= ~RenderLayer::CheckForRepaint;
>+        flags -= RenderLayer::CheckForRepaint;
>         flags |= RenderLayer::NeedsFullRepaintInBacking;
>     }
>     if (isRelayoutingSubtree && layer->enclosingPaginationLayer(RenderLayer::IncludeCompositedPaginatedLayers))
>@@ -4163,7 +4163,7 @@ void FrameView::paintContents(GraphicsCo
>     while (is<RenderInline>(renderer) && !downcast<RenderInline>(*renderer).firstLineBox())
>         renderer = renderer->parent();
> 
>-    rootLayer->paint(context, dirtyRect, LayoutSize(), m_paintBehavior, renderer, 0, securityOriginPaintPolicy == SecurityOriginPaintPolicy::AnyOrigin ? RenderLayer::SecurityOriginPaintPolicy::AnyOrigin : RenderLayer::SecurityOriginPaintPolicy::AccessibleOriginOnly);
>+    rootLayer->paint(context, dirtyRect, LayoutSize(), m_paintBehavior, renderer, { }, securityOriginPaintPolicy == SecurityOriginPaintPolicy::AnyOrigin ? RenderLayer::SecurityOriginPaintPolicy::AnyOrigin : RenderLayer::SecurityOriginPaintPolicy::AccessibleOriginOnly);
>     if (rootLayer->containsDirtyOverlayScrollbars())
>         rootLayer->paintOverlayScrollbars(context, dirtyRect, m_paintBehavior, renderer);
> 
>Index: Source/WebCore/rendering/RenderLayer.cpp
>===================================================================
>--- Source/WebCore/rendering/RenderLayer.cpp	(revision 234753)
>+++ Source/WebCore/rendering/RenderLayer.cpp	(working copy)
>@@ -471,7 +471,7 @@ FilterEffectRenderer* RenderLayer::filte
>     return filterInfo ? filterInfo->renderer() : nullptr;
> }
> 
>-void RenderLayer::updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, UpdateLayerPositionsFlags flags)
>+void RenderLayer::updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, OptionSet<UpdateLayerPositionsFlag> flags)
> {
>     LOG(Compositing, "RenderLayer %p updateLayerPositionsAfterLayout", this);
>     RenderGeometryMap geometryMap(UseTransforms);
>@@ -480,7 +480,7 @@ void RenderLayer::updateLayerPositionsAf
>     updateLayerPositions(&geometryMap, flags);
> }
> 
>-void RenderLayer::updateLayerPositions(RenderGeometryMap* geometryMap, UpdateLayerPositionsFlags flags)
>+void RenderLayer::updateLayerPositions(RenderGeometryMap* geometryMap, OptionSet<UpdateLayerPositionsFlag> flags)
> {
>     updateLayerPosition(); // For relpositioned layers or non-positioned layers,
>                            // we need to keep in sync, since we may have shifted relative
>@@ -547,17 +547,17 @@ void RenderLayer::updateLayerPositions(R
>         clearRepaintRects();
> 
>     m_repaintStatus = NeedsNormalRepaint;
>-    m_hasTransformedAncestor = flags & SeenTransformedLayer;
>-    m_has3DTransformedAncestor = flags & Seen3DTransformedLayer;
>+    m_hasTransformedAncestor = flags.contains(SeenTransformedLayer);
>+    m_has3DTransformedAncestor = flags.contains(Seen3DTransformedLayer);
> 
>     // Update the reflection's position and size.
>     if (m_reflection)
>         m_reflection->layout();
> 
>     // Clear the IsCompositingUpdateRoot flag once we've found the first compositing layer in this update.
>-    bool isUpdateRoot = (flags & IsCompositingUpdateRoot);
>+    bool isUpdateRoot = flags.contains(IsCompositingUpdateRoot);
>     if (isComposited())
>-        flags &= ~IsCompositingUpdateRoot;
>+        flags -= IsCompositingUpdateRoot;
> 
>     if (renderer().isInFlowRenderFragmentedFlow()) {
>         updatePagination();
>@@ -837,7 +837,7 @@ void RenderLayer::updateLayerPositionsAf
>     updateLayerPositionsAfterScroll(&geometryMap, IsOverflowScroll);
> }
> 
>-void RenderLayer::updateLayerPositionsAfterScroll(RenderGeometryMap* geometryMap, UpdateLayerPositionsAfterScrollFlags flags)
>+void RenderLayer::updateLayerPositionsAfterScroll(RenderGeometryMap* geometryMap, OptionSet<UpdateLayerPositionsAfterScrollFlag> flags)
> {
>     // FIXME: This shouldn't be needed, but there are some corner cases where
>     // these flags are still dirty. Update so that the check below is valid.
>@@ -3855,7 +3855,7 @@ bool RenderLayer::scroll(ScrollDirection
>     return ScrollableArea::scroll(direction, granularity, multiplier);
> }
> 
>-void RenderLayer::paint(GraphicsContext& context, const LayoutRect& damageRect, const LayoutSize& subpixelOffset, OptionSet<PaintBehavior> paintBehavior, RenderObject* subtreePaintRoot, PaintLayerFlags paintFlags, SecurityOriginPaintPolicy paintPolicy)
>+void RenderLayer::paint(GraphicsContext& context, const LayoutRect& damageRect, const LayoutSize& subpixelOffset, OptionSet<PaintBehavior> paintBehavior, RenderObject* subtreePaintRoot, OptionSet<PaintLayerFlag> paintFlags, SecurityOriginPaintPolicy paintPolicy)
> {
>     OverlapTestRequestMap overlapTestRequests;
> 
>@@ -3962,12 +3962,12 @@ static inline bool shouldSuppressPaintin
>     return false;
> }
> 
>-static inline bool paintForFixedRootBackground(const RenderLayer* layer, RenderLayer::PaintLayerFlags paintFlags)
>+static inline bool paintForFixedRootBackground(const RenderLayer* layer, OptionSet<RenderLayer::PaintLayerFlag> paintFlags)
> {
>     return layer->renderer().isDocumentElementRenderer() && (paintFlags & RenderLayer::PaintLayerPaintingRootBackgroundOnly);
> }
> 
>-void RenderLayer::paintLayer(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
>+void RenderLayer::paintLayer(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, OptionSet<PaintLayerFlag> paintFlags)
> {
>     if (isComposited()) {
>         // The performingPaintInvalidation() painting pass goes through compositing layers,
>@@ -3976,7 +3976,7 @@ void RenderLayer::paintLayer(GraphicsCon
>             paintFlags |= PaintLayerTemporaryClipRects;
>         else if (!backing()->paintsIntoWindow()
>             && !backing()->paintsIntoCompositedAncestor()
>-            && !shouldDoSoftwarePaint(this, paintFlags & PaintLayerPaintingReflection)
>+            && !shouldDoSoftwarePaint(this, paintFlags.contains(PaintLayerPaintingReflection))
>             && !paintForFixedRootBackground(this, paintFlags)) {
>             // If this RenderLayer should paint into its backing, that will be done via RenderLayerBacking::paintIntoLayer().
>             return;
>@@ -4047,11 +4047,11 @@ void RenderLayer::paintLayer(GraphicsCon
>     paintLayerContentsAndReflection(context, paintingInfo, paintFlags);
> }
> 
>-void RenderLayer::paintLayerContentsAndReflection(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
>+void RenderLayer::paintLayerContentsAndReflection(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, OptionSet<PaintLayerFlag> paintFlags)
> {
>     ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
> 
>-    PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
>+    auto localPaintFlags = paintFlags - PaintLayerAppliedTransform;
> 
>     // Paint the reflection first if we have one.
>     if (m_reflection && !m_paintingInsideReflection) {
>@@ -4061,7 +4061,7 @@ void RenderLayer::paintLayerContentsAndR
>         m_paintingInsideReflection = false;
>     }
> 
>-    localPaintFlags |= PaintLayerPaintingCompositingAllPhases;
>+    localPaintFlags |= paintLayerPaintingCompositingAllPhasesFlags();
>     paintLayerContents(context, paintingInfo, localPaintFlags);
> }
> 
>@@ -4157,7 +4157,7 @@ bool RenderLayer::setupClipPath(Graphics
>         return false;
> 
>     if (!rootRelativeBoundsComputed) {
>-        rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, offsetFromRoot, 0);
>+        rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, offsetFromRoot, { });
>         rootRelativeBoundsComputed = true;
>     }
> 
>@@ -4195,7 +4195,7 @@ bool RenderLayer::setupClipPath(Graphics
>     return false;
> }
> 
>-std::pair<RenderLayer::FilterInfo*, std::unique_ptr<FilterEffectRendererHelper>> RenderLayer::filterPainter(GraphicsContext& context, PaintLayerFlags paintFlags) const
>+std::pair<RenderLayer::FilterInfo*, std::unique_ptr<FilterEffectRendererHelper>> RenderLayer::filterPainter(GraphicsContext& context, OptionSet<PaintLayerFlag> paintFlags) const
> {
>     if (context.paintingDisabled())
>         return { };
>@@ -4217,12 +4217,12 @@ std::pair<RenderLayer::FilterInfo*, std:
>     return { info, WTFMove(helper) };
> }
> 
>-bool RenderLayer::hasFilterThatIsPainting(GraphicsContext& context, PaintLayerFlags paintFlags) const
>+bool RenderLayer::hasFilterThatIsPainting(GraphicsContext& context, OptionSet<PaintLayerFlag> paintFlags) const
> {
>     return !!filterPainter(context, paintFlags).first;
> }
> 
>-std::unique_ptr<FilterEffectRendererHelper> RenderLayer::setupFilters(GraphicsContext& context, LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
>+std::unique_ptr<FilterEffectRendererHelper> RenderLayer::setupFilters(GraphicsContext& context, LayerPaintingInfo& paintingInfo, OptionSet<PaintLayerFlag> paintFlags, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed)
> {
>     auto painter = filterPainter(context, paintFlags);
>     if (!painter.first)
>@@ -4235,7 +4235,7 @@ std::unique_ptr<FilterEffectRendererHelp
>     filterRepaintRect.move(offsetFromRoot);
> 
>     if (!rootRelativeBoundsComputed) {
>-        rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, offsetFromRoot, 0);
>+        rootRelativeBounds = calculateLayerBounds(paintingInfo.rootLayer, offsetFromRoot, { });
>         rootRelativeBoundsComputed = true;
>     }
> 
>@@ -4277,18 +4277,18 @@ static inline bool compareZIndex(RenderL
>     return first->zIndex() < second->zIndex();
> }
> 
>-void RenderLayer::paintLayerContents(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
>+void RenderLayer::paintLayerContents(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, OptionSet<PaintLayerFlag> paintFlags)
> {
>     ASSERT(isSelfPaintingLayer() || hasSelfPaintingLayerDescendant());
> 
>-    PaintLayerFlags localPaintFlags = paintFlags & ~(PaintLayerAppliedTransform);
>-    bool haveTransparency = localPaintFlags & PaintLayerHaveTransparency;
>+    auto localPaintFlags = paintFlags - PaintLayerAppliedTransform;
>+    bool haveTransparency = localPaintFlags.contains(PaintLayerHaveTransparency);
>     bool isSelfPaintingLayer = this->isSelfPaintingLayer();
>-    bool isPaintingOverlayScrollbars = paintFlags & PaintLayerPaintingOverlayScrollbars;
>-    bool isPaintingScrollingContent = paintFlags & PaintLayerPaintingCompositingScrollingPhase;
>-    bool isPaintingCompositedForeground = paintFlags & PaintLayerPaintingCompositingForegroundPhase;
>-    bool isPaintingCompositedBackground = paintFlags & PaintLayerPaintingCompositingBackgroundPhase;
>-    bool isPaintingOverflowContents = paintFlags & PaintLayerPaintingOverflowContents;
>+    bool isPaintingOverlayScrollbars = paintFlags.contains(PaintLayerPaintingOverlayScrollbars);
>+    bool isPaintingScrollingContent = paintFlags.contains(PaintLayerPaintingCompositingScrollingPhase);
>+    bool isPaintingCompositedForeground = paintFlags.contains(PaintLayerPaintingCompositingForegroundPhase);
>+    bool isPaintingCompositedBackground = paintFlags.contains(PaintLayerPaintingCompositingBackgroundPhase);
>+    bool isPaintingOverflowContents = paintFlags.contains(PaintLayerPaintingOverflowContents);
>     // Outline always needs to be painted even if we have no visible content. Also,
>     // the outline is painted in the background phase during composited scrolling.
>     // If it were painted in the foreground phase, it would move with the scrolled
>@@ -4477,7 +4477,7 @@ void RenderLayer::paintLayerContents(Gra
>         context.restore();
> }
> 
>-void RenderLayer::paintLayerByApplyingTransform(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags, const LayoutSize& translationOffset)
>+void RenderLayer::paintLayerByApplyingTransform(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, OptionSet<PaintLayerFlag> paintFlags, const LayoutSize& translationOffset)
> {
>     // This involves subtracting out the position of the layer in our current coordinate space, but preserving
>     // the accumulated error for sub-pixel layout.
>@@ -4506,7 +4506,7 @@ void RenderLayer::paintLayerByApplyingTr
>     context.setCTM(oldTransfrom);
> }
> 
>-void RenderLayer::paintList(Vector<RenderLayer*>* list, GraphicsContext& context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
>+void RenderLayer::paintList(Vector<RenderLayer*>* list, GraphicsContext& context, const LayerPaintingInfo& paintingInfo, OptionSet<PaintLayerFlag> paintFlags)
> {
>     if (!list)
>         return;
>@@ -4675,7 +4675,7 @@ void RenderLayer::collectFragments(Layer
>     }
> }
> 
>-void RenderLayer::updatePaintingInfoForFragments(LayerFragments& fragments, const LayerPaintingInfo& localPaintingInfo, PaintLayerFlags localPaintFlags,
>+void RenderLayer::updatePaintingInfoForFragments(LayerFragments& fragments, const LayerPaintingInfo& localPaintingInfo, OptionSet<PaintLayerFlag> localPaintFlags,
>     bool shouldPaintContent, const LayoutSize& offsetFromRoot)
> {
>     for (auto& fragment : fragments) {
>@@ -4687,7 +4687,7 @@ void RenderLayer::updatePaintingInfoForF
>     }
> }
> 
>-void RenderLayer::paintTransformedLayerIntoFragments(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, PaintLayerFlags paintFlags)
>+void RenderLayer::paintTransformedLayerIntoFragments(GraphicsContext& context, const LayerPaintingInfo& paintingInfo, OptionSet<PaintLayerFlag> paintFlags)
> {
>     LayerFragments enclosingPaginationFragments;
>     LayoutSize offsetOfPaginationLayerFromRoot;
>@@ -5715,7 +5715,7 @@ bool RenderLayer::intersectsDamageRect(c
>     return boundingBox(rootLayer, offsetFromRoot).intersects(damageRect);
> }
> 
>-LayoutRect RenderLayer::localBoundingBox(CalculateLayerBoundsFlags flags) const
>+LayoutRect RenderLayer::localBoundingBox(OptionSet<CalculateLayerBoundsFlag> flags) const
> {
>     // There are three special cases we need to consider.
>     // (1) Inline Flows.  For inline flows we will create a bounding box that fully encompasses all of the lines occupied by the
>@@ -5756,7 +5756,7 @@ LayoutRect RenderLayer::localBoundingBox
>     return result;
> }
> 
>-LayoutRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, CalculateLayerBoundsFlags flags) const
>+LayoutRect RenderLayer::boundingBox(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, OptionSet<CalculateLayerBoundsFlag> flags) const
> {    
>     LayoutRect result = localBoundingBox(flags);
>     if (renderer().view().frameView().hasFlippedBlockRenderers()) {
>@@ -5797,10 +5797,10 @@ LayoutRect RenderLayer::boundingBox(cons
>     return result;
> }
> 
>-bool RenderLayer::getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(LayoutRect& bounds, CalculateLayerBoundsFlags additionalFlags) const
>+bool RenderLayer::getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(LayoutRect& bounds, OptionSet<CalculateLayerBoundsFlag> additionalFlags) const
> {
>     // The animation will override the display transform, so don't include it.
>-    CalculateLayerBoundsFlags boundsFlags = additionalFlags | (DefaultCalculateLayerBoundsFlags & ~IncludeSelfTransform);
>+    auto boundsFlags = (additionalFlags | defaultCalculateLayerBoundsFlags()) - IncludeSelfTransform;
>     
>     bounds = calculateLayerBounds(this, LayoutSize(), boundsFlags);
>     
>@@ -5834,7 +5834,7 @@ FloatRect RenderLayer::absoluteBoundingB
>     return snapRectToDevicePixels(boundingBox(rootLayer, offsetFromAncestor(rootLayer)), renderer().document().deviceScaleFactor());
> }
> 
>-LayoutRect RenderLayer::calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, CalculateLayerBoundsFlags flags) const
>+LayoutRect RenderLayer::calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, OptionSet<CalculateLayerBoundsFlag> flags) const
> {
>     if (!isSelfPaintingLayer())
>         return LayoutRect();
>@@ -5880,7 +5880,7 @@ LayoutRect RenderLayer::calculateLayerBo
>     }
> 
>     // FIXME: should probably just pass 'flags' down to descendants.
>-    CalculateLayerBoundsFlags descendantFlags = DefaultCalculateLayerBoundsFlags | (flags & ExcludeHiddenDescendants) | (flags & IncludeCompositedDescendants);
>+    auto descendantFlags = defaultCalculateLayerBoundsFlags() | (flags & ExcludeHiddenDescendants) | (flags & IncludeCompositedDescendants);
> 
>     const_cast<RenderLayer*>(this)->updateLayerListsIfNeeded();
> 
>@@ -6011,7 +6011,7 @@ bool RenderLayer::paintsWithTransform(Op
>     return transform() && ((paintBehavior & PaintBehavior::FlattenCompositingLayers) || paintsToWindow);
> }
> 
>-bool RenderLayer::shouldPaintMask(OptionSet<PaintBehavior> paintBehavior, PaintLayerFlags paintFlags) const
>+bool RenderLayer::shouldPaintMask(OptionSet<PaintBehavior> paintBehavior, OptionSet<PaintLayerFlag> paintFlags) const
> {
>     if (!renderer().hasMask())
>         return false;
>@@ -6020,10 +6020,10 @@ bool RenderLayer::shouldPaintMask(Option
>     if (paintsToWindow || (paintBehavior & PaintBehavior::FlattenCompositingLayers))
>         return true;
> 
>-    return (paintFlags & PaintLayerPaintingCompositingMaskPhase);
>+    return paintFlags.contains(PaintLayerPaintingCompositingMaskPhase);
> }
> 
>-bool RenderLayer::shouldApplyClipPath(OptionSet<PaintBehavior> paintBehavior, PaintLayerFlags paintFlags) const
>+bool RenderLayer::shouldApplyClipPath(OptionSet<PaintBehavior> paintBehavior, OptionSet<PaintLayerFlag> paintFlags) const
> {
>     if (!renderer().hasClipPath())
>         return false;
>@@ -6032,7 +6032,7 @@ bool RenderLayer::shouldApplyClipPath(Op
>     if (paintsToWindow || (paintBehavior & PaintBehavior::FlattenCompositingLayers))
>         return true;
> 
>-    return (paintFlags & PaintLayerPaintingCompositingClipPathPhase);
>+    return paintFlags.contains(PaintLayerPaintingCompositingClipPathPhase);
> }
> 
> bool RenderLayer::scrollingMayRevealBackground() const
>Index: Source/WebCore/rendering/RenderLayer.h
>===================================================================
>--- Source/WebCore/rendering/RenderLayer.h	(revision 234753)
>+++ Source/WebCore/rendering/RenderLayer.h	(working copy)
>@@ -112,7 +112,6 @@ enum LayerScrollCoordinationRole {
>     ViewportConstrained = 1 << 0,
>     Scrolling           = 1 << 1
> };
>-typedef unsigned LayerScrollCoordinationRoles;
> 
> enum class RequestState {
>     Unknown,
>@@ -310,10 +309,9 @@ public:
>         SeenTransformedLayer = 1 << 5,
>         Seen3DTransformedLayer = 1 << 6
>     };
>-    typedef unsigned UpdateLayerPositionsFlags;
>-    static const UpdateLayerPositionsFlags defaultFlags = CheckForRepaint | IsCompositingUpdateRoot | UpdateCompositingLayers;
>+    static constexpr OptionSet<UpdateLayerPositionsFlag> updateLayerPositionsDefaultFlags() { return { CheckForRepaint, IsCompositingUpdateRoot, UpdateCompositingLayers }; }
> 
>-    void updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, UpdateLayerPositionsFlags);
>+    void updateLayerPositionsAfterLayout(const RenderLayer* rootLayer, OptionSet<UpdateLayerPositionsFlag>);
> 
>     void updateLayerPositionsAfterOverflowScroll();
>     void updateLayerPositionsAfterDocumentScroll();
>@@ -494,10 +492,8 @@ public:
>         PaintLayerPaintingRootBackgroundOnly            = 1 << 11,
>         PaintLayerPaintingSkipRootBackground            = 1 << 12,
>         PaintLayerPaintingChildClippingMaskPhase        = 1 << 13,
>-        PaintLayerPaintingCompositingAllPhases          = PaintLayerPaintingCompositingBackgroundPhase | PaintLayerPaintingCompositingForegroundPhase
>     };
>-    
>-    typedef unsigned PaintLayerFlags;
>+    static constexpr OptionSet<PaintLayerFlag> paintLayerPaintingCompositingAllPhasesFlags() { return { PaintLayerPaintingCompositingBackgroundPhase,  PaintLayerPaintingCompositingForegroundPhase }; }
> 
>     enum class SecurityOriginPaintPolicy { AnyOrigin, AccessibleOriginOnly };
> 
>@@ -506,7 +502,7 @@ public:
>     // front.  The hitTest method looks for mouse events by walking
>     // layers that intersect the point from front to back.
>     void paint(GraphicsContext&, const LayoutRect& damageRect, const LayoutSize& subpixelOffset = LayoutSize(), OptionSet<PaintBehavior> = PaintBehavior::Normal,
>-        RenderObject* subtreePaintRoot = nullptr, PaintLayerFlags = 0, SecurityOriginPaintPolicy = SecurityOriginPaintPolicy::AnyOrigin);
>+        RenderObject* subtreePaintRoot = nullptr, OptionSet<PaintLayerFlag> = { }, SecurityOriginPaintPolicy = SecurityOriginPaintPolicy::AnyOrigin);
>     bool hitTest(const HitTestRequest&, HitTestResult&);
>     bool hitTest(const HitTestRequest&, const HitTestLocation&, HitTestResult&);
>     void paintOverlayScrollbars(GraphicsContext&, const LayoutRect& damageRect, OptionSet<PaintBehavior>, RenderObject* subtreePaintRoot = nullptr);
>@@ -553,14 +549,14 @@ public:
>         IncludeCompositedDescendants            = 1 << 5,
>         UseFragmentBoxesExcludingCompositing    = 1 << 6,
>         UseFragmentBoxesIncludingCompositing    = 1 << 7,
>-        DefaultCalculateLayerBoundsFlags        = IncludeSelfTransform | UseLocalClipRectIfPossible | IncludeLayerFilterOutsets | UseFragmentBoxesExcludingCompositing
>+
>     };
>-    typedef unsigned CalculateLayerBoundsFlags;
>+    static constexpr OptionSet<CalculateLayerBoundsFlag> defaultCalculateLayerBoundsFlags() { return { IncludeSelfTransform, UseLocalClipRectIfPossible, IncludeLayerFilterOutsets, UseFragmentBoxesExcludingCompositing }; }
> 
>     // Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
>-    LayoutRect boundingBox(const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot = LayoutSize(), CalculateLayerBoundsFlags = 0) const;
>+    LayoutRect boundingBox(const RenderLayer* rootLayer, const LayoutSize& offsetFromRoot = LayoutSize(), OptionSet<CalculateLayerBoundsFlag> = { }) const;
>     // Bounding box in the coordinates of this layer.
>-    LayoutRect localBoundingBox(CalculateLayerBoundsFlags = 0) const;
>+    LayoutRect localBoundingBox(OptionSet<CalculateLayerBoundsFlag> = { }) const;
>     // Deprecated: Pixel snapped bounding box relative to the root.
>     WEBCORE_EXPORT IntRect absoluteBoundingBox() const;
>     // Device pixel snapped bounding box relative to the root. absoluteBoundingBox() callers will be directed to this.
>@@ -571,14 +567,14 @@ public:
>     
>     // Takes transform animations into account, returning true if they could be cheaply computed.
>     // Unlike overlapBounds, these bounds include descendant layers.
>-    bool getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(LayoutRect&, CalculateLayerBoundsFlags additionalFlags = 0) const;
>+    bool getOverlapBoundsIncludingChildrenAccountingForTransformAnimations(LayoutRect&, OptionSet<CalculateLayerBoundsFlag> additionalFlags = { }) const;
> 
>     // If true, this layer's children are included in its bounds for overlap testing.
>     // We can't rely on the children's positions if this layer has a filter that could have moved the children's pixels around.
>     bool overlapBoundsIncludeChildren() const { return hasFilter() && renderer().style().filter().hasFilterThatMovesPixels(); }
> 
>     // Can pass offsetFromRoot if known.
>-    LayoutRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, CalculateLayerBoundsFlags = DefaultCalculateLayerBoundsFlags) const;
>+    LayoutRect calculateLayerBounds(const RenderLayer* ancestorLayer, const LayoutSize& offsetFromRoot, OptionSet<CalculateLayerBoundsFlag> = defaultCalculateLayerBoundsFlags()) const;
>     
>     // Return a cached repaint rect, computed relative to the layer renderer's containerForRepaint.
>     bool hasComputedRepaintRects() const { return renderer().hasRepaintLayoutRects(); }
>@@ -669,8 +665,8 @@ public:
>     }
> 
>     bool paintsWithTransform(OptionSet<PaintBehavior>) const;
>-    bool shouldPaintMask(OptionSet<PaintBehavior>, PaintLayerFlags) const;
>-    bool shouldApplyClipPath(OptionSet<PaintBehavior>, PaintLayerFlags) const;
>+    bool shouldPaintMask(OptionSet<PaintBehavior>, OptionSet<PaintLayerFlag>) const;
>+    bool shouldApplyClipPath(OptionSet<PaintBehavior>, OptionSet<PaintLayerFlag>) const;
> 
>     // Returns true if background phase is painted opaque in the given rect.
>     // The query rect is given in local coordinates.
>@@ -795,17 +791,15 @@ private:
>     // Returns true if the position changed.
>     bool updateLayerPosition();
> 
>-    void updateLayerPositions(RenderGeometryMap* = nullptr, UpdateLayerPositionsFlags = defaultFlags);
>+    void updateLayerPositions(RenderGeometryMap* = nullptr, OptionSet<UpdateLayerPositionsFlag> = updateLayerPositionsDefaultFlags());
> 
>     enum UpdateLayerPositionsAfterScrollFlag {
>-        NoFlag = 0,
>         IsOverflowScroll = 1 << 0,
>         HasSeenViewportConstrainedAncestor = 1 << 1,
>         HasSeenAncestorWithOverflowClip = 1 << 2,
>         HasChangedAncestor = 1 << 3
>     };
>-    typedef unsigned UpdateLayerPositionsAfterScrollFlags;
>-    void updateLayerPositionsAfterScroll(RenderGeometryMap*, UpdateLayerPositionsAfterScrollFlags = NoFlag);
>+    void updateLayerPositionsAfterScroll(RenderGeometryMap*, OptionSet<UpdateLayerPositionsAfterScrollFlag> = { });
> 
>     ScrollOffset clampScrollOffset(const ScrollOffset&) const;
> 
>@@ -830,18 +824,18 @@ private:
>     bool setupClipPath(GraphicsContext&, const LayerPaintingInfo&, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
> 
>     class FilterInfo;
>-    std::pair<FilterInfo*, std::unique_ptr<FilterEffectRendererHelper>> filterPainter(GraphicsContext&, PaintLayerFlags) const;
>-    bool hasFilterThatIsPainting(GraphicsContext&, PaintLayerFlags) const;
>-    std::unique_ptr<FilterEffectRendererHelper> setupFilters(GraphicsContext&, LayerPaintingInfo&, PaintLayerFlags, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
>+    std::pair<FilterInfo*, std::unique_ptr<FilterEffectRendererHelper>> filterPainter(GraphicsContext&, OptionSet<PaintLayerFlag>) const;
>+    bool hasFilterThatIsPainting(GraphicsContext&, OptionSet<PaintLayerFlag>) const;
>+    std::unique_ptr<FilterEffectRendererHelper> setupFilters(GraphicsContext&, LayerPaintingInfo&, OptionSet<PaintLayerFlag>, const LayoutSize& offsetFromRoot, LayoutRect& rootRelativeBounds, bool& rootRelativeBoundsComputed);
>     void applyFilters(FilterEffectRendererHelper*, GraphicsContext& originalContext, const LayerPaintingInfo&, const LayerFragments&);
> 
>-    void paintLayer(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
>-    void paintLayerContentsAndReflection(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
>-    void paintLayerByApplyingTransform(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags, const LayoutSize& translationOffset = LayoutSize());
>-    void paintLayerContents(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
>-    void paintList(Vector<RenderLayer*>*, GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
>+    void paintLayer(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
>+    void paintLayerContentsAndReflection(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
>+    void paintLayerByApplyingTransform(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>, const LayoutSize& translationOffset = LayoutSize());
>+    void paintLayerContents(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
>+    void paintList(Vector<RenderLayer*>*, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
> 
>-    void updatePaintingInfoForFragments(LayerFragments&, const LayerPaintingInfo&, PaintLayerFlags, bool shouldPaintContent, const LayoutSize& offsetFromRoot);
>+    void updatePaintingInfoForFragments(LayerFragments&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>, bool shouldPaintContent, const LayoutSize& offsetFromRoot);
>     void paintBackgroundForFragments(const LayerFragments&, GraphicsContext&, GraphicsContext& transparencyLayerContext,
>         const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
>     void paintForegroundForFragments(const LayerFragments&, GraphicsContext&, GraphicsContext& transparencyLayerContext,
>@@ -851,7 +845,7 @@ private:
>     void paintOverflowControlsForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&);
>     void paintMaskForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
>     void paintChildClippingMaskForFragments(const LayerFragments&, GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintBehavior>, RenderObject* paintingRootForRenderer);
>-    void paintTransformedLayerIntoFragments(GraphicsContext&, const LayerPaintingInfo&, PaintLayerFlags);
>+    void paintTransformedLayerIntoFragments(GraphicsContext&, const LayerPaintingInfo&, OptionSet<PaintLayerFlag>);
> 
>     RenderLayer* transparentPaintingAncestor();
>     void beginTransparencyLayers(GraphicsContext&, const LayerPaintingInfo&, const LayoutRect& dirtyRect);
>Index: Source/WebCore/rendering/RenderLayerBacking.cpp
>===================================================================
>--- Source/WebCore/rendering/RenderLayerBacking.cpp	(revision 234753)
>+++ Source/WebCore/rendering/RenderLayerBacking.cpp	(working copy)
>@@ -245,7 +245,7 @@ RenderLayerBacking::~RenderLayerBacking(
>     updateBackgroundLayer(false);
>     updateMaskingLayer(false, false);
>     updateScrollingLayers(false);
>-    detachFromScrollingCoordinator(Scrolling | ViewportConstrained);
>+    detachFromScrollingCoordinator({Scrolling , ViewportConstrained });
>     destroyGraphicsLayers();
> }
> 
>@@ -593,7 +593,7 @@ static bool hasNonZeroTransformOrigin(co
> 
> void RenderLayerBacking::updateCompositedBounds()
> {
>-    LayoutRect layerBounds = m_owningLayer.calculateLayerBounds(&m_owningLayer, LayoutSize(), RenderLayer::DefaultCalculateLayerBoundsFlags | RenderLayer::ExcludeHiddenDescendants | RenderLayer::DontConstrainForMask);
>+    LayoutRect layerBounds = m_owningLayer.calculateLayerBounds(&m_owningLayer, LayoutSize(), RenderLayer::defaultCalculateLayerBoundsFlags() | RenderLayer::ExcludeHiddenDescendants | RenderLayer::DontConstrainForMask);
>     // Clip to the size of the document or enclosing overflow-scroll layer.
>     // If this or an ancestor is transformed, we can't currently compute the correct rect to intersect with.
>     // We'd need RenderObject::convertContainerToLocalQuad(), which doesn't yet exist.
>@@ -1774,7 +1774,7 @@ bool RenderLayerBacking::updateScrolling
>     return true;
> }
> 
>-void RenderLayerBacking::detachFromScrollingCoordinator(LayerScrollCoordinationRoles roles)
>+void RenderLayerBacking::detachFromScrollingCoordinator(OptionSet<LayerScrollCoordinationRole> roles)
> {
>     if (!m_scrollingNodeID && !m_viewportConstrainedNodeID)
>         return;
>@@ -2532,7 +2532,7 @@ void RenderLayerBacking::paintIntoLayer(
>         return;
>     }
> 
>-    RenderLayer::PaintLayerFlags paintFlags = 0;
>+    OptionSet<RenderLayer::PaintLayerFlag> paintFlags;
>     if (paintingPhase & GraphicsLayerPaintBackground)
>         paintFlags |= RenderLayer::PaintLayerPaintingCompositingBackgroundPhase;
>     if (paintingPhase & GraphicsLayerPaintForeground)
>@@ -2549,7 +2549,7 @@ void RenderLayerBacking::paintIntoLayer(
>         paintFlags |= RenderLayer::PaintLayerPaintingCompositingScrollingPhase;
> 
>     if (graphicsLayer == m_backgroundLayer.get() && m_backgroundLayerPaintsFixedRootBackground)
>-        paintFlags |= (RenderLayer::PaintLayerPaintingRootBackgroundOnly | RenderLayer::PaintLayerPaintingCompositingForegroundPhase); // Need PaintLayerPaintingCompositingForegroundPhase to walk child layers.
>+        paintFlags |= { RenderLayer::PaintLayerPaintingRootBackgroundOnly, RenderLayer::PaintLayerPaintingCompositingForegroundPhase }; // Need PaintLayerPaintingCompositingForegroundPhase to walk child layers.
>     else if (compositor().fixedRootBackgroundLayer())
>         paintFlags |= RenderLayer::PaintLayerPaintingSkipRootBackground;
> 
>Index: Source/WebCore/rendering/RenderLayerBacking.h
>===================================================================
>--- Source/WebCore/rendering/RenderLayerBacking.h	(revision 234753)
>+++ Source/WebCore/rendering/RenderLayerBacking.h	(working copy)
>@@ -106,7 +106,7 @@ public:
>     GraphicsLayer* scrollingLayer() const { return m_scrollingLayer.get(); }
>     GraphicsLayer* scrollingContentsLayer() const { return m_scrollingContentsLayer.get(); }
> 
>-    void detachFromScrollingCoordinator(LayerScrollCoordinationRoles);
>+    void detachFromScrollingCoordinator(OptionSet<LayerScrollCoordinationRole>);
>     
>     ScrollingNodeID scrollingNodeIDForRole(LayerScrollCoordinationRole role) const
>     {
>Index: Source/WebCore/rendering/RenderLayerCompositor.cpp
>===================================================================
>--- Source/WebCore/rendering/RenderLayerCompositor.cpp	(revision 234753)
>+++ Source/WebCore/rendering/RenderLayerCompositor.cpp	(working copy)
>@@ -2755,8 +2755,8 @@ bool RenderLayerCompositor::requiresComp
>     else
>         viewBounds = m_renderView.frameView().rectForFixedPositionLayout();
> 
>-    LayoutRect layerBounds = layer.calculateLayerBounds(&layer, LayoutSize(), RenderLayer::UseLocalClipRectIfPossible | RenderLayer::IncludeLayerFilterOutsets | RenderLayer::UseFragmentBoxesExcludingCompositing
>-        | RenderLayer::ExcludeHiddenDescendants | RenderLayer::DontConstrainForMask | RenderLayer::IncludeCompositedDescendants);
>+    LayoutRect layerBounds = layer.calculateLayerBounds(&layer, LayoutSize(), { RenderLayer::UseLocalClipRectIfPossible, RenderLayer::IncludeLayerFilterOutsets, RenderLayer::UseFragmentBoxesExcludingCompositing,
>+        RenderLayer::ExcludeHiddenDescendants, RenderLayer::DontConstrainForMask, RenderLayer::IncludeCompositedDescendants });
>     // Map to m_renderView to ignore page scale.
>     FloatRect absoluteBounds = layer.renderer().localToContainerQuad(FloatRect(layerBounds), &m_renderView).boundingBox();
>     if (!viewBounds.intersects(enclosingIntRect(absoluteBounds))) {
>@@ -3620,7 +3620,7 @@ static bool canCoordinateScrollingForLay
> 
> void RenderLayerCompositor::updateScrollCoordinatedStatus(RenderLayer& layer, OptionSet<ScrollingNodeChangeFlags> changes)
> {
>-    LayerScrollCoordinationRoles coordinationRoles = 0;
>+    OptionSet<LayerScrollCoordinationRole> coordinationRoles;
>     if (isViewportConstrainedFixedOrStickyLayer(layer))
>         coordinationRoles |= ViewportConstrained;
> 
>@@ -3628,7 +3628,7 @@ void RenderLayerCompositor::updateScroll
>         coordinationRoles |= Scrolling;
> 
>     if (layer.isComposited())
>-        layer.backing()->setIsScrollCoordinatedWithViewportConstrainedRole(coordinationRoles & ViewportConstrained);
>+        layer.backing()->setIsScrollCoordinatedWithViewportConstrainedRole(coordinationRoles.contains(ViewportConstrained));
> 
>     if (coordinationRoles && canCoordinateScrollingForLayer(layer)) {
>         if (m_scrollCoordinatedLayers.add(&layer).isNewEntry)
>@@ -3649,7 +3649,7 @@ void RenderLayerCompositor::removeFromSc
>     m_scrollCoordinatedLayers.remove(&layer);
>     m_scrollCoordinatedLayersNeedingUpdate.remove(&layer);
> 
>-    detachScrollCoordinatedLayer(layer, Scrolling | ViewportConstrained);
>+    detachScrollCoordinatedLayer(layer, { Scrolling, ViewportConstrained });
> }
> 
> FixedPositionViewportConstraints RenderLayerCompositor::computeFixedViewportConstraints(RenderLayer& layer) const
>@@ -3807,7 +3807,7 @@ ScrollingNodeID RenderLayerCompositor::a
>     return nodeID;
> }
> 
>-void RenderLayerCompositor::detachScrollCoordinatedLayer(RenderLayer& layer, LayerScrollCoordinationRoles roles)
>+void RenderLayerCompositor::detachScrollCoordinatedLayer(RenderLayer& layer, OptionSet<LayerScrollCoordinationRole> roles)
> {
>     auto* backing = layer.backing();
>     if (!backing)
>@@ -3835,7 +3835,7 @@ void RenderLayerCompositor::updateScroll
>     scrollingCoordinator->updateFrameScrollingNode(nodeID, m_scrollLayer.get(), m_rootContentLayer.get(), fixedRootBackgroundLayer(), clipLayer());
> }
> 
>-void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, LayerScrollCoordinationRoles reasons, OptionSet<ScrollingNodeChangeFlags> changes)
>+void RenderLayerCompositor::updateScrollCoordinatedLayer(RenderLayer& layer, OptionSet<LayerScrollCoordinationRole> reasons, OptionSet<ScrollingNodeChangeFlags> changes)
> {
>     bool isRenderViewLayer = layer.isRenderViewLayer();
> 
>Index: Source/WebCore/rendering/RenderLayerCompositor.h
>===================================================================
>--- Source/WebCore/rendering/RenderLayerCompositor.h	(revision 234753)
>+++ Source/WebCore/rendering/RenderLayerCompositor.h	(working copy)
>@@ -445,8 +445,8 @@ private:
> 
>     void updateScrollCoordinationForThisFrame(ScrollingNodeID);
>     ScrollingNodeID attachScrollingNode(RenderLayer&, ScrollingNodeType, ScrollingNodeID parentNodeID);
>-    void updateScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles, OptionSet<ScrollingNodeChangeFlags>);
>-    void detachScrollCoordinatedLayer(RenderLayer&, LayerScrollCoordinationRoles);
>+    void updateScrollCoordinatedLayer(RenderLayer&, OptionSet<LayerScrollCoordinationRole>, OptionSet<ScrollingNodeChangeFlags>);
>+    void detachScrollCoordinatedLayer(RenderLayer&, OptionSet<LayerScrollCoordinationRole>);
>     void reattachSubframeScrollLayers();
>     
>     FixedPositionViewportConstraints computeFixedViewportConstraints(RenderLayer&) const;
>Index: Source/WebCore/rendering/RenderReplica.cpp
>===================================================================
>--- Source/WebCore/rendering/RenderReplica.cpp	(revision 234753)
>+++ Source/WebCore/rendering/RenderReplica.cpp	(working copy)
>@@ -76,7 +76,7 @@ void RenderReplica::paint(PaintInfo& pai
>         // computing using the wrong rootLayer
>         RenderLayer* rootPaintingLayer = layer()->transform() ? layer()->parent() : layer()->enclosingTransformedAncestor();
>         RenderLayer::LayerPaintingInfo paintingInfo(rootPaintingLayer, paintInfo.rect, PaintBehavior::Normal, LayoutSize(), 0);
>-        RenderLayer::PaintLayerFlags flags = RenderLayer::PaintLayerHaveTransparency | RenderLayer::PaintLayerAppliedTransform | RenderLayer::PaintLayerTemporaryClipRects | RenderLayer::PaintLayerPaintingReflection;
>+        OptionSet<RenderLayer::PaintLayerFlag> flags { RenderLayer::PaintLayerHaveTransparency, RenderLayer::PaintLayerAppliedTransform, RenderLayer::PaintLayerTemporaryClipRects, RenderLayer::PaintLayerPaintingReflection };
>         layer()->parent()->paintLayer(paintInfo.context(), paintingInfo, flags);
>     } else if (paintInfo.phase == PaintPhase::Mask)
>         paintMask(paintInfo, adjustedPaintOffset);

Actions: View | Formatted Diff | Diff

Attachments on bug 188472: 346913