Make all ScriptWrappable IsoHeap-ed
[WebKit-https.git] / Source / WebCore / dom / Event.h
index 89bb87c..1bc7255 100644 (file)
@@ -30,7 +30,7 @@
 #include "ScriptWrappable.h"
 #include <wtf/MonotonicTime.h>
 #include <wtf/TypeCasts.h>
-#include <wtf/text/AtomicString.h>
+#include <wtf/text/AtomString.h>
 
 namespace WebCore {
 
@@ -39,30 +39,32 @@ class EventTarget;
 class ScriptExecutionContext;
 
 class Event : public ScriptWrappable, public RefCounted<Event> {
+    WTF_MAKE_ISO_ALLOCATED(Event);
 public:
     enum class IsTrusted : uint8_t { No, Yes };
     enum class CanBubble : uint8_t { No, Yes };
     enum class IsCancelable : uint8_t { No, Yes };
+    enum class IsComposed : uint8_t { No, Yes };
 
-    enum PhaseType 
+    enum PhaseType : uint8_t {
         NONE = 0,
         CAPTURING_PHASE = 1,
         AT_TARGET = 2,
         BUBBLING_PHASE = 3
     };
 
-    WEBCORE_EXPORT static Ref<Event> create(const AtomicString& type, CanBubble, IsCancelable);
+    WEBCORE_EXPORT static Ref<Event> create(const AtomString& type, CanBubble, IsCancelable, IsComposed = IsComposed::No);
     static Ref<Event> createForBindings();
-    static Ref<Event> create(const AtomicString& type, const EventInit&, IsTrusted = IsTrusted::No);
+    static Ref<Event> create(const AtomString& type, const EventInit&, IsTrusted = IsTrusted::No);
 
     virtual ~Event();
 
-    WEBCORE_EXPORT void initEvent(const AtomicString& type, bool canBubble, bool cancelable);
+    WEBCORE_EXPORT void initEvent(const AtomString& type, bool canBubble, bool cancelable);
 
     bool isInitialized() const { return m_isInitialized; }
 
-    const AtomicString& type() const { return m_type; }
-    void setType(const AtomicString& type) { m_type = type; }
+    const AtomString& type() const { return m_type; }
+    void setType(const AtomString& type) { m_type = type; }
     
     EventTarget* target() const { return m_target.get(); }
     void setTarget(RefPtr<EventTarget>&&);
@@ -75,7 +77,7 @@ public:
 
     bool bubbles() const { return m_canBubble; }
     bool cancelable() const { return m_cancelable; }
-    WEBCORE_EXPORT bool composed() const;
+    bool composed() const { return m_composed; }
 
     DOMHighResTimeStamp timeStampForBindings(ScriptExecutionContext&) const;
     MonotonicTime timeStamp() const { return m_createTime; }
@@ -103,6 +105,7 @@ public:
     virtual bool isInputEvent() const { return false; }
     virtual bool isKeyboardEvent() const { return false; }
     virtual bool isMouseEvent() const { return false; }
+    virtual bool isPointerEvent() const { return false; }
     virtual bool isTextEvent() const { return false; }
     virtual bool isTouchEvent() const { return false; }
     virtual bool isUIEvent() const { return false; }
@@ -141,31 +144,34 @@ public:
 
 protected:
     explicit Event(IsTrusted = IsTrusted::No);
-    Event(const AtomicString& type, CanBubble, IsCancelable);
-    Event(const AtomicString& type, CanBubble, IsCancelable, MonotonicTime timestamp);
-    Event(const AtomicString& type, const EventInit&, IsTrusted);
+    Event(const AtomString& type, CanBubble, IsCancelable, IsComposed = IsComposed::No);
+    Event(const AtomString& type, CanBubble, IsCancelable, IsComposed, MonotonicTime timestamp, IsTrusted isTrusted = IsTrusted::Yes);
+    Event(const AtomString& type, const EventInit&, IsTrusted);
 
     virtual void receivedTarget() { }
 
 private:
-    AtomicString m_type;
+    explicit Event(MonotonicTime createTime, const AtomString& type, IsTrusted, CanBubble, IsCancelable, IsComposed);
 
     void setCanceledFlagIfPossible();
 
-    bool m_isInitialized { false };
-    bool m_canBubble { false };
-    bool m_cancelable { false };
-    bool m_composed { false };
+    unsigned m_isInitialized : 1;
+    unsigned m_canBubble : 1;
+    unsigned m_cancelable : 1;
+    unsigned m_composed : 1;
 
-    bool m_propagationStopped { false };
-    bool m_immediatePropagationStopped { false };
-    bool m_wasCanceled { false };
-    bool m_defaultHandled { false };
-    bool m_isDefaultEventHandlerIgnored { false };
-    bool m_isTrusted { false };
-    bool m_isExecutingPassiveEventListener { false };
+    unsigned m_propagationStopped : 1;
+    unsigned m_immediatePropagationStopped : 1;
+    unsigned m_wasCanceled : 1;
+    unsigned m_defaultHandled : 1;
+    unsigned m_isDefaultEventHandlerIgnored : 1;
+    unsigned m_isTrusted : 1;
+    unsigned m_isExecutingPassiveEventListener : 1;
+
+    unsigned m_eventPhase : 2;
+
+    AtomString m_type;
 
-    PhaseType m_eventPhase { NONE };
     RefPtr<EventTarget> m_currentTarget;
     const EventPath* m_eventPath { nullptr };
     RefPtr<EventTarget> m_target;