Source code

Revision control

Copy as Markdown

Other Tools

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at */
#ifndef mozilla_dom_Event_h_
#define mozilla_dom_Event_h_
#include <cstdint>
#include "Units.h"
#include "js/TypeDecls.h"
#include "mozilla/AlreadyAddRefed.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/BasicEvents.h"
#include "mozilla/RefPtr.h"
#include "mozilla/Maybe.h"
#include "mozilla/dom/BindingDeclarations.h"
#include "nsCOMPtr.h"
#include "nsCycleCollectionParticipant.h"
#include "nsID.h"
#include "nsISupports.h"
#include "nsStringFwd.h"
#include "nsWrapperCache.h"
class PickleIterator;
class nsCycleCollectionTraversalCallback;
class nsIContent;
class nsIGlobalObject;
class nsIPrincipal;
class nsPIDOMWindowInner;
class nsPresContext;
namespace IPC {
class Message;
class MessageReader;
class MessageWriter;
} // namespace IPC
namespace mozilla::dom {
class BeforeUnloadEvent;
class CustomEvent;
class Document;
class DragEvent;
class EventTarget;
class EventMessageAutoOverride;
// ExtendableEvent is a ServiceWorker event that is not
// autogenerated since it has some extra methods.
class ExtendableEvent;
class KeyboardEvent;
class MouseEvent;
class MessageEvent;
class TimeEvent;
class UIEvent;
class WantsPopupControlCheck;
class XULCommandEvent;
struct EventInit;
#define GENERATED_EVENT(EventClass_) class EventClass_;
#include "mozilla/dom/GeneratedEventList.h"
// IID for Event
#define NS_EVENT_IID \
{ \
0x71139716, 0x4d91, 0x4dee, { \
0xba, 0xf9, 0xe3, 0x3b, 0x80, 0xc1, 0x61, 0x61 \
} \
class Event : public nsISupports, public nsWrapperCache {
Event(EventTarget* aOwner, nsPresContext* aPresContext, WidgetEvent* aEvent);
explicit Event(nsPIDOMWindowInner* aWindow);
virtual ~Event();
void ConstructorInit(EventTarget* aOwner, nsPresContext* aPresContext,
WidgetEvent* aEvent);
void UpdateDefaultPreventedOnContentForDragEvent();
nsIGlobalObject* GetParentObject() const { return mOwner; }
JSObject* WrapObject(JSContext* aCx, JS::Handle<JSObject*> aGivenProto) final;
virtual JSObject* WrapObjectInternal(JSContext* aCx,
JS::Handle<JSObject*> aGivenProto);
#define GENERATED_EVENT(EventClass_) \
virtual EventClass_* As##EventClass_() { return nullptr; }
#include "mozilla/dom/GeneratedEventList.h"
// ExtendableEvent is a ServiceWorker event that is not
// autogenerated since it has some extra methods.
virtual ExtendableEvent* AsExtendableEvent() { return nullptr; }
virtual TimeEvent* AsTimeEvent() { return nullptr; }
// BeforeUnloadEvent is not autogenerated because it has a setter.
virtual BeforeUnloadEvent* AsBeforeUnloadEvent() { return nullptr; }
// KeyboardEvent has all sorts of non-autogeneratable bits so far.
virtual KeyboardEvent* AsKeyboardEvent() { return nullptr; }
// DragEvent has a non-autogeneratable initDragEvent.
virtual DragEvent* AsDragEvent() { return nullptr; }
// XULCommandEvent has a non-autogeneratable initCommandEvent.
virtual XULCommandEvent* AsXULCommandEvent() { return nullptr; }
// MouseEvent has a non-autogeneratable initMouseEvent and other
// non-autogeneratable methods.
virtual MouseEvent* AsMouseEvent() { return nullptr; }
// UIEvent has a non-autogeneratable initUIEvent.
virtual UIEvent* AsUIEvent() { return nullptr; }
// CustomEvent has a non-autogeneratable initCustomEvent.
virtual CustomEvent* AsCustomEvent() { return nullptr; }
// MessageEvent has a non-autogeneratable initMessageEvent and more.
virtual MessageEvent* AsMessageEvent() { return nullptr; }
void InitEvent(const nsAString& aEventTypeArg, bool aCanBubble,
bool aCancelable) {
InitEvent(aEventTypeArg, aCanBubble ? CanBubble::eYes : CanBubble::eNo,
aCancelable ? Cancelable::eYes : Cancelable::eNo);
void InitEvent(const nsAString& aEventTypeArg, mozilla::CanBubble,
mozilla::Composed = mozilla::Composed::eDefault);
void SetTarget(EventTarget* aTarget);
virtual void DuplicatePrivateData();
bool IsDispatchStopped();
WidgetEvent* WidgetEventPtr();
const WidgetEvent* WidgetEventPtr() const {
return const_cast<Event*>(this)->WidgetEventPtr();
virtual void Serialize(IPC::MessageWriter* aWriter,
bool aSerializeInterfaceType);
virtual bool Deserialize(IPC::MessageReader* aReader);
void SetOwner(EventTarget* aOwner);
void StopCrossProcessForwarding();
void SetTrusted(bool aTrusted);
// When listening to chrome EventTargets, in the parent process, nsWindowRoot
// might receive events we've already handled via
// InProcessBrowserChildMessageManager, and handlers should call this to avoid
// handling the same event twice.
bool ShouldIgnoreChromeEventTargetListener() const;
void InitPresContextData(nsPresContext* aPresContext);
// Returns true if the event should be trusted.
bool Init(EventTarget* aGlobal);
static const char16_t* GetEventName(EventMessage aEventType);
static CSSIntPoint GetClientCoords(nsPresContext* aPresContext,
WidgetEvent* aEvent,
LayoutDeviceIntPoint aPoint,
CSSIntPoint aDefaultPoint);
static CSSIntPoint GetPageCoords(nsPresContext* aPresContext,
WidgetEvent* aEvent,
LayoutDeviceIntPoint aPoint,
CSSIntPoint aDefaultPoint);
static Maybe<CSSIntPoint> GetScreenCoords(nsPresContext* aPresContext,
WidgetEvent* aEvent,
LayoutDeviceIntPoint aPoint);
static CSSIntPoint GetOffsetCoords(nsPresContext* aPresContext,
WidgetEvent* aEvent,
LayoutDeviceIntPoint aPoint,
CSSIntPoint aDefaultPoint);
static already_AddRefed<Event> Constructor(EventTarget* aEventTarget,
const nsAString& aType,
const EventInit& aParam);
static already_AddRefed<Event> Constructor(const GlobalObject& aGlobal,
const nsAString& aType,
const EventInit& aParam);
void GetType(nsAString& aType) const;
EventTarget* GetTarget() const;
EventTarget* GetCurrentTarget() const;
// This method returns the document which is associated with the event target.
already_AddRefed<Document> GetDocument() const;
void ComposedPath(nsTArray<RefPtr<EventTarget>>& aPath);
uint16_t EventPhase() const;
void StopPropagation();
void StopImmediatePropagation();
bool Bubbles() const { return mEvent->mFlags.mBubbles; }
bool Cancelable() const { return mEvent->mFlags.mCancelable; }
bool Composed() const { return mEvent->mFlags.mComposed; }
bool CancelBubble() const { return mEvent->PropagationStopped(); }
void SetCancelBubble(bool aCancelBubble) {
if (aCancelBubble) {
// For C++ consumers only!
void PreventDefault();
// You MUST NOT call PreventDefault(JSContext*, CallerType) from C++ code. A
// call of this method always sets Event.defaultPrevented true for web
// contents. If default action handler calls this, web applications see wrong
// defaultPrevented value.
virtual void PreventDefault(JSContext* aCx, CallerType aCallerType);
// You MUST NOT call DefaultPrevented(CallerType) from C++ code. This may
// return false even if PreventDefault() has been called.
// See comments in its implementation for the details.
bool DefaultPrevented(CallerType aCallerType) const;
bool DefaultPrevented() const { return mEvent->DefaultPrevented(); }
bool DefaultPreventedByChrome() const {
return mEvent->mFlags.mDefaultPreventedByChrome;
bool DefaultPreventedByContent() const {
return mEvent->mFlags.mDefaultPreventedByContent;
void PreventMultipleActions() {
mEvent->mFlags.mMultipleActionsPrevented = true;
bool MultipleActionsPrevented() const {
return mEvent->mFlags.mMultipleActionsPrevented;
bool ReturnValue(CallerType aCallerType) const;
void SetReturnValue(bool aReturnValue, CallerType aCallerType);
bool IsTrusted() const { return mEvent->IsTrusted(); }
bool IsSynthesized() const { return mEvent->mFlags.mIsSynthesizedForTests; }
bool IsSafeToBeDispatchedAsynchronously() const {
// If mEvent is not created by dom::Event nor its subclasses, its lifetime
// is not guaranteed. So, only when mEventIsInternal is true, it's safe
// to be dispatched asynchronously.
return mEventIsInternal;
double TimeStamp();
EventTarget* GetOriginalTarget() const;
EventTarget* GetExplicitOriginalTarget() const;
EventTarget* GetComposedTarget() const;
* @param aCalledByDefaultHandler Should be true when this is called by
* C++ or Chrome. Otherwise, e.g., called
* by a call of Event.preventDefault() in
* content script, false.
void PreventDefaultInternal(bool aCalledByDefaultHandler,
nsIPrincipal* aPrincipal = nullptr);
bool IsMainThreadEvent() { return mIsMainThreadEvent; }
void MarkUninitialized() {
mEvent->mMessage = eVoidEvent;
mEvent->mSpecifiedEventType = nullptr;
* For WidgetEvent, return it's type in string.
* @param aEvent is a WidgetEvent to get its type.
* @param aType is a string where to return the type.
static void GetWidgetEventType(WidgetEvent* aEvent, nsAString& aType);
void RequestReplyFromRemoteContent() {
bool IsWaitingReplyFromRemoteContent() const {
return mEvent->IsWaitingReplyFromRemoteProcess();
bool IsReplyEventFromRemoteContent() const {
return mEvent->IsHandledInRemoteProcess();
static bool IsDragExitEnabled(JSContext* aCx, JSObject* aGlobal);
// Internal helper functions
void SetEventType(const nsAString& aEventTypeArg);
already_AddRefed<nsIContent> GetTargetFromFrame();
friend class EventMessageAutoOverride;
friend class PopupBlocker;
friend class WantsPopupControlCheck;
void SetWantsPopupControlCheck(bool aCheck) {
mWantsPopupControlCheck = aCheck;
bool GetWantsPopupControlCheck() {
return IsTrusted() && mWantsPopupControlCheck;
void SetComposed(bool aComposed) { mEvent->SetComposed(aComposed); }
already_AddRefed<EventTarget> EnsureWebAccessibleRelatedTarget(
EventTarget* aRelatedTarget);
mozilla::WidgetEvent* mEvent;
RefPtr<nsPresContext> mPresContext;
nsCOMPtr<EventTarget> mExplicitOriginalTarget;
nsCOMPtr<nsIGlobalObject> mOwner;
bool mEventIsInternal;
bool mPrivateDataDuplicated;
bool mIsMainThreadEvent;
// True when popup control check should rely on event.type, not
// WidgetEvent.mMessage.
bool mWantsPopupControlCheck;
* RAII helper-class to override an event's message (i.e. its DOM-exposed
* type), for as long as the object is alive. Restores the original
* EventMessage when destructed.
* Notable requirements:
* - The original & overriding messages must be known (not eUnidentifiedEvent).
* - The original & overriding messages must be different.
* - The passed-in Event must outlive this RAII helper.
class MOZ_RAII EventMessageAutoOverride {
explicit EventMessageAutoOverride(Event* aEvent,
EventMessage aOverridingMessage)
: mEvent(aEvent), mOrigMessage(mEvent->mEvent->mMessage) {
MOZ_ASSERT(aOverridingMessage != mOrigMessage,
"Don't use this class if you're not actually overriding");
MOZ_ASSERT(aOverridingMessage != eUnidentifiedEvent,
"Only use this class with a valid overriding EventMessage");
MOZ_ASSERT(mOrigMessage != eUnidentifiedEvent &&
"Only use this class on events whose overridden type is "
"known (so we can restore it properly)");
mEvent->mEvent->mMessage = aOverridingMessage;
~EventMessageAutoOverride() { mEvent->mEvent->mMessage = mOrigMessage; }
// Non-owning ref, which should be safe since we're a stack-allocated object
// with limited lifetime. Whoever creates us should keep mEvent alive.
Event* const MOZ_NON_OWNING_REF mEvent;
const EventMessage mOrigMessage;
class MOZ_STACK_CLASS WantsPopupControlCheck {
explicit WantsPopupControlCheck(Event* aEvent) : mEvent(aEvent) {
mOriginalWantsPopupControlCheck = mEvent->GetWantsPopupControlCheck();
~WantsPopupControlCheck() {
Event* mEvent;
bool mOriginalWantsPopupControlCheck;
} // namespace mozilla::dom
already_AddRefed<mozilla::dom::Event> NS_NewDOMEvent(
mozilla::dom::EventTarget* aOwner, nsPresContext* aPresContext,
mozilla::WidgetEvent* aEvent);
#endif // mozilla_dom_Event_h_