Attachment 347157 Details for Bug 188554 – patch

[patch] patch

optionset-activitystate-5.patch (text/plain), 65.88 KB, created by Antti Koivisto on 2018-08-15 04:29:58 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Antti Koivisto

Created: 2018-08-15 04:29:58 PDT

Size: 65.88 KB

patch

obsolete

>Index: Source/WTF/ChangeLog
>===================================================================
>--- Source/WTF/ChangeLog	(revision 234841)
>+++ Source/WTF/ChangeLog	(working copy)
>@@ -1,3 +1,15 @@
>+2018-08-14  Antti Koivisto  <antti@apple.com>
>+
>+        Use OptionSet for ActivityState::Flags
>+        https://bugs.webkit.org/show_bug.cgi?id=188554
>+
>+        Reviewed by Brent Fulgham.
>+
>+        * wtf/OptionSet.h:
>+        (WTF::OptionSet::operator^):
>+
>+        Add xor operator, useful for finding changes between sets.
>+
> 2018-08-13  Don Olmstead  <don.olmstead@sony.com>
> 
>         Meaning of OptionSet::contains is unclear when used with OptionSet argument
>Index: Source/WTF/wtf/OptionSet.h
>===================================================================
>--- Source/WTF/wtf/OptionSet.h	(revision 234841)
>+++ Source/WTF/wtf/OptionSet.h	(working copy)
>@@ -148,6 +148,11 @@ public:
>         return fromRaw(lhs.m_storage & ~rhs.m_storage);
>     }
> 
>+    constexpr friend OptionSet operator^(OptionSet lhs, OptionSet rhs)
>+    {
>+        return fromRaw(lhs.m_storage ^ rhs.m_storage);
>+    }
>+
> private:
>     enum InitializationTag { FromRawValue };
>     constexpr OptionSet(T t, InitializationTag)
>Index: Source/WebCore/ChangeLog
>===================================================================
>--- Source/WebCore/ChangeLog	(revision 234841)
>+++ Source/WebCore/ChangeLog	(working copy)
>@@ -1,3 +1,52 @@
>+2018-08-14  Antti Koivisto  <antti@apple.com>
>+
>+        Use OptionSet for ActivityState::Flags
>+        https://bugs.webkit.org/show_bug.cgi?id=188554
>+
>+        Reviewed by Brent Fulgham.
>+
>+        More typesafe flags.
>+
>+        * Modules/geolocation/GeolocationController.cpp:
>+        (WebCore::GeolocationController::activityStateDidChange):
>+        * Modules/geolocation/GeolocationController.h:
>+        * html/canvas/WebGLRenderingContextBase.cpp:
>+        (WebCore::WebGLRenderingContextBase::activityStateDidChange):
>+        * html/canvas/WebGLRenderingContextBase.h:
>+        * page/ActivityState.cpp:
>+        (WebCore::operator<<):
>+        (WebCore::activityStateFlagsToString): Deleted.
>+        * page/ActivityState.h:
>+        (WebCore::ActivityState::allFlags):
>+        * page/ActivityStateChangeObserver.h:
>+        * page/FocusController.cpp:
>+        (WebCore::FocusController::FocusController):
>+        (WebCore::FocusController::setFocused):
>+        (WebCore::FocusController::setActivityState):
>+        (WebCore::FocusController::setActive):
>+        * page/FocusController.h:
>+        (WebCore::FocusController::isActive const):
>+        (WebCore::FocusController::isFocused const):
>+        (WebCore::FocusController::contentIsVisible const):
>+        * page/Page.cpp:
>+        (WebCore::pageInitialActivityState):
>+        (WebCore::Page::Page):
>+        (WebCore::Page::setIsInWindow):
>+        (WebCore::Page::updateTimerThrottlingState):
>+        (WebCore::Page::setActivityState):
>+        (WebCore::Page::isVisibleAndActive const):
>+        (WebCore::Page::isWindowActive const):
>+        (WebCore::Page::setIsVisible):
>+        * page/Page.h:
>+        (WebCore::Page::activityState const):
>+        (WebCore::Page::isVisible const):
>+        (WebCore::Page::isInWindow const):
>+        * page/PerformanceMonitor.cpp:
>+        (WebCore::activityStateForCPUSampling):
>+        (WebCore::PerformanceMonitor::activityStateChanged):
>+        * page/PerformanceMonitor.h:
>+        * platform/text/cocoa: Added.
>+
> 2018-08-14  Rob Buis  <rbuis@igalia.com>
> 
>         Fetch: content-length header is being added to the safe-list
>Index: Source/WebCore/Modules/geolocation/GeolocationController.cpp
>===================================================================
>--- Source/WebCore/Modules/geolocation/GeolocationController.cpp	(revision 234841)
>+++ Source/WebCore/Modules/geolocation/GeolocationController.cpp	(working copy)
>@@ -128,10 +128,10 @@ std::optional<GeolocationPosition> Geolo
>     return m_client.lastPosition();
> }
> 
>-void GeolocationController::activityStateDidChange(ActivityState::Flags oldActivityState, ActivityState::Flags newActivityState)
>+void GeolocationController::activityStateDidChange(OptionSet<ActivityState::Flag> oldActivityState, OptionSet<ActivityState::Flag> newActivityState)
> {
>     // Toggle GPS based on page visibility to save battery.
>-    ActivityState::Flags changed = oldActivityState ^ newActivityState;
>+    auto changed = oldActivityState ^ newActivityState;
>     if (changed & ActivityState::IsVisible && !m_observers.isEmpty()) {
>         if (newActivityState & ActivityState::IsVisible)
>             m_client.startUpdating();
>Index: Source/WebCore/Modules/geolocation/GeolocationController.h
>===================================================================
>--- Source/WebCore/Modules/geolocation/GeolocationController.h	(revision 234841)
>+++ Source/WebCore/Modules/geolocation/GeolocationController.h	(working copy)
>@@ -67,7 +67,7 @@ private:
>     Page& m_page;
>     GeolocationClient& m_client;
> 
>-    void activityStateDidChange(ActivityState::Flags oldActivityState, ActivityState::Flags newActivityState) override;
>+    void activityStateDidChange(OptionSet<ActivityState::Flag> oldActivityState, OptionSet<ActivityState::Flag> newActivityState) override;
> 
>     std::optional<GeolocationPosition> m_lastPosition;
> 
>Index: Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp
>===================================================================
>--- Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp	(revision 234841)
>+++ Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp	(working copy)
>@@ -6371,14 +6371,14 @@ bool WebGLRenderingContextBase::enableSu
>     return true;
> }
> 
>-void WebGLRenderingContextBase::activityStateDidChange(ActivityState::Flags oldActivityState, ActivityState::Flags newActivityState)
>+void WebGLRenderingContextBase::activityStateDidChange(OptionSet<ActivityState::Flag> oldActivityState, OptionSet<ActivityState::Flag> newActivityState)
> {
>     if (!m_context)
>         return;
> 
>-    ActivityState::Flags changed = oldActivityState ^ newActivityState;
>+    auto changed = oldActivityState ^ newActivityState;
>     if (changed & ActivityState::IsVisible)
>-        m_context->setContextVisibility(newActivityState & ActivityState::IsVisible);
>+        m_context->setContextVisibility(newActivityState.contains(ActivityState::IsVisible));
> }
> 
> void WebGLRenderingContextBase::setFailNextGPUStatusCheck()
>Index: Source/WebCore/html/canvas/WebGLRenderingContextBase.h
>===================================================================
>--- Source/WebCore/html/canvas/WebGLRenderingContextBase.h	(revision 234841)
>+++ Source/WebCore/html/canvas/WebGLRenderingContextBase.h	(working copy)
>@@ -838,7 +838,7 @@ private:
>     void registerWithWebGLStateTracker();
>     void checkForContextLossHandling();
> 
>-    void activityStateDidChange(ActivityState::Flags oldActivityState, ActivityState::Flags newActivityState) override;
>+    void activityStateDidChange(OptionSet<ActivityState::Flag> oldActivityState, OptionSet<ActivityState::Flag> newActivityState) override;
> 
>     WebGLStateTracker::Token m_trackerToken;
>     Timer m_checkForContextLossHandlingTimer;
>Index: Source/WebCore/page/ActivityState.cpp
>===================================================================
>--- Source/WebCore/page/ActivityState.cpp	(revision 234841)
>+++ Source/WebCore/page/ActivityState.cpp	(working copy)
>@@ -26,65 +26,34 @@
> #include "config.h"
> #include "ActivityState.h"
> 
>-#include <wtf/text/StringBuilder.h>
>+#include <wtf/text/TextStream.h>
> 
> namespace WebCore {
> 
>-String activityStateFlagsToString(ActivityState::Flags flags)
>+TextStream& operator<<(TextStream& ts, OptionSet<ActivityState::Flag> flags)
> {
>-    StringBuilder builder;
>-    
>-    auto appendCommaIfNecessary = [&]() {
>-        if (!builder.isEmpty())
>-            builder.append(", ");
>+    bool didAppend = false;
>+
>+    auto appendIf = [&](auto flag, auto message) {
>+        if (!flags.contains(flag))
>+            return;
>+        if (didAppend)
>+            ts << ", ";
>+        ts << message;
>+        didAppend = true;
>     };
>     
>-    if (flags & WebCore::ActivityState::WindowIsActive) {
>-        appendCommaIfNecessary();
>-        builder.append("active window");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsFocused) {
>-        appendCommaIfNecessary();
>-        builder.append("focused");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsVisible) {
>-        appendCommaIfNecessary();
>-        builder.append("visible");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsVisibleOrOccluded) {
>-        appendCommaIfNecessary();
>-        builder.append("visible or occluded");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsInWindow) {
>-        appendCommaIfNecessary();
>-        builder.append("in-window");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsVisuallyIdle) {
>-        appendCommaIfNecessary();
>-        builder.append("visually idle");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsAudible) {
>-        appendCommaIfNecessary();
>-        builder.append("audible");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsLoading) {
>-        appendCommaIfNecessary();
>-        builder.append("loading");
>-    }
>-
>-    if (flags & WebCore::ActivityState::IsCapturingMedia) {
>-        appendCommaIfNecessary();
>-        builder.append("capturing media");
>-    }
>-    
>-    return builder.toString();
>+    appendIf(ActivityState::WindowIsActive, "active window");
>+    appendIf(ActivityState::IsFocused, "focused");
>+    appendIf(ActivityState::IsVisible, "visible");
>+    appendIf(ActivityState::IsVisibleOrOccluded, "visible or occluded");
>+    appendIf(ActivityState::IsInWindow, "in-window");
>+    appendIf(ActivityState::IsVisuallyIdle, "visually idle");
>+    appendIf(ActivityState::IsAudible, "audible");
>+    appendIf(ActivityState::IsLoading, "loading");
>+    appendIf(ActivityState::IsCapturingMedia, "capturing media");
>+
>+    return ts;
> }
> 
> } // namespace WebCore
>Index: Source/WebCore/page/ActivityState.h
>===================================================================
>--- Source/WebCore/page/ActivityState.h	(revision 234841)
>+++ Source/WebCore/page/ActivityState.h	(working copy)
>@@ -25,14 +25,16 @@
> 
> #pragma once
> 
>+#include <wtf/OptionSet.h>
>+
> namespace WTF {
>-class String;
>+class TextStream;
> }
> 
> namespace WebCore {
> 
> struct ActivityState {
>-    enum {
>+    enum Flag {
>         WindowIsActive = 1 << 0,
>         IsFocused = 1 << 1,
>         IsVisible = 1 << 2,
>@@ -44,10 +46,7 @@ struct ActivityState {
>         IsCapturingMedia = 1 << 8,
>     };
> 
>-    typedef unsigned Flags;
>-
>-    static const Flags NoFlags = 0;
>-    static const Flags AllFlags = WindowIsActive | IsFocused | IsVisible | IsVisibleOrOccluded | IsInWindow | IsVisuallyIdle | IsAudible | IsLoading | IsCapturingMedia;
>+    static constexpr OptionSet<Flag> allFlags() { return { WindowIsActive, IsFocused, IsVisible, IsVisibleOrOccluded, IsInWindow, IsVisuallyIdle, IsAudible, IsLoading, IsCapturingMedia }; }
> };
> 
> enum class ActivityStateForCPUSampling {
>@@ -56,7 +55,6 @@ enum class ActivityStateForCPUSampling {
>     VisibleAndActive
> };
> 
>-// Ideally this would be operator<<(WTF::TextStream&, ActivityState::Flags) but ActivityState::Flags needs to be strongly typed to avoid ambiguous overloads.
>-WEBCORE_EXPORT WTF::String activityStateFlagsToString(ActivityState::Flags);
>+WEBCORE_EXPORT WTF::TextStream& operator<<(WTF::TextStream&, OptionSet<ActivityState::Flag>);
> 
> } // namespace WebCore
>Index: Source/WebCore/page/ActivityStateChangeObserver.h
>===================================================================
>--- Source/WebCore/page/ActivityStateChangeObserver.h	(revision 234841)
>+++ Source/WebCore/page/ActivityStateChangeObserver.h	(working copy)
>@@ -35,7 +35,7 @@ public:
>     {
>     }
>     
>-    virtual void activityStateDidChange(ActivityState::Flags oldActivityState, ActivityState::Flags newActivityState) = 0;
>+    virtual void activityStateDidChange(OptionSet<ActivityState::Flag> oldActivityState, OptionSet<ActivityState::Flag> newActivityState) = 0;
> };
> 
> } // namespace WebCore
>Index: Source/WebCore/page/FocusController.cpp
>===================================================================
>--- Source/WebCore/page/FocusController.cpp	(revision 234841)
>+++ Source/WebCore/page/FocusController.cpp	(working copy)
>@@ -307,7 +307,7 @@ static inline int shadowAdjustedTabIndex
>     return element.tabIndex();
> }
> 
>-FocusController::FocusController(Page& page, ActivityState::Flags activityState)
>+FocusController::FocusController(Page& page, OptionSet<ActivityState::Flag> activityState)
>     : m_page(page)
>     , m_isChangingFocusedFrame(false)
>     , m_activityState(activityState)
>@@ -353,7 +353,7 @@ Frame& FocusController::focusedOrMainFra
> 
> void FocusController::setFocused(bool focused)
> {
>-    m_page.setActivityState(focused ? m_activityState | ActivityState::IsFocused : m_activityState & ~ActivityState::IsFocused);
>+    m_page.setActivityState(focused ? m_activityState | ActivityState::IsFocused : m_activityState - ActivityState::IsFocused);
> }
> 
> void FocusController::setFocusedInternal(bool focused)
>@@ -841,23 +841,23 @@ bool FocusController::setFocusedElement(
>     return true;
> }
> 
>-void FocusController::setActivityState(ActivityState::Flags activityState)
>+void FocusController::setActivityState(OptionSet<ActivityState::Flag> activityState)
> {
>-    ActivityState::Flags changed = m_activityState ^ activityState;
>+    auto changed = m_activityState ^ activityState;
>     m_activityState = activityState;
> 
>     if (changed & ActivityState::IsFocused)
>-        setFocusedInternal(activityState & ActivityState::IsFocused);
>+        setFocusedInternal(activityState.contains(ActivityState::IsFocused));
>     if (changed & ActivityState::WindowIsActive) {
>-        setActiveInternal(activityState & ActivityState::WindowIsActive);
>+        setActiveInternal(activityState.contains(ActivityState::WindowIsActive));
>         if (changed & ActivityState::IsVisible)
>-            setIsVisibleAndActiveInternal(activityState & ActivityState::WindowIsActive);
>+            setIsVisibleAndActiveInternal(activityState.contains(ActivityState::WindowIsActive));
>     }
> }
> 
> void FocusController::setActive(bool active)
> {
>-    m_page.setActivityState(active ? m_activityState | ActivityState::WindowIsActive : m_activityState & ~ActivityState::WindowIsActive);
>+    m_page.setActivityState(active ? m_activityState | ActivityState::WindowIsActive : m_activityState - ActivityState::WindowIsActive);
> }
> 
> void FocusController::setActiveInternal(bool active)
>Index: Source/WebCore/page/FocusController.h
>===================================================================
>--- Source/WebCore/page/FocusController.h	(revision 234841)
>+++ Source/WebCore/page/FocusController.h	(working copy)
>@@ -51,7 +51,7 @@ struct FocusCandidate;
> class FocusController {
>     WTF_MAKE_FAST_ALLOCATED;
> public:
>-    explicit FocusController(Page&, ActivityState::Flags);
>+    explicit FocusController(Page&, OptionSet<ActivityState::Flag>);
> 
>     WEBCORE_EXPORT void setFocusedFrame(Frame*);
>     Frame* focusedFrame() const { return m_focusedFrame.get(); }
>@@ -62,15 +62,15 @@ public:
> 
>     WEBCORE_EXPORT bool setFocusedElement(Element*, Frame&, FocusDirection = FocusDirectionNone);
> 
>-    void setActivityState(ActivityState::Flags);
>+    void setActivityState(OptionSet<ActivityState::Flag>);
> 
>     WEBCORE_EXPORT void setActive(bool);
>-    bool isActive() const { return m_activityState & ActivityState::WindowIsActive; }
>+    bool isActive() const { return m_activityState.contains(ActivityState::WindowIsActive); }
> 
>     WEBCORE_EXPORT void setFocused(bool);
>-    bool isFocused() const { return m_activityState & ActivityState::IsFocused; }
>+    bool isFocused() const { return m_activityState.contains(ActivityState::IsFocused); }
> 
>-    bool contentIsVisible() const { return m_activityState & ActivityState::IsVisible; }
>+    bool contentIsVisible() const { return m_activityState.contains(ActivityState::IsVisible); }
> 
>     // These methods are used in WebCore/bindings/objc/DOM.mm.
>     WEBCORE_EXPORT Element* nextFocusableElement(Node&);
>@@ -119,7 +119,7 @@ private:
>     Page& m_page;
>     RefPtr<Frame> m_focusedFrame;
>     bool m_isChangingFocusedFrame;
>-    ActivityState::Flags m_activityState;
>+    OptionSet<ActivityState::Flag> m_activityState;
> 
>     Timer m_focusRepaintTimer;
>     MonotonicTime m_focusSetTime;
>Index: Source/WebCore/page/Page.cpp
>===================================================================
>--- Source/WebCore/page/Page.cpp	(revision 234841)
>+++ Source/WebCore/page/Page.cpp	(working copy)
>@@ -192,7 +192,10 @@ static void networkStateChanged(bool isO
>     }
> }
> 
>-static const ActivityState::Flags PageInitialActivityState = ActivityState::IsVisible | ActivityState::IsInWindow;
>+static constexpr OptionSet<ActivityState::Flag> pageInitialActivityState()
>+{
>+    return { ActivityState::IsVisible, ActivityState::IsInWindow };
>+}
> 
> Page::Page(PageConfiguration&& pageConfiguration)
>     : m_chrome(std::make_unique<Chrome>(*this, *pageConfiguration.chromeClient))
>@@ -200,7 +203,7 @@ Page::Page(PageConfiguration&& pageConfi
> #if ENABLE(DRAG_SUPPORT)
>     , m_dragController(std::make_unique<DragController>(*this, *pageConfiguration.dragClient))
> #endif
>-    , m_focusController(std::make_unique<FocusController>(*this, PageInitialActivityState))
>+    , m_focusController(std::make_unique<FocusController>(*this, pageInitialActivityState()))
> #if ENABLE(CONTEXT_MENUS)
>     , m_contextMenuController(std::make_unique<ContextMenuController>(*this, *pageConfiguration.contextMenuClient))
> #endif
>@@ -224,7 +227,7 @@ Page::Page(PageConfiguration&& pageConfi
>     , m_horizontalScrollElasticity(ScrollElasticityAllowed)
>     , m_domTimerAlignmentInterval(DOMTimer::defaultAlignmentInterval())
>     , m_domTimerAlignmentIntervalIncreaseTimer(*this, &Page::domTimerAlignmentIntervalIncreaseTimerFired)
>-    , m_activityState(PageInitialActivityState)
>+    , m_activityState(pageInitialActivityState())
>     , m_alternativeTextClient(pageConfiguration.alternativeTextClient)
>     , m_consoleClient(std::make_unique<PageConsoleClient>(*this))
> #if ENABLE(REMOTE_INSPECTOR)
>@@ -1089,7 +1092,7 @@ unsigned Page::pageCount() const
> 
> void Page::setIsInWindow(bool isInWindow)
> {
>-    setActivityState(isInWindow ? m_activityState | ActivityState::IsInWindow : m_activityState & ~ActivityState::IsInWindow);
>+    setActivityState(isInWindow ? m_activityState | ActivityState::IsInWindow : m_activityState - ActivityState::IsInWindow);
> }
> 
> void Page::setIsInWindowInternal(bool isInWindow)
>@@ -1356,7 +1359,7 @@ void Page::updateTimerThrottlingState()
>     // If the page is visible (but idle), there is any activity (loading, media playing, etc), or per setting,
>     // we allow timer throttling, but not increasing timer throttling.
>     if (!m_settings->hiddenPageDOMTimerThrottlingAutoIncreases()
>-        || m_activityState & (ActivityState::IsVisible | ActivityState::IsAudible | ActivityState::IsLoading | ActivityState::IsCapturingMedia)) {
>+        || m_activityState.containsAny({ActivityState::IsVisible, ActivityState::IsAudible, ActivityState::IsLoading, ActivityState::IsCapturingMedia })) {
>         setTimerThrottlingState(TimerThrottlingState::Enabled);
>         return;
>     }
>@@ -1590,13 +1593,13 @@ void Page::resumeAnimatingImages()
>         view->resumeVisibleImageAnimationsIncludingSubframes();
> }
> 
>-void Page::setActivityState(ActivityState::Flags activityState)
>+void Page::setActivityState(OptionSet<ActivityState::Flag> activityState)
> {
>-    ActivityState::Flags changed = m_activityState ^ activityState;
>+    auto changed = m_activityState ^ activityState;
>     if (!changed)
>         return;
> 
>-    ActivityState::Flags oldActivityState = m_activityState;
>+    auto oldActivityState = m_activityState;
> 
>     bool wasVisibleAndActive = isVisibleAndActive();
>     m_activityState = activityState;
>@@ -1604,17 +1607,17 @@ void Page::setActivityState(ActivityStat
>     m_focusController->setActivityState(activityState);
> 
>     if (changed & ActivityState::IsVisible)
>-        setIsVisibleInternal(activityState & ActivityState::IsVisible);
>+        setIsVisibleInternal(activityState.contains(ActivityState::IsVisible));
>     if (changed & ActivityState::IsInWindow)
>-        setIsInWindowInternal(activityState & ActivityState::IsInWindow);
>+        setIsInWindowInternal(activityState.contains(ActivityState::IsInWindow));
>     if (changed & ActivityState::IsVisuallyIdle)
>-        setIsVisuallyIdleInternal(activityState & ActivityState::IsVisuallyIdle);
>+        setIsVisuallyIdleInternal(activityState.contains(ActivityState::IsVisuallyIdle));
>     if (changed & ActivityState::WindowIsActive) {
>         if (auto* view = m_mainFrame->view())
>             view->updateTiledBackingAdaptiveSizing();
>     }
> 
>-    if (changed & (ActivityState::IsVisible | ActivityState::IsVisuallyIdle | ActivityState::IsAudible | ActivityState::IsLoading | ActivityState::IsCapturingMedia))
>+    if (changed.containsAny({ActivityState::IsVisible, ActivityState::IsVisuallyIdle, ActivityState::IsAudible, ActivityState::IsLoading, ActivityState::IsCapturingMedia }))
>         updateTimerThrottlingState();
> 
>     for (auto* observer : m_activityStateChangeObservers)
>@@ -1629,20 +1632,26 @@ void Page::setActivityState(ActivityStat
> 
> bool Page::isVisibleAndActive() const
> {
>-    return (m_activityState & ActivityState::IsVisible) && (m_activityState & ActivityState::WindowIsActive);
>+    return m_activityState.contains(ActivityState::IsVisible) && m_activityState.contains(ActivityState::WindowIsActive);
> }
> 
> bool Page::isWindowActive() const
> {
>-    return m_activityState & ActivityState::WindowIsActive;
>+    return m_activityState.contains(ActivityState::WindowIsActive);
> }
> 
> void Page::setIsVisible(bool isVisible)
> {
>-    if (isVisible)
>-        setActivityState((m_activityState & ~ActivityState::IsVisuallyIdle) | ActivityState::IsVisible | ActivityState::IsVisibleOrOccluded);
>-    else
>-        setActivityState((m_activityState & ~(ActivityState::IsVisible | ActivityState::IsVisibleOrOccluded)) | ActivityState::IsVisuallyIdle);
>+    auto state = m_activityState;
>+
>+    if (isVisible) {
>+        state -= ActivityState::IsVisuallyIdle;
>+        state |= { ActivityState::IsVisible, ActivityState::IsVisibleOrOccluded };
>+    } else {
>+        state |= ActivityState::IsVisuallyIdle;
>+        state -= { ActivityState::IsVisible, ActivityState::IsVisibleOrOccluded };
>+    }
>+    setActivityState(state);
> }
> 
> enum class SVGAnimationsState { Paused, Resumed };
>Index: Source/WebCore/page/Page.h
>===================================================================
>--- Source/WebCore/page/Page.h	(revision 234841)
>+++ Source/WebCore/page/Page.h	(working copy)
>@@ -415,18 +415,18 @@ public:
> #endif
> 
>     // Notifications when the Page starts and stops being presented via a native window.
>-    WEBCORE_EXPORT void setActivityState(ActivityState::Flags);
>-    ActivityState::Flags activityState() const { return m_activityState; }
>+    WEBCORE_EXPORT void setActivityState(OptionSet<ActivityState::Flag>);
>+    OptionSet<ActivityState::Flag> activityState() const { return m_activityState; }
> 
>     bool isWindowActive() const;
>     bool isVisibleAndActive() const;
>     WEBCORE_EXPORT void setIsVisible(bool);
>     WEBCORE_EXPORT void setIsPrerender();
>-    bool isVisible() const { return m_activityState & ActivityState::IsVisible; }
>+    bool isVisible() const { return m_activityState.contains(ActivityState::IsVisible); }
> 
>     // Notification that this Page was moved into or out of a native window.
>     WEBCORE_EXPORT void setIsInWindow(bool);
>-    bool isInWindow() const { return m_activityState & ActivityState::IsInWindow; }
>+    bool isInWindow() const { return m_activityState.contains(ActivityState::IsInWindow); }
> 
>     void setIsClosing() { m_isClosing = true; }
>     bool isClosing() const { return m_isClosing; }
>@@ -811,7 +811,7 @@ private:
> 
>     bool m_isEditable { false };
>     bool m_isPrerender { false };
>-    ActivityState::Flags m_activityState;
>+    OptionSet<ActivityState::Flag> m_activityState;
> 
>     LayoutMilestones m_requestedLayoutMilestones { 0 };
> 
>Index: Source/WebCore/page/PerformanceMonitor.cpp
>===================================================================
>--- Source/WebCore/page/PerformanceMonitor.cpp	(revision 234841)
>+++ Source/WebCore/page/PerformanceMonitor.cpp	(working copy)
>@@ -55,7 +55,7 @@ static const double postPageLoadCPUUsage
> static const uint64_t postPageLoadMemoryUsageDomainReportingThreshold { 2048 * MB };
> #endif
> 
>-static inline ActivityStateForCPUSampling activityStateForCPUSampling(ActivityState::Flags state)
>+static inline ActivityStateForCPUSampling activityStateForCPUSampling(OptionSet<ActivityState::Flag> state)
> {
>     if (!(state & ActivityState::IsVisible))
>         return ActivityStateForCPUSampling::NonVisible;
>@@ -101,10 +101,10 @@ void PerformanceMonitor::didFinishLoad()
>         m_postPageLoadMemoryUsageTimer.startOneShot(memoryUsageMeasurementDelay);
> }
> 
>-void PerformanceMonitor::activityStateChanged(ActivityState::Flags oldState, ActivityState::Flags newState)
>+void PerformanceMonitor::activityStateChanged(OptionSet<ActivityState::Flag> oldState, OptionSet<ActivityState::Flag> newState)
> {
>-    ActivityState::Flags changed = oldState ^ newState;
>-    bool visibilityChanged = changed & ActivityState::IsVisible;
>+    auto changed = oldState ^ newState;
>+    bool visibilityChanged = changed.contains(ActivityState::IsVisible);
> 
>     // Measure CPU usage of pages when they are no longer visible.
>     if (DeprecatedGlobalSettings::isPostBackgroundingCPUUsageMeasurementEnabled() && visibilityChanged) {
>Index: Source/WebCore/page/PerformanceMonitor.h
>===================================================================
>--- Source/WebCore/page/PerformanceMonitor.h	(revision 234841)
>+++ Source/WebCore/page/PerformanceMonitor.h	(working copy)
>@@ -40,7 +40,7 @@ public:
> 
>     void didStartProvisionalLoad();
>     void didFinishLoad();
>-    void activityStateChanged(ActivityState::Flags oldState, ActivityState::Flags newState);
>+    void activityStateChanged(OptionSet<ActivityState::Flag> oldState, OptionSet<ActivityState::Flag> newState);
> 
> private:
>     void measurePostLoadCPUUsage();
>Index: Source/WebCore/testing/Internals.cpp
>===================================================================
>--- Source/WebCore/testing/Internals.cpp	(revision 234841)
>+++ Source/WebCore/testing/Internals.cpp	(working copy)
>@@ -4331,7 +4331,7 @@ void Internals::setPageVisibility(bool i
>     auto state = page.activityState();
> 
>     if (!isVisible)
>-        state &= ~ActivityState::IsVisible;
>+        state -= ActivityState::IsVisible;
>     else
>         state |= ActivityState::IsVisible;
> 
>Index: Source/WebKit/ChangeLog
>===================================================================
>--- Source/WebKit/ChangeLog	(revision 234848)
>+++ Source/WebKit/ChangeLog	(working copy)
>@@ -1,3 +1,50 @@
>+2018-08-14  Antti Koivisto  <antti@apple.com>
>+
>+        Use OptionSet for ActivityState::Flags
>+        https://bugs.webkit.org/show_bug.cgi?id=188554
>+
>+        Reviewed by Brent Fulgham.
>+
>+        * Shared/WebPageCreationParameters.h:
>+        * UIProcess/Cocoa/WebViewImpl.mm:
>+        (WebKit::WebViewImpl::windowDidOrderOffScreen):
>+        (WebKit::WebViewImpl::windowDidOrderOnScreen):
>+        (WebKit::WebViewImpl::viewDidMoveToWindow):
>+        * UIProcess/WebPageProxy.cpp:
>+        (WebKit::WebPageProxy::updateActivityState):
>+        (WebKit::WebPageProxy::activityStateDidChange):
>+        (WebKit::WebPageProxy::dispatchActivityStateChange):
>+        (WebKit::WebPageProxy::setMuted):
>+        (WebKit::WebPageProxy::isPlayingMediaDidChange):
>+        * UIProcess/WebPageProxy.h:
>+        (WebKit::WebPageProxy::isInWindow const):
>+        (WebKit::WebPageProxy::isViewVisible const):
>+        (WebKit::WebPageProxy::isViewFocused const):
>+        (WebKit::WebPageProxy::isViewWindowActive const):
>+        * WebProcess/Plugins/PluginView.cpp:
>+        (WebKit::PluginView::activityStateDidChange):
>+        * WebProcess/Plugins/PluginView.h:
>+        * WebProcess/WebPage/DrawingArea.h:
>+        (WebKit::DrawingArea::activityStateDidChange):
>+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h:
>+        * WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm:
>+        (WebKit::RemoteLayerTreeDrawingArea::activityStateDidChange):
>+        * WebProcess/WebPage/WebPage.cpp:
>+        (WebKit::WebPage::updateThrottleState):
>+        (WebKit::WebPage::updateIsInWindow):
>+        (WebKit::WebPage::visibilityDidChange):
>+        (WebKit::WebPage::setActivityState):
>+        * WebProcess/WebPage/WebPage.h:
>+        (WebKit::WebPage::isVisible const):
>+        (WebKit::WebPage::isVisibleOrOccluded const):
>+        * WebProcess/WebPage/WebPage.messages.in:
>+        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h:
>+        * WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm:
>+        (WebKit::TiledCoreAnimationDrawingArea::activityStateDidChange):
>+        * WebProcess/WebProcess.cpp:
>+        (WebKit::WebProcess::pageActivityStateDidChange):
>+        * WebProcess/WebProcess.h:
>+
> 2018-08-13  Wenson Hsieh  <wenson_hsieh@apple.com>
> 
>         [WK2] [macOS] Implement a mechanism to test drag and drop
>Index: Source/WebKit/Shared/WebPageCreationParameters.h
>===================================================================
>--- Source/WebKit/Shared/WebPageCreationParameters.h	(revision 234841)
>+++ Source/WebKit/Shared/WebPageCreationParameters.h	(working copy)
>@@ -67,7 +67,7 @@ struct WebPageCreationParameters {
> 
>     WebCore::IntSize viewSize;
> 
>-    WebCore::ActivityState::Flags activityState;
>+    OptionSet<WebCore::ActivityState::Flag> activityState;
>     
>     WebPreferencesStore store;
>     DrawingAreaType drawingAreaType;
>Index: Source/WebKit/UIProcess/WebPageProxy.cpp
>===================================================================
>--- Source/WebKit/UIProcess/WebPageProxy.cpp	(revision 234841)
>+++ Source/WebKit/UIProcess/WebPageProxy.cpp	(working copy)
>@@ -1492,9 +1492,9 @@ void WebPageProxy::setSuppressVisibility
>     }
> }
> 
>-void WebPageProxy::updateActivityState(ActivityState::Flags flagsToUpdate)
>+void WebPageProxy::updateActivityState(OptionSet<ActivityState::Flag> flagsToUpdate)
> {
>-    m_activityState &= ~flagsToUpdate;
>+    m_activityState = m_activityState - flagsToUpdate;
>     if (flagsToUpdate & ActivityState::IsFocused && m_pageClient.isViewFocused())
>         m_activityState |= ActivityState::IsFocused;
>     if (flagsToUpdate & ActivityState::WindowIsActive && m_pageClient.isViewWindowActive())
>@@ -1515,9 +1515,9 @@ void WebPageProxy::updateActivityState(A
>         m_activityState |= ActivityState::IsCapturingMedia;
> }
> 
>-void WebPageProxy::activityStateDidChange(ActivityState::Flags mayHaveChanged, bool wantsSynchronousReply, ActivityStateChangeDispatchMode dispatchMode)
>+void WebPageProxy::activityStateDidChange(OptionSet<ActivityState::Flag> mayHaveChanged, bool wantsSynchronousReply, ActivityStateChangeDispatchMode dispatchMode)
> {
>-    LOG_WITH_STREAM(ActivityState, stream << "WebPageProxy " << pageID() << " activityStateDidChange - mayHaveChanged " <<  activityStateFlagsToString(mayHaveChanged));
>+    LOG_WITH_STREAM(ActivityState, stream << "WebPageProxy " << pageID() << " activityStateDidChange - mayHaveChanged " << mayHaveChanged);
> 
>     m_potentiallyChangedActivityStateFlags |= mayHaveChanged;
>     m_activityStateChangeWantsSynchronousReply = m_activityStateChangeWantsSynchronousReply || wantsSynchronousReply;
>@@ -1566,20 +1566,20 @@ void WebPageProxy::dispatchActivityState
>     if (!isValid())
>         return;
> 
>-    LOG_WITH_STREAM(ActivityState, stream << "WebPageProxy " << pageID() << " dispatchActivityStateChange - potentiallyChangedActivityStateFlags " << activityStateFlagsToString(m_potentiallyChangedActivityStateFlags));
>+    LOG_WITH_STREAM(ActivityState, stream << "WebPageProxy " << pageID() << " dispatchActivityStateChange - potentiallyChangedActivityStateFlags " << m_potentiallyChangedActivityStateFlags);
> 
>     // If the visibility state may have changed, then so may the visually idle & occluded agnostic state.
>     if (m_potentiallyChangedActivityStateFlags & ActivityState::IsVisible)
>-        m_potentiallyChangedActivityStateFlags |= ActivityState::IsVisibleOrOccluded | ActivityState::IsVisuallyIdle;
>+        m_potentiallyChangedActivityStateFlags |= { ActivityState::IsVisibleOrOccluded, ActivityState::IsVisuallyIdle };
> 
>     // Record the prior view state, update the flags that may have changed,
>     // and check which flags have actually changed.
>-    ActivityState::Flags previousActivityState = m_activityState;
>+    auto previousActivityState = m_activityState;
>     updateActivityState(m_potentiallyChangedActivityStateFlags);
>-    ActivityState::Flags changed = m_activityState ^ previousActivityState;
>+    auto changed = m_activityState ^ previousActivityState;
> 
>     if (changed)
>-        LOG_WITH_STREAM(ActivityState, stream << "WebPageProxy " << pageID() << " dispatchActivityStateChange: state changed from " << activityStateFlagsToString(previousActivityState) << " to " << activityStateFlagsToString(m_activityState));
>+        LOG_WITH_STREAM(ActivityState, stream << "WebPageProxy " << pageID() << " dispatchActivityStateChange: state changed from " << previousActivityState << " to " << m_activityState);
> 
>     if ((m_potentiallyChangedActivityStateFlags & ActivityState::IsVisible) && isViewVisible())
>         viewIsBecomingVisible();
>@@ -1637,7 +1637,7 @@ void WebPageProxy::dispatchActivityState
>     if (activityStateChangeID != ActivityStateChangeAsynchronous)
>         waitForDidUpdateActivityState(activityStateChangeID);
> 
>-    m_potentiallyChangedActivityStateFlags = ActivityState::NoFlags;
>+    m_potentiallyChangedActivityStateFlags = { };
>     m_activityStateChangeWantsSynchronousReply = false;
>     m_viewWasEverInWindow |= isNowInWindow;
> }
>@@ -1663,8 +1663,8 @@ void WebPageProxy::updateThrottleState()
>         m_pageIsUserObservableCount = m_process->processPool().userObservablePageCount();
> 
> #if PLATFORM(IOS)
>-    bool isCapturingMedia = m_activityState & ActivityState::IsCapturingMedia;
>-    bool isAudible = m_activityState & ActivityState::IsAudible;
>+    bool isCapturingMedia = m_activityState.contains(ActivityState::IsCapturingMedia);
>+    bool isAudible = m_activityState.contains(ActivityState::IsAudible);
>     if (!isViewVisible() && !m_alwaysRunsAtForegroundPriority && !isCapturingMedia && !isAudible) {
>         if (m_activityToken) {
>             RELEASE_LOG_IF_ALLOWED(ProcessSuspension, "%p - UIProcess is releasing a foreground assertion because the view is no longer visible", this);
>@@ -4712,7 +4712,7 @@ void WebPageProxy::setMuted(WebCore::Med
> #endif
> 
>     m_process->send(Messages::WebPage::SetMuted(state), m_pageID);
>-    activityStateDidChange(ActivityState::IsAudible | ActivityState::IsCapturingMedia);
>+    activityStateDidChange({ ActivityState::IsAudible, ActivityState::IsCapturingMedia });
> }
> 
> void WebPageProxy::setMediaCaptureEnabled(bool enabled)
>@@ -7269,7 +7269,7 @@ void WebPageProxy::isPlayingMediaDidChan
>     }
> #endif
> 
>-    activityStateDidChange(ActivityState::IsAudible | ActivityState::IsCapturingMedia);
>+    activityStateDidChange({ ActivityState::IsAudible, ActivityState::IsCapturingMedia });
> 
>     playingMediaMask |= WebCore::MediaProducer::MediaCaptureMask;
>     if ((oldState & playingMediaMask) != (m_mediaState & playingMediaMask))
>Index: Source/WebKit/UIProcess/WebPageProxy.h
>===================================================================
>--- Source/WebKit/UIProcess/WebPageProxy.h	(revision 234841)
>+++ Source/WebKit/UIProcess/WebPageProxy.h	(working copy)
>@@ -515,17 +515,17 @@ public:
>     bool delegatesScrolling() const { return m_delegatesScrolling; }
> 
>     enum class ActivityStateChangeDispatchMode { Deferrable, Immediate };
>-    void activityStateDidChange(WebCore::ActivityState::Flags mayHaveChanged, bool wantsSynchronousReply = false, ActivityStateChangeDispatchMode = ActivityStateChangeDispatchMode::Deferrable);
>-    bool isInWindow() const { return m_activityState & WebCore::ActivityState::IsInWindow; }
>+    void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> mayHaveChanged, bool wantsSynchronousReply = false, ActivityStateChangeDispatchMode = ActivityStateChangeDispatchMode::Deferrable);
>+    bool isInWindow() const { return m_activityState.contains(WebCore::ActivityState::IsInWindow); }
>     void waitForDidUpdateActivityState(ActivityStateChangeID);
>     void didUpdateActivityState() { m_waitingForDidUpdateActivityState = false; }
> 
>     void layerHostingModeDidChange();
> 
>     WebCore::IntSize viewSize() const;
>-    bool isViewVisible() const { return m_activityState & WebCore::ActivityState::IsVisible; }
>-    bool isViewFocused() const { return m_activityState & WebCore::ActivityState::IsFocused; }
>-    bool isViewWindowActive() const { return m_activityState & WebCore::ActivityState::WindowIsActive; }
>+    bool isViewVisible() const { return m_activityState.contains(WebCore::ActivityState::IsVisible); }
>+    bool isViewFocused() const { return m_activityState.contains(WebCore::ActivityState::IsFocused); }
>+    bool isViewWindowActive() const { return m_activityState.contains(WebCore::ActivityState::WindowIsActive); }
> 
>     void addMIMETypeWithCustomContentProvider(const String& mimeType);
> 
>@@ -1358,7 +1358,7 @@ private:
> 
>     RefPtr<API::Navigation> goToBackForwardItem(WebBackForwardListItem&, WebCore::FrameLoadType);
> 
>-    void updateActivityState(WebCore::ActivityState::Flags flagsToUpdate = WebCore::ActivityState::AllFlags);
>+    void updateActivityState(OptionSet<WebCore::ActivityState::Flag> flagsToUpdate = WebCore::ActivityState::allFlags());
>     void updateThrottleState();
>     void updateHiddenPageThrottlingAutoIncreases();
> 
>@@ -1939,7 +1939,7 @@ private:
>     std::unique_ptr<UserMediaPermissionRequestManagerProxy> m_userMediaPermissionRequestManager;
> #endif
> 
>-    WebCore::ActivityState::Flags m_activityState { WebCore::ActivityState::NoFlags };
>+    OptionSet<WebCore::ActivityState::Flag> m_activityState;
>     bool m_viewWasEverInWindow { false };
> #if PLATFORM(IOS)
>     bool m_allowsMediaDocumentInlinePlayback { false };
>@@ -2176,7 +2176,7 @@ private:
>     ActivityStateChangeID m_currentActivityStateChangeID { ActivityStateChangeAsynchronous };
> 
>     WebPreferencesStore::ValueMap m_configurationPreferenceValues;
>-    WebCore::ActivityState::Flags m_potentiallyChangedActivityStateFlags { WebCore::ActivityState::NoFlags };
>+    OptionSet<WebCore::ActivityState::Flag> m_potentiallyChangedActivityStateFlags;
>     bool m_activityStateChangeWantsSynchronousReply { false };
>     Vector<CallbackID> m_nextActivityStateChangeCallbacks;
> 
>Index: Source/WebKit/UIProcess/API/C/wpe/WKAPICastWPE.h
>===================================================================
>--- Source/WebKit/UIProcess/API/C/wpe/WKAPICastWPE.h	(revision 234841)
>+++ Source/WebKit/UIProcess/API/C/wpe/WKAPICastWPE.h	(working copy)
>@@ -48,16 +48,16 @@ inline ProxyingRefPtr<WebGrammarDetail> 
>     return ProxyingRefPtr<WebGrammarDetail>(WebGrammarDetail::create(grammarDetail));
> }
> 
>-inline WebCore::ActivityState::Flags toViewStateFlags(WKViewState wkViewState)
>+inline OptionSet<WebCore::ActivityState::Flag> toViewStateFlags(WKViewState wkViewState)
> {
>-    unsigned viewStateFlags = 0;
>+    OptionSet<WebCore::ActivityState::Flag> viewStateFlags;
> 
>     if (wkViewState & kWKViewStateIsInWindow)
>         viewStateFlags |= WebCore::ActivityState::IsInWindow;
>     if (wkViewState & kWKViewStateIsVisible)
>         viewStateFlags |= WebCore::ActivityState::IsVisible;
> 
>-    return static_cast<WebCore::ActivityState::Flags>(viewStateFlags);
>+    return viewStateFlags;
> }
> 
> }
>Index: Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp
>===================================================================
>--- Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp	(revision 234841)
>+++ Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp	(working copy)
>@@ -155,7 +155,7 @@ struct _WebKitWebViewBasePrivate {
>         if (!pageProxy)
>             return;
>         pageProxy->activityStateDidChange(activityStateFlagsToUpdate);
>-        activityStateFlagsToUpdate = ActivityState::NoFlags;
>+        activityStateFlagsToUpdate = { };
>     }
> 
>     WebKitWebViewChildrenMap children;
>@@ -185,8 +185,8 @@ struct _WebKitWebViewBasePrivate {
>     unsigned long toplevelWindowRealizedID { 0 };
> 
>     // View State.
>-    ActivityState::Flags activityState { 0 };
>-    ActivityState::Flags activityStateFlagsToUpdate { 0 };
>+    OptionSet<ActivityState::Flag> activityState;
>+    OptionSet<ActivityState::Flag> activityStateFlagsToUpdate;
>     RunLoop::Timer<WebKitWebViewBasePrivate> updateActivityStateTimer;
> 
> #if ENABLE(FULLSCREEN_API)
>@@ -207,7 +207,7 @@ struct _WebKitWebViewBasePrivate {
> 
> WEBKIT_DEFINE_TYPE(WebKitWebViewBase, webkit_web_view_base, GTK_TYPE_CONTAINER)
> 
>-static void webkitWebViewBaseScheduleUpdateActivityState(WebKitWebViewBase* webViewBase, ActivityState::Flags flagsToUpdate)
>+static void webkitWebViewBaseScheduleUpdateActivityState(WebKitWebViewBase* webViewBase, OptionSet<ActivityState::Flag> flagsToUpdate)
> {
>     WebKitWebViewBasePrivate* priv = webViewBase->priv;
>     priv->activityStateFlagsToUpdate |= flagsToUpdate;
>@@ -239,7 +239,7 @@ static gboolean toplevelWindowFocusOutEv
>     if (!(priv->activityState & ActivityState::WindowIsActive))
>         return FALSE;
> 
>-    priv->activityState &= ~ActivityState::WindowIsActive;
>+    priv->activityState -= ActivityState::WindowIsActive;
>     webkitWebViewBaseScheduleUpdateActivityState(webViewBase, ActivityState::WindowIsActive);
> 
>     return FALSE;
>@@ -258,7 +258,7 @@ static gboolean toplevelWindowStateEvent
>     if (visible)
>         priv->activityState |= ActivityState::IsVisible;
>     else
>-        priv->activityState &= ~ActivityState::IsVisible;
>+        priv->activityState -= ActivityState::IsVisible;
>     webkitWebViewBaseScheduleUpdateActivityState(webViewBase, ActivityState::IsVisible);
> 
>     return FALSE;
>@@ -301,13 +301,13 @@ static void webkitWebViewBaseSetToplevel
>     priv->toplevelOnScreenWindow = window;
> 
>     if (!priv->toplevelOnScreenWindow) {
>-        ActivityState::Flags flagsToUpdate = 0;
>+        OptionSet<ActivityState::Flag> flagsToUpdate;
>         if (priv->activityState & ActivityState::IsInWindow) {
>-            priv->activityState &= ~ActivityState::IsInWindow;
>+            priv->activityState -= ActivityState::IsInWindow;
>             flagsToUpdate |= ActivityState::IsInWindow;
>         }
>         if (priv->activityState & ActivityState::WindowIsActive) {
>-            priv->activityState &= ~ActivityState::WindowIsActive;
>+            priv->activityState -= ActivityState::WindowIsActive;
>             flagsToUpdate |= ActivityState::IsInWindow;
>         }
>         if (flagsToUpdate)
>@@ -624,7 +624,7 @@ static void webkitWebViewBaseMap(GtkWidg
> 
>     WebKitWebViewBase* webViewBase = WEBKIT_WEB_VIEW_BASE(widget);
>     WebKitWebViewBasePrivate* priv = webViewBase->priv;
>-    ActivityState::Flags flagsToUpdate = 0;
>+    OptionSet<ActivityState::Flag> flagsToUpdate;
>     if (!(priv->activityState & ActivityState::IsVisible))
>         flagsToUpdate |= ActivityState::IsVisible;
>     if (priv->toplevelOnScreenWindow) {
>@@ -649,7 +649,7 @@ static void webkitWebViewBaseUnmap(GtkWi
>     if (!(priv->activityState & ActivityState::IsVisible))
>         return;
> 
>-    priv->activityState &= ~ActivityState::IsVisible;
>+    priv->activityState -= ActivityState::IsVisible;
>     webkitWebViewBaseScheduleUpdateActivityState(webViewBase, ActivityState::IsVisible);
> }
> 
>@@ -1493,7 +1493,7 @@ void webkitWebViewBaseSetFocus(WebKitWeb
>     if ((focused && priv->activityState & ActivityState::IsFocused) || (!focused && !(priv->activityState & ActivityState::IsFocused)))
>         return;
> 
>-    ActivityState::Flags flagsToUpdate = ActivityState::IsFocused;
>+    OptionSet<ActivityState::Flag> flagsToUpdate { ActivityState::IsFocused };
>     if (focused) {
>         priv->activityState |= ActivityState::IsFocused;
> 
>@@ -1507,29 +1507,29 @@ void webkitWebViewBaseSetFocus(WebKitWeb
>             flagsToUpdate |= ActivityState::WindowIsActive;
>         }
>     } else
>-        priv->activityState &= ~ActivityState::IsFocused;
>+        priv->activityState -= ActivityState::IsFocused;
> 
>     webkitWebViewBaseScheduleUpdateActivityState(webViewBase, flagsToUpdate);
> }
> 
> bool webkitWebViewBaseIsInWindowActive(WebKitWebViewBase* webViewBase)
> {
>-    return webViewBase->priv->activityState & ActivityState::WindowIsActive;
>+    return webViewBase->priv->activityState.contains(ActivityState::WindowIsActive);
> }
> 
> bool webkitWebViewBaseIsFocused(WebKitWebViewBase* webViewBase)
> {
>-    return webViewBase->priv->activityState & ActivityState::IsFocused;
>+    return webViewBase->priv->activityState.contains(ActivityState::IsFocused);
> }
> 
> bool webkitWebViewBaseIsVisible(WebKitWebViewBase* webViewBase)
> {
>-    return webViewBase->priv->activityState & ActivityState::IsVisible;
>+    return webViewBase->priv->activityState.contains(ActivityState::IsVisible);
> }
> 
> bool webkitWebViewBaseIsInWindow(WebKitWebViewBase* webViewBase)
> {
>-    return webViewBase->priv->activityState & ActivityState::IsInWindow;
>+    return webViewBase->priv->activityState.contains(ActivityState::IsInWindow);
> }
> 
> void webkitWebViewBaseSetInputMethodState(WebKitWebViewBase* webkitWebViewBase, bool enabled)
>Index: Source/WebKit/UIProcess/API/wpe/WPEView.cpp
>===================================================================
>--- Source/WebKit/UIProcess/API/wpe/WPEView.cpp	(revision 234841)
>+++ Source/WebKit/UIProcess/API/wpe/WPEView.cpp	(working copy)
>@@ -172,11 +172,11 @@ void View::setSize(const WebCore::IntSiz
>         m_pageProxy->drawingArea()->setSize(size);
> }
> 
>-void View::setViewState(WebCore::ActivityState::Flags flags)
>+void View::setViewState(OptionSet<WebCore::ActivityState::Flag> flags)
> {
>-    static const WebCore::ActivityState::Flags defaultFlags = WebCore::ActivityState::WindowIsActive | WebCore::ActivityState::IsFocused;
>+    static const OptionSet<WebCore::ActivityState::Flag> defaultFlags { WebCore::ActivityState::WindowIsActive, WebCore::ActivityState::IsFocused };
> 
>-    WebCore::ActivityState::Flags changedFlags = m_viewStateFlags ^ (defaultFlags | flags);
>+    auto = m_viewStateFlags ^ (defaultFlags | flags);
>     m_viewStateFlags = defaultFlags | flags;
> 
>     if (changedFlags)
>Index: Source/WebKit/UIProcess/API/wpe/WPEView.h
>===================================================================
>--- Source/WebKit/UIProcess/API/wpe/WPEView.h	(revision 234841)
>+++ Source/WebKit/UIProcess/API/wpe/WPEView.h	(working copy)
>@@ -67,8 +67,8 @@ public:
> 
>     const WebCore::IntSize& size() const { return m_size; }
> 
>-    WebCore::ActivityState::Flags viewState() const { return m_viewStateFlags; }
>-    void setViewState(WebCore::ActivityState::Flags);
>+    OptionSet<WebCore::ActivityState::Flag> viewState() const { return m_viewStateFlags; }
>+    void setViewState(OptionSet<WebCore::ActivityState::Flag>);
> 
>     void close();
> 
>@@ -87,7 +87,7 @@ private:
>     std::unique_ptr<WebKit::PageClientImpl> m_pageClient;
>     RefPtr<WebKit::WebPageProxy> m_pageProxy;
>     WebCore::IntSize m_size;
>-    WebCore::ActivityState::Flags m_viewStateFlags;
>+    OptionSet<WebCore::ActivityState::Flag> m_viewStateFlags;
> 
>     WebKit::CompositingManagerProxy m_compositingManagerProxy;
>     struct wpe_view_backend* m_backend;
>Index: Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm
>===================================================================
>--- Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm	(revision 234841)
>+++ Source/WebKit/UIProcess/Cocoa/WebViewImpl.mm	(working copy)
>@@ -1892,13 +1892,13 @@ float WebViewImpl::intrinsicDeviceScaleF
> void WebViewImpl::windowDidOrderOffScreen()
> {
>     LOG(ActivityState, "WebViewImpl %p (page %llu) windowDidOrderOffScreen", this, m_page->pageID());
>-    m_page->activityStateDidChange(WebCore::ActivityState::IsVisible | WebCore::ActivityState::WindowIsActive);
>+    m_page->activityStateDidChange({ WebCore::ActivityState::IsVisible, WebCore::ActivityState::WindowIsActive });
> }
> 
> void WebViewImpl::windowDidOrderOnScreen()
> {
>     LOG(ActivityState, "WebViewImpl %p (page %llu) windowDidOrderOnScreen", this, m_page->pageID());
>-    m_page->activityStateDidChange(WebCore::ActivityState::IsVisible | WebCore::ActivityState::WindowIsActive);
>+    m_page->activityStateDidChange({ WebCore::ActivityState::IsVisible, WebCore::ActivityState::WindowIsActive });
> }
> 
> void WebViewImpl::windowDidBecomeKey(NSWindow *keyWindow)
>@@ -2064,7 +2064,7 @@ void WebViewImpl::viewDidMoveToWindow()
>     if (window) {
>         windowDidChangeScreen();
> 
>-        WebCore::ActivityState::Flags activityStateChanges = WebCore::ActivityState::WindowIsActive | WebCore::ActivityState::IsVisible;
>+        OptionSet<WebCore::ActivityState::Flag> activityStateChanges { WebCore::ActivityState::WindowIsActive, WebCore::ActivityState::IsVisible };
>         if (m_shouldDeferViewInWindowChanges)
>             m_viewInWindowChangeWasDeferred = true;
>         else
>@@ -2090,7 +2090,7 @@ void WebViewImpl::viewDidMoveToWindow()
>         if (m_immediateActionGestureRecognizer && ![[m_view gestureRecognizers] containsObject:m_immediateActionGestureRecognizer.get()] && !m_ignoresNonWheelEvents && m_allowsLinkPreview)
>             [m_view addGestureRecognizer:m_immediateActionGestureRecognizer.get()];
>     } else {
>-        WebCore::ActivityState::Flags activityStateChanges = WebCore::ActivityState::WindowIsActive | WebCore::ActivityState::IsVisible;
>+        OptionSet<WebCore::ActivityState::Flag> activityStateChanges { WebCore::ActivityState::WindowIsActive, WebCore::ActivityState::IsVisible };
>         if (m_shouldDeferViewInWindowChanges)
>             m_viewInWindowChangeWasDeferred = true;
>         else
>Index: Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm
>===================================================================
>--- Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm	(revision 234841)
>+++ Source/WebKit/UIProcess/ios/WKApplicationStateTrackingView.mm	(working copy)
>@@ -73,7 +73,7 @@ - (void)_applicationDidEnterBackground
>         return;
> 
>     page->applicationDidEnterBackground();
>-    page->activityStateDidChange(WebCore::ActivityState::AllFlags & ~WebCore::ActivityState::IsInWindow);
>+    page->activityStateDidChange(WebCore::ActivityState::allFlags() - WebCore::ActivityState::IsInWindow);
> }
> 
> - (void)_applicationDidFinishSnapshottingAfterEnteringBackground
>@@ -89,7 +89,7 @@ - (void)_applicationWillEnterForeground
>         return;
> 
>     page->applicationWillEnterForeground();
>-    page->activityStateDidChange(WebCore::ActivityState::AllFlags & ~WebCore::ActivityState::IsInWindow, true, WebKit::WebPageProxy::ActivityStateChangeDispatchMode::Immediate);
>+    page->activityStateDidChange(WebCore::ActivityState::allFlags() - WebCore::ActivityState::IsInWindow, true, WebKit::WebPageProxy::ActivityStateChangeDispatchMode::Immediate);
> }
> 
> - (BOOL)isBackground
>Index: Source/WebKit/WebProcess/WebProcess.cpp
>===================================================================
>--- Source/WebKit/WebProcess/WebProcess.cpp	(revision 234841)
>+++ Source/WebKit/WebProcess/WebProcess.cpp	(working copy)
>@@ -1373,7 +1373,7 @@ void WebProcess::updateCPUMonitorState(C
> 
> #endif
> 
>-void WebProcess::pageActivityStateDidChange(uint64_t, WebCore::ActivityState::Flags changed)
>+void WebProcess::pageActivityStateDidChange(uint64_t, OptionSet<WebCore::ActivityState::Flag> changed)
> {
>     if (changed & WebCore::ActivityState::IsVisible)
>         updateCPUMonitorState(CPUMonitorUpdateReason::VisibilityHasChanged);
>Index: Source/WebKit/WebProcess/WebProcess.h
>===================================================================
>--- Source/WebKit/WebProcess/WebProcess.h	(revision 234841)
>+++ Source/WebKit/WebProcess/WebProcess.h	(working copy)
>@@ -194,7 +194,7 @@ public:
> #endif
> 
>     void updateActivePages();
>-    void pageActivityStateDidChange(uint64_t pageID, WebCore::ActivityState::Flags changed);
>+    void pageActivityStateDidChange(uint64_t pageID, OptionSet<WebCore::ActivityState::Flag> changed);
> 
>     void setHiddenPageDOMTimerThrottlingIncreaseLimit(int milliseconds);
> 
>Index: Source/WebKit/WebProcess/Plugins/PluginView.cpp
>===================================================================
>--- Source/WebKit/WebProcess/Plugins/PluginView.cpp	(revision 234841)
>+++ Source/WebKit/WebProcess/Plugins/PluginView.cpp	(working copy)
>@@ -515,7 +515,7 @@ void PluginView::webPageDestroyed()
>     m_webPage = 0;
> }
> 
>-void PluginView::activityStateDidChange(ActivityState::Flags changed)
>+void PluginView::activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> changed)
> {
>     if (!m_plugin || !m_isInitialized)
>         return;
>Index: Source/WebKit/WebProcess/Plugins/PluginView.h
>===================================================================
>--- Source/WebKit/WebProcess/Plugins/PluginView.h	(revision 234841)
>+++ Source/WebKit/WebProcess/Plugins/PluginView.h	(working copy)
>@@ -79,7 +79,7 @@ public:
>     void manualLoadDidFinishLoading();
>     void manualLoadDidFail(const WebCore::ResourceError&);
> 
>-    void activityStateDidChange(WebCore::ActivityState::Flags changed);
>+    void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> changed);
>     void setLayerHostingMode(LayerHostingMode);
> 
> #if PLATFORM(COCOA)
>Index: Source/WebKit/WebProcess/WebPage/AcceleratedDrawingArea.cpp
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/AcceleratedDrawingArea.cpp	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/AcceleratedDrawingArea.cpp	(working copy)
>@@ -455,7 +455,7 @@ void AcceleratedDrawingArea::deviceOrPag
> }
> #endif
> 
>-void AcceleratedDrawingArea::activityStateDidChange(ActivityState::Flags changed, ActivityStateChangeID, const Vector<CallbackID>&)
>+void AcceleratedDrawingArea::activityStateDidChange(OptionSet<ActivityState::Flag> changed, ActivityStateChangeID, const Vector<CallbackID>&)
> {
>     if (changed & ActivityState::IsVisible) {
>         if (m_webPage.isVisible())
>Index: Source/WebKit/WebProcess/WebPage/AcceleratedDrawingArea.h
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/AcceleratedDrawingArea.h	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/AcceleratedDrawingArea.h	(working copy)
>@@ -68,7 +68,7 @@ protected:
>     void destroyNativeSurfaceHandleForCompositing(bool&) override;
> #endif
> 
>-    void activityStateDidChange(WebCore::ActivityState::Flags, ActivityStateChangeID, const Vector<CallbackID>& /* callbackIDs */) override;
>+    void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag>, ActivityStateChangeID, const Vector<CallbackID>& /* callbackIDs */) override;
>     void attachViewOverlayGraphicsLayer(WebCore::Frame*, WebCore::GraphicsLayer*) override;
> 
>     void layerHostDidFlushLayers() override;
>Index: Source/WebKit/WebProcess/WebPage/DrawingArea.h
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/DrawingArea.h	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/DrawingArea.h	(working copy)
>@@ -119,7 +119,7 @@ public:
> 
>     virtual void dispatchAfterEnsuringUpdatedScrollPosition(WTF::Function<void ()>&&);
> 
>-    virtual void activityStateDidChange(WebCore::ActivityState::Flags, ActivityStateChangeID, const Vector<CallbackID>&) { }
>+    virtual void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag>, ActivityStateChangeID, const Vector<CallbackID>&) { }
>     virtual void setLayerHostingMode(LayerHostingMode) { }
> 
>     virtual bool markLayersVolatileImmediatelyIfPossible() { return true; }
>Index: Source/WebKit/WebProcess/WebPage/WebPage.cpp
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/WebPage.cpp	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/WebPage.cpp	(working copy)
>@@ -663,13 +663,9 @@ void WebPage::reinitializeWebPage(WebPag
> 
> void WebPage::updateThrottleState()
> {
>-    // We should suppress if the page is not active, is visually idle, and supression is enabled.
>-    bool isLoading = m_activityState & ActivityState::IsLoading;
>-    bool isPlayingAudio = m_activityState & ActivityState::IsAudible;
>-    bool isCapturingMedia = m_activityState & ActivityState::IsCapturingMedia;
>-    bool isVisuallyIdle = m_activityState & ActivityState::IsVisuallyIdle;
>-    bool windowIsActive = m_activityState & ActivityState::WindowIsActive;
>-    bool pageSuppressed = !windowIsActive && !isLoading && !isPlayingAudio && !isCapturingMedia && m_processSuppressionEnabled && isVisuallyIdle;
>+    bool isActive = m_activityState.containsAny({ ActivityState::IsLoading, ActivityState::IsAudible, ActivityState::IsCapturingMedia, ActivityState::WindowIsActive });
>+    bool isVisuallyIdle = m_activityState.contains(ActivityState::IsVisuallyIdle);
>+    bool pageSuppressed = m_processSuppressionEnabled && !isActive && isVisuallyIdle;
> 
> #if PLATFORM(MAC) && ENABLE(WEBPROCESS_WINDOWSERVER_BLOCKING)
>     if (!pageSuppressed) {
>@@ -2760,7 +2756,7 @@ void WebPage::setCanStartMediaTimerFired
> 
> void WebPage::updateIsInWindow(bool isInitialState)
> {
>-    bool isInWindow = m_activityState & WebCore::ActivityState::IsInWindow;
>+    bool isInWindow = m_activityState.contains(WebCore::ActivityState::IsInWindow);
> 
>     if (!isInWindow) {
>         m_setCanStartMediaTimer.stop();
>@@ -2785,7 +2781,7 @@ void WebPage::updateIsInWindow(bool isIn
> 
> void WebPage::visibilityDidChange()
> {
>-    bool isVisible = m_activityState & ActivityState::IsVisible;
>+    bool isVisible = m_activityState.contains(ActivityState::IsVisible);
>     if (!isVisible) {
>         // We save the document / scroll state when backgrounding a tab so that we are able to restore it
>         // if it gets terminated while in the background.
>@@ -2794,11 +2790,11 @@ void WebPage::visibilityDidChange()
>     }
> }
> 
>-void WebPage::setActivityState(ActivityState::Flags activityState, ActivityStateChangeID activityStateChangeID, const Vector<CallbackID>& callbackIDs)
>+void WebPage::setActivityState(OptionSet<ActivityState::Flag> activityState, ActivityStateChangeID activityStateChangeID, const Vector<CallbackID>& callbackIDs)
> {
>-    LOG_WITH_STREAM(ActivityState, stream << "WebPage " << pageID() << " setActivityState to " << activityStateFlagsToString(activityState));
>+    LOG_WITH_STREAM(ActivityState, stream << "WebPage " << pageID() << " setActivityState to " << activityState);
> 
>-    ActivityState::Flags changed = m_activityState ^ activityState;
>+    auto changed = m_activityState ^ activityState;
>     m_activityState = activityState;
> 
>     if (changed)
>Index: Source/WebKit/WebProcess/WebPage/WebPage.h
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/WebPage.h	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/WebPage.h	(working copy)
>@@ -498,8 +498,8 @@ public:
>     void addPluginView(PluginView*);
>     void removePluginView(PluginView*);
> 
>-    bool isVisible() const { return m_activityState & WebCore::ActivityState::IsVisible; }
>-    bool isVisibleOrOccluded() const { return m_activityState & WebCore::ActivityState::IsVisibleOrOccluded; }
>+    bool isVisible() const { return m_activityState.contains(WebCore::ActivityState::IsVisible); }
>+    bool isVisibleOrOccluded() const { return m_activityState.contains(WebCore::ActivityState::IsVisibleOrOccluded); }
> 
>     LayerHostingMode layerHostingMode() const { return m_layerHostingMode; }
>     void setLayerHostingMode(LayerHostingMode);
>@@ -1171,7 +1171,7 @@ private:
>     void setInitialFocus(bool forward, bool isKeyboardEventValid, const WebKeyboardEvent&, CallbackID);
>     void updateIsInWindow(bool isInitialState = false);
>     void visibilityDidChange();
>-    void setActivityState(WebCore::ActivityState::Flags, ActivityStateChangeID, const Vector<CallbackID>& callbackIDs);
>+    void setActivityState(OptionSet<WebCore::ActivityState::Flag>, ActivityStateChangeID, const Vector<CallbackID>& callbackIDs);
>     void validateCommand(const String&, CallbackID);
>     void executeEditCommand(const String&, const String&);
>     void setEditable(bool);
>@@ -1689,7 +1689,7 @@ private:
> 
>     bool m_useAsyncScrolling { false };
> 
>-    WebCore::ActivityState::Flags m_activityState;
>+    OptionSet<WebCore::ActivityState::Flag> m_activityState;
> 
>     bool m_processSuppressionEnabled;
>     UserActivity m_userActivity;
>Index: Source/WebKit/WebProcess/WebPage/WebPage.messages.in
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/WebPage.messages.in	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/WebPage.messages.in	(working copy)
>@@ -22,7 +22,7 @@
> 
> messages -> WebPage LegacyReceiver {
>     SetInitialFocus(bool forward, bool isKeyboardEventValid, WebKit::WebKeyboardEvent event, WebKit::CallbackID callbackID)
>-    SetActivityState(unsigned activityState, WebKit::ActivityStateChangeID activityStateChangeID, Vector<WebKit::CallbackID> callbackIDs)
>+    SetActivityState(OptionSet<WebCore::ActivityState::Flag> activityState, WebKit::ActivityStateChangeID activityStateChangeID, Vector<WebKit::CallbackID> callbackIDs)
>     SetLayerHostingMode(enum WebKit::LayerHostingMode layerHostingMode)
> 
>     SetDrawsBackground(bool drawsBackground)
>Index: Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.h	(working copy)
>@@ -102,7 +102,7 @@ private:
> 
>     void mainFrameContentSizeChanged(const WebCore::IntSize&) override;
> 
>-    void activityStateDidChange(WebCore::ActivityState::Flags changed, ActivityStateChangeID, const Vector<CallbackID>& callbackIDs) override;
>+    void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> changed, ActivityStateChangeID, const Vector<CallbackID>& callbackIDs) override;
> 
>     bool adjustLayerFlushThrottling(WebCore::LayerFlushThrottleState::Flags) override;
> 
>Index: Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/RemoteLayerTree/RemoteLayerTreeDrawingArea.mm	(working copy)
>@@ -488,7 +488,7 @@ void RemoteLayerTreeDrawingArea::Backing
>     m_connection->sendMessage(WTFMove(m_commitEncoder), { });
> }
> 
>-void RemoteLayerTreeDrawingArea::activityStateDidChange(ActivityState::Flags, ActivityStateChangeID activityStateChangeID, const Vector<CallbackID>&)
>+void RemoteLayerTreeDrawingArea::activityStateDidChange(OptionSet<WebCore::ActivityState::Flag>, ActivityStateChangeID activityStateChangeID, const Vector<CallbackID>&)
> {
>     // FIXME: Should we suspend painting while not visible, like TiledCoreAnimationDrawingArea? Probably.
> 
>Index: Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.h	(working copy)
>@@ -81,7 +81,7 @@ private:
> 
>     bool shouldUseTiledBackingForFrameView(const WebCore::FrameView&) override;
> 
>-    void activityStateDidChange(WebCore::ActivityState::Flags changed, ActivityStateChangeID, const Vector<CallbackID>&) override;
>+    void activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> changed, ActivityStateChangeID, const Vector<CallbackID>&) override;
>     void didUpdateActivityStateTimerFired();
> 
>     void attachViewOverlayGraphicsLayer(WebCore::Frame*, WebCore::GraphicsLayer*) override;
>Index: Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm
>===================================================================
>--- Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm	(revision 234841)
>+++ Source/WebKit/WebProcess/WebPage/mac/TiledCoreAnimationDrawingArea.mm	(working copy)
>@@ -468,7 +468,7 @@ bool TiledCoreAnimationDrawingArea::flus
>     }
> }
> 
>-void TiledCoreAnimationDrawingArea::activityStateDidChange(ActivityState::Flags changed, ActivityStateChangeID activityStateChangeID, const Vector<CallbackID>& nextActivityStateChangeCallbackIDs)
>+void TiledCoreAnimationDrawingArea::activityStateDidChange(OptionSet<WebCore::ActivityState::Flag> changed, ActivityStateChangeID activityStateChangeID, const Vector<CallbackID>& nextActivityStateChangeCallbackIDs)
> {
>     m_nextActivityStateChangeCallbackIDs.appendVector(nextActivityStateChangeCallbackIDs);
>     m_activityStateChangeID = std::max(m_activityStateChangeID, activityStateChangeID);
>Index: Tools/ChangeLog
>===================================================================
>--- Tools/ChangeLog	(revision 234848)
>+++ Tools/ChangeLog	(working copy)
>@@ -1,3 +1,13 @@
>+2018-08-14  Antti Koivisto  <antti@apple.com>
>+
>+        Use OptionSet for ActivityState::Flags
>+        https://bugs.webkit.org/show_bug.cgi?id=188554
>+
>+        Reviewed by Brent Fulgham.
>+
>+        * TestWebKitAPI/Tests/WTF/OptionSet.cpp:
>+        (TestWebKitAPI::TEST):
>+
> 2018-08-14  Zalan Bujtas  <zalan@apple.com>
> 
>         [LFC][Floating] Adjust vertical position with non-collapsing previous sibling margin.
>Index: Tools/TestWebKitAPI/Tests/WTF/OptionSet.cpp
>===================================================================
>--- Tools/TestWebKitAPI/Tests/WTF/OptionSet.cpp	(revision 234841)
>+++ Tools/TestWebKitAPI/Tests/WTF/OptionSet.cpp	(working copy)
>@@ -379,6 +379,31 @@ TEST(WTF_OptionSet, OperatorAnd)
>     }
> }
> 
>+TEST(WTF_OptionSet, OperatorXor)
>+{
>+    OptionSet<ExampleFlags> a { ExampleFlags::A };
>+    OptionSet<ExampleFlags> ac { ExampleFlags::A, ExampleFlags::C };
>+    OptionSet<ExampleFlags> bc { ExampleFlags::B, ExampleFlags::C };
>+    {
>+        auto set = a ^ ac;
>+        EXPECT_FALSE(set.contains(ExampleFlags::A));
>+        EXPECT_FALSE(set.contains(ExampleFlags::B));
>+        EXPECT_TRUE(set.contains(ExampleFlags::C));
>+    }
>+    {
>+        auto set = a ^ bc;
>+        EXPECT_TRUE(set.contains(ExampleFlags::A));
>+        EXPECT_TRUE(set.contains(ExampleFlags::B));
>+        EXPECT_TRUE(set.contains(ExampleFlags::C));
>+    }
>+    {
>+        auto set = ac ^ bc;
>+        EXPECT_TRUE(set.contains(ExampleFlags::A));
>+        EXPECT_TRUE(set.contains(ExampleFlags::B));
>+        EXPECT_FALSE(set.contains(ExampleFlags::C));
>+    }
>+}
>+
> TEST(WTF_OptionSet, ContainsAny)
> {
>     OptionSet<ExampleFlags> set { ExampleFlags::A, ExampleFlags::B };

Actions: View | Formatted Diff | Diff

Attachments on bug 188554: 347081 | 347153 | 347157 | 347204