widget/BasicEvents.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_BasicEvents_h__
   7 #define mozilla_BasicEvents_h__
   8
   9 #include <stdint.h>
  10 #include <type_traits>
  11
  12 #include "mozilla/EventForwards.h"
  13 #include "mozilla/TimeStamp.h"
  14 #include "mozilla/dom/EventTarget.h"
  15 #include "mozilla/layers/LayersTypes.h"
  16 #include "nsCOMPtr.h"
  17 #include "nsAtom.h"
  18 #include "nsISupportsImpl.h"
  19 #include "nsIWidget.h"
  20 #include "nsString.h"
  21 #include "Units.h"
  22
  23 #ifdef DEBUG
  24 #  include "nsXULAppAPI.h"
  25 #endif  // #ifdef DEBUG
  26
  27 class nsIPrincipal;
  28
  29 namespace IPC {
  30 template <typename T>
  31 struct ParamTraits;
  32 }  // namespace IPC
  33
  34 namespace mozilla {
  35
  36 class EventTargetChainItem;
  37
  38 enum class CrossProcessForwarding {
  39   // eStop prevents the event to be sent to remote process.
  40   eStop,
  41   // eAllow keeps current state of the event whether it's sent to remote
  42   // process.  In other words, eAllow does NOT mean that making the event
  43   // sent to remote process when IsCrossProcessForwardingStopped() returns
  44   // true.
  45   eAllow,
  46 };
  47
  48 /******************************************************************************
  49  * mozilla::BaseEventFlags
  50  *
  51  * BaseEventFlags must be a POD struct for safe to use memcpy (including
  52  * in ParamTraits<BaseEventFlags>).  So don't make virtual methods, constructor,
  53  * destructor and operators.
  54  * This is necessary for VC which is NOT C++0x compiler.
  55  ******************************************************************************/
  56
  57 struct BaseEventFlags {
  58  public:
  59   // If mIsTrusted is true, the event is a trusted event.  Otherwise, it's
  60   // an untrusted event.
  61   bool mIsTrusted : 1;
  62   // If mInBubblingPhase is true, the event is in bubbling phase or target
  63   // phase.
  64   bool mInBubblingPhase : 1;
  65   // If mInCapturePhase is true, the event is in capture phase or target phase.
  66   bool mInCapturePhase : 1;
  67   // If mInSystemGroup is true, the event is being dispatched in system group.
  68   bool mInSystemGroup : 1;
  69   // If mCancelable is true, the event can be consumed.  I.e., calling
  70   // dom::Event::PreventDefault() can prevent the default action.
  71   bool mCancelable : 1;
  72   // If mBubbles is true, the event can bubble.  Otherwise, cannot be handled
  73   // in bubbling phase.
  74   bool mBubbles : 1;
  75   // If mPropagationStopped is true, dom::Event::StopPropagation() or
  76   // dom::Event::StopImmediatePropagation() has been called.
  77   bool mPropagationStopped : 1;
  78   // If mImmediatePropagationStopped is true,
  79   // dom::Event::StopImmediatePropagation() has been called.
  80   // Note that mPropagationStopped must be true when this is true.
  81   bool mImmediatePropagationStopped : 1;
  82   // If mDefaultPrevented is true, the event has been consumed.
  83   // E.g., dom::Event::PreventDefault() has been called or
  84   // the default action has been performed.
  85   bool mDefaultPrevented : 1;
  86   // If mDefaultPreventedByContent is true, the event has been
  87   // consumed by content.
  88   // Note that mDefaultPrevented must be true when this is true.
  89   bool mDefaultPreventedByContent : 1;
  90   // If mDefaultPreventedByChrome is true, the event has been
  91   // consumed by chrome.
  92   // Note that mDefaultPrevented must be true when this is true.
  93   bool mDefaultPreventedByChrome : 1;
  94   // mMultipleActionsPrevented may be used when default handling don't want to
  95   // be prevented, but only one of the event targets should handle the event.
  96   // For example, when a <label> element is in another <label> element and
  97   // the first <label> element is clicked, that one may set this true.
  98   // Then, the second <label> element won't handle the event.
  99   bool mMultipleActionsPrevented : 1;
 100   // Similar to above but expected to be used during PreHandleEvent phase.
 101   bool mMultiplePreActionsPrevented : 1;
 102   // If mIsBeingDispatched is true, the DOM event created from the event is
 103   // dispatching into the DOM tree and not completed.
 104   bool mIsBeingDispatched : 1;
 105   // If mDispatchedAtLeastOnce is true, the event has been dispatched
 106   // as a DOM event and the dispatch has been completed in the process.
 107   // So, this is false even if the event has already been dispatched
 108   // in another process.
 109   bool mDispatchedAtLeastOnce : 1;
 110   // If mIsSynthesizedForTests is true, the event has been synthesized for
 111   // automated tests or something hacky approach of an add-on.
 112   bool mIsSynthesizedForTests : 1;
 113   // If mExceptionWasRaised is true, one of the event handlers has raised an
 114   // exception.
 115   bool mExceptionWasRaised : 1;
 116   // If mRetargetToNonNativeAnonymous is true and the target is in a non-native
 117   // native anonymous subtree, the event target is set to mOriginalTarget.
 118   bool mRetargetToNonNativeAnonymous : 1;
 119   // If mNoContentDispatch is true, the event is never dispatched to the
 120   // event handlers which are added to the contents, onfoo attributes and
 121   // properties.  Note that this flag is ignored when
 122   // EventChainPreVisitor::mForceContentDispatch is set true.  For exapmle,
 123   // window and document object sets it true.  Therefore, web applications
 124   // can handle the event if they add event listeners to the window or the
 125   // document.
 126   // XXX This is an ancient and broken feature, don't use this for new bug
 127   //     as far as possible.
 128   bool mNoContentDispatch : 1;
 129   // If mOnlyChromeDispatch is true, the event is dispatched to only chrome.
 130   bool mOnlyChromeDispatch : 1;
 131   // Indicates if the key combination is reserved by chrome.  This is set by
 132   // MarkAsReservedByChrome().
 133   bool mIsReservedByChrome : 1;
 134   // If mOnlySystemGroupDispatchInContent is true, event listeners added to
 135   // the default group for non-chrome EventTarget won't be called.
 136   // Be aware, if this is true, EventDispatcher needs to check if each event
 137   // listener is added to chrome node, so, don't set this to true for the
 138   // events which are fired a lot of times like eMouseMove.
 139   bool mOnlySystemGroupDispatchInContent : 1;
 140   // If mOnlySystemGroupDispatch is true, the event will be dispatched only to
 141   // event listeners added in the system group.
 142   bool mOnlySystemGroupDispatch : 1;
 143   // The event's action will be handled by APZ. The main thread should not
 144   // perform its associated action.
 145   bool mHandledByAPZ : 1;
 146   // True if the event is currently being handled by an event listener that
 147   // was registered as a passive listener.
 148   bool mInPassiveListener : 1;
 149   // If mComposed is true, the event fired by nodes in shadow DOM can cross the
 150   // boundary of shadow DOM and light DOM.
 151   bool mComposed : 1;
 152   // Similar to mComposed. Set it to true to allow events cross the boundary
 153   // between native non-anonymous content and native anonymouse content
 154   bool mComposedInNativeAnonymousContent : 1;
 155   // Set to true for events which are suppressed or delayed so that later a
 156   // DelayedEvent of it is dispatched. This is used when parent side process
 157   // the key event after content side, and may drop the event if the event
 158   // was suppressed or delayed in contents side.
 159   // It is also set to true for the events (in a DelayedInputEvent), which will
 160   // be dispatched afterwards.
 161   bool mIsSuppressedOrDelayed : 1;
 162   // Certain mouse events can be marked as positionless to return 0 from
 163   // coordinate related getters.
 164   bool mIsPositionless : 1;
 165
 166   // Flags managing state of propagation between processes.
 167   // Note the the following flags shouldn't be referred directly.  Use utility
 168   // methods instead.
 169
 170   // If mNoRemoteProcessDispatch is true, the event is not allowed to be sent
 171   // to remote process.
 172   bool mNoRemoteProcessDispatch : 1;
 173   // If mWantReplyFromContentProcess is true, the event will be redispatched
 174   // in the parent process after the content process has handled it. Useful
 175   // for when the parent process need the know first how the event was used
 176   // by content before handling it itself.
 177   bool mWantReplyFromContentProcess : 1;
 178   // If mPostedToRemoteProcess is true, the event has been posted to the
 179   // remote process (but it's not handled yet if it's not a duplicated event
 180   // instance).
 181   bool mPostedToRemoteProcess : 1;
 182   // If mCameFromAnotherProcess is true, the event came from another process.
 183   bool mCameFromAnotherProcess : 1;
 184
 185   // At lease one of the event in the event path had non privileged click
 186   // listener.
 187   bool mHadNonPrivilegedClickListeners : 1;
 188
 189   // If the event is being handled in target phase, returns true.
 190   inline bool InTargetPhase() const {
 191     return (mInBubblingPhase && mInCapturePhase);
 192   }
 193
 194   /**
 195    * Helper methods for methods of DOM Event.
 196    */
 197   inline void StopPropagation() { mPropagationStopped = true; }
 198   inline void StopImmediatePropagation() {
 199     StopPropagation();
 200     mImmediatePropagationStopped = true;
 201   }
 202   inline void PreventDefault(bool aCalledByDefaultHandler = true) {
 203     if (!mCancelable) {
 204       return;
 205     }
 206     mDefaultPrevented = true;
 207     // Note that even if preventDefault() has already been called by chrome,
 208     // a call of preventDefault() by content needs to overwrite
 209     // mDefaultPreventedByContent to true because in such case, defaultPrevented
 210     // must be true when web apps check it after they call preventDefault().
 211     if (aCalledByDefaultHandler) {
 212       StopCrossProcessForwarding();
 213       mDefaultPreventedByChrome = true;
 214     } else {
 215       mDefaultPreventedByContent = true;
 216     }
 217   }
 218   // This should be used only before dispatching events into the DOM tree.
 219   inline void PreventDefaultBeforeDispatch(
 220       CrossProcessForwarding aCrossProcessForwarding) {
 221     if (!mCancelable) {
 222       return;
 223     }
 224     mDefaultPrevented = true;
 225     if (aCrossProcessForwarding == CrossProcessForwarding::eStop) {
 226       StopCrossProcessForwarding();
 227     }
 228   }
 229   inline bool DefaultPrevented() const { return mDefaultPrevented; }
 230   inline bool DefaultPreventedByContent() const {
 231     MOZ_ASSERT(!mDefaultPreventedByContent || DefaultPrevented());
 232     return mDefaultPreventedByContent;
 233   }
 234   inline bool IsTrusted() const { return mIsTrusted; }
 235   inline bool PropagationStopped() const { return mPropagationStopped; }
 236
 237   // Helper methods to access flags managing state of propagation between
 238   // processes.
 239
 240   /**
 241    * Prevent to be dispatched to remote process.
 242    */
 243   inline void StopCrossProcessForwarding() {
 244     MOZ_ASSERT(!mPostedToRemoteProcess);
 245     mNoRemoteProcessDispatch = true;
 246     mWantReplyFromContentProcess = false;
 247   }
 248   /**
 249    * Return true if the event shouldn't be dispatched to remote process.
 250    */
 251   inline bool IsCrossProcessForwardingStopped() const {
 252     return mNoRemoteProcessDispatch;
 253   }
 254   /**
 255    * Mark the event as waiting reply from remote process.
 256    * If the caller needs to win other keyboard event handlers in chrome,
 257    * the caller should call StopPropagation() too.
 258    * Otherwise, if the caller just needs to know if the event is consumed by
 259    * either content or chrome, it should just call this because the event
 260    * may be reserved by chrome and it needs to be dispatched into the DOM
 261    * tree in chrome for checking if it's reserved before being sent to any
 262    * remote processes.
 263    */
 264   inline void MarkAsWaitingReplyFromRemoteProcess() {
 265     MOZ_ASSERT(!mPostedToRemoteProcess);
 266     mNoRemoteProcessDispatch = false;
 267     mWantReplyFromContentProcess = true;
 268   }
 269   /**
 270    * Reset "waiting reply from remote process" state.  This is useful when
 271    * you dispatch a copy of an event coming from different process.
 272    */
 273   inline void ResetWaitingReplyFromRemoteProcessState() {
 274     if (IsWaitingReplyFromRemoteProcess()) {
 275       // FYI: mWantReplyFromContentProcess is also used for indicating
 276       //      "handled in remote process" state.  Therefore, only when
 277       //      IsWaitingReplyFromRemoteProcess() returns true, this should
 278       //      reset the flag.
 279       mWantReplyFromContentProcess = false;
 280     }
 281   }
 282   /**
 283    * Return true if the event handler should wait reply event.  I.e., if this
 284    * returns true, any event handler should do nothing with the event.
 285    */
 286   inline bool IsWaitingReplyFromRemoteProcess() const {
 287     return !mNoRemoteProcessDispatch && mWantReplyFromContentProcess;
 288   }
 289   /**
 290    * Mark the event as already handled in the remote process.  This should be
 291    * called when initializing reply events.
 292    */
 293   inline void MarkAsHandledInRemoteProcess() {
 294     mNoRemoteProcessDispatch = true;
 295     mWantReplyFromContentProcess = true;
 296     mPostedToRemoteProcess = false;
 297   }
 298   /**
 299    * Return true if the event has already been handled in the remote process.
 300    */
 301   inline bool IsHandledInRemoteProcess() const {
 302     return mNoRemoteProcessDispatch && mWantReplyFromContentProcess;
 303   }
 304   /**
 305    * Return true if the event should be sent back to its parent process.
 306    */
 307   inline bool WantReplyFromContentProcess() const {
 308     MOZ_ASSERT(!XRE_IsParentProcess());
 309     return IsWaitingReplyFromRemoteProcess();
 310   }
 311   /**
 312    * Mark the event has already posted to a remote process.
 313    */
 314   inline void MarkAsPostedToRemoteProcess() {
 315     MOZ_ASSERT(!IsCrossProcessForwardingStopped());
 316     mPostedToRemoteProcess = true;
 317   }
 318   /**
 319    * Reset the cross process dispatching state.  This should be used when a
 320    * process receives the event because the state is in the sender.
 321    */
 322   inline void ResetCrossProcessDispatchingState() {
 323     MOZ_ASSERT(!IsCrossProcessForwardingStopped());
 324     mPostedToRemoteProcess = false;
 325     // Ignore propagation state in the different process if it's marked as
 326     // "waiting reply from remote process" because the process needs to
 327     // stop propagation in the process until receiving a reply event.
 328     if (IsWaitingReplyFromRemoteProcess()) {
 329       mPropagationStopped = mImmediatePropagationStopped = false;
 330     }
 331     // mDispatchedAtLeastOnce indicates the state in current process.
 332     mDispatchedAtLeastOnce = false;
 333   }
 334   /**
 335    * Return true if the event has been posted to a remote process.
 336    * Note that MarkAsPostedToRemoteProcess() is called by
 337    * ParamTraits<mozilla::WidgetEvent>.  Therefore, it *might* be possible
 338    * that posting the event failed even if this returns true.  But that must
 339    * really rare.  If that'd be problem for you, you should unmark this in
 340    * BrowserParent or somewhere.
 341    */
 342   inline bool HasBeenPostedToRemoteProcess() const {
 343     return mPostedToRemoteProcess;
 344   }
 345   /**
 346    * Return true if the event came from another process.
 347    */
 348   inline bool CameFromAnotherProcess() const { return mCameFromAnotherProcess; }
 349   /**
 350    * Mark the event as coming from another process.
 351    */
 352   inline void MarkAsComingFromAnotherProcess() {
 353     mCameFromAnotherProcess = true;
 354   }
 355   /**
 356    * Mark the event is reserved by chrome.  I.e., shouldn't be dispatched to
 357    * content because it shouldn't be cancelable.
 358    */
 359   inline void MarkAsReservedByChrome() {
 360     MOZ_ASSERT(!mPostedToRemoteProcess);
 361     mIsReservedByChrome = true;
 362     // For reserved commands (such as Open New Tab), we don't need to wait for
 363     // the content to answer, neither to give a chance for content to override
 364     // its behavior.
 365     StopCrossProcessForwarding();
 366     // If the event is reserved by chrome, we shouldn't expose the event to
 367     // web contents because such events shouldn't be cancelable.  So, it's not
 368     // good behavior to fire such events but to ignore the defaultPrevented
 369     // attribute value in chrome.
 370     mOnlySystemGroupDispatchInContent = true;
 371   }
 372   /**
 373    * Return true if the event is reserved by chrome.
 374    */
 375   inline bool IsReservedByChrome() const {
 376     MOZ_ASSERT(!mIsReservedByChrome || (IsCrossProcessForwardingStopped() &&
 377                                         mOnlySystemGroupDispatchInContent));
 378     return mIsReservedByChrome;
 379   }
 380
 381   inline void Clear() { SetRawFlags(0); }
 382   // Get if either the instance's bit or the aOther's bit is true, the
 383   // instance's bit becomes true.  In other words, this works like:
 384   // eventFlags |= aOther;
 385   inline void Union(const BaseEventFlags& aOther) {
 386     RawFlags rawFlags = GetRawFlags() | aOther.GetRawFlags();
 387     SetRawFlags(rawFlags);
 388   }
 389
 390  private:
 391   typedef uint64_t RawFlags;
 392
 393   inline void SetRawFlags(RawFlags aRawFlags) {
 394     static_assert(sizeof(BaseEventFlags) <= sizeof(RawFlags),
 395                   "mozilla::EventFlags must not be bigger than the RawFlags");
 396     memcpy(this, &aRawFlags, sizeof(BaseEventFlags));
 397   }
 398   inline RawFlags GetRawFlags() const {
 399     RawFlags result = 0;
 400     memcpy(&result, this, sizeof(BaseEventFlags));
 401     return result;
 402   }
 403 };
 404
 405 /******************************************************************************
 406  * mozilla::EventFlags
 407  ******************************************************************************/
 408
 409 struct EventFlags : public BaseEventFlags {
 410   EventFlags() { Clear(); }
 411 };
 412
 413 /******************************************************************************
 414  * mozilla::WidgetEventTime
 415  ******************************************************************************/
 416
 417 class WidgetEventTime {
 418  public:
 419   // Elapsed time, in milliseconds, from a platform-specific zero time
 420   // to the time the message was created
 421   uint64_t mTime;
 422   // Timestamp when the message was created. Set in parallel to 'time' until we
 423   // determine if it is safe to drop 'time' (see bug 77992).
 424   TimeStamp mTimeStamp;
 425
 426   WidgetEventTime() : mTime(0), mTimeStamp(TimeStamp::Now()) {}
 427
 428   WidgetEventTime(uint64_t aTime, TimeStamp aTimeStamp)
 429       : mTime(aTime), mTimeStamp(aTimeStamp) {}
 430
 431   void AssignEventTime(const WidgetEventTime& aOther) {
 432     mTime = aOther.mTime;
 433     mTimeStamp = aOther.mTimeStamp;
 434   }
 435 };
 436
 437 /******************************************************************************
 438  * mozilla::WidgetEvent
 439  ******************************************************************************/
 440
 441 class WidgetEvent : public WidgetEventTime {
 442  private:
 443   void SetDefaultCancelableAndBubbles() {
 444     switch (mClass) {
 445       case eEditorInputEventClass:
 446         mFlags.mCancelable = false;
 447         mFlags.mBubbles = mFlags.mIsTrusted;
 448         break;
 449       case eMouseEventClass:
 450         mFlags.mCancelable =
 451             (mMessage != eMouseEnter && mMessage != eMouseLeave);
 452         mFlags.mBubbles = (mMessage != eMouseEnter && mMessage != eMouseLeave);
 453         break;
 454       case ePointerEventClass:
 455         mFlags.mCancelable =
 456             (mMessage != ePointerEnter && mMessage != ePointerLeave &&
 457              mMessage != ePointerCancel && mMessage != ePointerGotCapture &&
 458              mMessage != ePointerLostCapture);
 459         mFlags.mBubbles =
 460             (mMessage != ePointerEnter && mMessage != ePointerLeave);
 461         break;
 462       case eDragEventClass:
 463         mFlags.mCancelable = (mMessage != eDragExit && mMessage != eDragLeave &&
 464                               mMessage != eDragEnd);
 465         mFlags.mBubbles = true;
 466         break;
 467       case eSMILTimeEventClass:
 468         mFlags.mCancelable = false;
 469         mFlags.mBubbles = false;
 470         break;
 471       case eTransitionEventClass:
 472       case eAnimationEventClass:
 473         mFlags.mCancelable = false;
 474         mFlags.mBubbles = true;
 475         break;
 476       case eCompositionEventClass:
 477         // XXX compositionstart is cancelable in draft of DOM3 Events.
 478         //     However, it doesn't make sense for us, we cannot cancel
 479         //     composition when we send compositionstart event.
 480         mFlags.mCancelable = false;
 481         mFlags.mBubbles = true;
 482         break;
 483       default:
 484         if (mMessage == eResize || mMessage == eMozVisualResize ||
 485             mMessage == eMozVisualScroll || mMessage == eEditorInput ||
 486             mMessage == eFormSelect) {
 487           mFlags.mCancelable = false;
 488         } else {
 489           mFlags.mCancelable = true;
 490         }
 491         mFlags.mBubbles = true;
 492         break;
 493     }
 494   }
 495
 496  protected:
 497   WidgetEvent(bool aIsTrusted, EventMessage aMessage,
 498               EventClassID aEventClassID)
 499       : WidgetEventTime(),
 500         mClass(aEventClassID),
 501         mMessage(aMessage),
 502         mRefPoint(0, 0),
 503         mLastRefPoint(0, 0),
 504         mFocusSequenceNumber(0),
 505         mSpecifiedEventType(nullptr),
 506         mPath(nullptr),
 507         mLayersId(layers::LayersId{0}) {
 508     MOZ_COUNT_CTOR(WidgetEvent);
 509     mFlags.Clear();
 510     mFlags.mIsTrusted = aIsTrusted;
 511     SetDefaultCancelableAndBubbles();
 512     SetDefaultComposed();
 513     SetDefaultComposedInNativeAnonymousContent();
 514   }
 515
 516   WidgetEvent() : WidgetEventTime(), mPath(nullptr) {
 517     MOZ_COUNT_CTOR(WidgetEvent);
 518   }
 519
 520  public:
 521   WidgetEvent(bool aIsTrusted, EventMessage aMessage)
 522       : WidgetEvent(aIsTrusted, aMessage, eBasicEventClass) {}
 523
 524   MOZ_COUNTED_DTOR_VIRTUAL(WidgetEvent)
 525
 526   WidgetEvent(const WidgetEvent& aOther) : WidgetEventTime() {
 527     MOZ_COUNT_CTOR(WidgetEvent);
 528     *this = aOther;
 529   }
 530   WidgetEvent& operator=(const WidgetEvent& aOther) = default;
 531
 532   WidgetEvent(WidgetEvent&& aOther)
 533       : WidgetEventTime(std::move(aOther)),
 534         mClass(aOther.mClass),
 535         mMessage(aOther.mMessage),
 536         mRefPoint(std::move(aOther.mRefPoint)),
 537         mLastRefPoint(std::move(aOther.mLastRefPoint)),
 538         mFocusSequenceNumber(aOther.mFocusSequenceNumber),
 539         mFlags(std::move(aOther.mFlags)),
 540         mSpecifiedEventType(std::move(aOther.mSpecifiedEventType)),
 541         mSpecifiedEventTypeString(std::move(aOther.mSpecifiedEventTypeString)),
 542         mTarget(std::move(aOther.mTarget)),
 543         mCurrentTarget(std::move(aOther.mCurrentTarget)),
 544         mOriginalTarget(std::move(aOther.mOriginalTarget)),
 545         mRelatedTarget(std::move(aOther.mRelatedTarget)),
 546         mOriginalRelatedTarget(std::move(aOther.mOriginalRelatedTarget)),
 547         mPath(std::move(aOther.mPath)) {
 548     MOZ_COUNT_CTOR(WidgetEvent);
 549   }
 550   WidgetEvent& operator=(WidgetEvent&& aOther) = default;
 551
 552   virtual WidgetEvent* Duplicate() const {
 553     MOZ_ASSERT(mClass == eBasicEventClass,
 554                "Duplicate() must be overridden by sub class");
 555     WidgetEvent* result = new WidgetEvent(false, mMessage);
 556     result->AssignEventData(*this, true);
 557     result->mFlags = mFlags;
 558     return result;
 559   }
 560
 561   EventClassID mClass;
 562   EventMessage mMessage;
 563   // Relative to the widget of the event, or if there is no widget then it is
 564   // in screen coordinates. Not modified by layout code.
 565   // This is in visual coordinates, i.e. the correct RelativeTo value that
 566   // expresses what this is relative to is `{viewportFrame, Visual}`, where
 567   // `viewportFrame` is the viewport frame of the widget's root document.
 568   LayoutDeviceIntPoint mRefPoint;
 569   // The previous mRefPoint, if known, used to calculate mouse movement deltas.
 570   LayoutDeviceIntPoint mLastRefPoint;
 571   // The sequence number of the last potentially focus changing event handled
 572   // by APZ. This is used to track when that event has been processed by
 573   // content, and focus can be reconfirmed for async keyboard scrolling.
 574   uint64_t mFocusSequenceNumber;
 575   // See BaseEventFlags definition for the detail.
 576   BaseEventFlags mFlags;
 577
 578   // If JS creates an event with unknown event type or known event type but
 579   // for different event interface, the event type is stored to this.
 580   // NOTE: This is always used if the instance is a WidgetCommandEvent instance
 581   //       or "input" event is dispatched with dom::Event class.
 582   RefPtr<nsAtom> mSpecifiedEventType;
 583
 584   // nsAtom isn't available on non-main thread due to unsafe.  Therefore,
 585   // mSpecifiedEventTypeString is used instead of mSpecifiedEventType if
 586   // the event is created in non-main thread.
 587   nsString mSpecifiedEventTypeString;
 588
 589   // Event targets, needed by DOM Events
 590   // Note that when you need event target for DOM event, you should use
 591   // Get*DOMEventTarget() instead of accessing these members directly.
 592   nsCOMPtr<dom::EventTarget> mTarget;
 593   nsCOMPtr<dom::EventTarget> mCurrentTarget;
 594   nsCOMPtr<dom::EventTarget> mOriginalTarget;
 595
 596   /// The possible related target
 597   nsCOMPtr<dom::EventTarget> mRelatedTarget;
 598   nsCOMPtr<dom::EventTarget> mOriginalRelatedTarget;
 599
 600   nsTArray<EventTargetChainItem>* mPath;
 601
 602   // The LayersId of the content process that this event should be
 603   // dispatched to. This field is only used in the chrome process
 604   // and doesn't get remoted to child processes.
 605   layers::LayersId mLayersId;
 606
 607   dom::EventTarget* GetDOMEventTarget() const;
 608   dom::EventTarget* GetCurrentDOMEventTarget() const;
 609   dom::EventTarget* GetOriginalDOMEventTarget() const;
 610
 611   void AssignEventData(const WidgetEvent& aEvent, bool aCopyTargets) {
 612     // mClass should be initialized with the constructor.
 613     // mMessage should be initialized with the constructor.
 614     mRefPoint = aEvent.mRefPoint;
 615     // mLastRefPoint doesn't need to be copied.
 616     mFocusSequenceNumber = aEvent.mFocusSequenceNumber;
 617     // mLayersId intentionally not copied, since it's not used within content
 618     AssignEventTime(aEvent);
 619     // mFlags should be copied manually if it's necessary.
 620     mSpecifiedEventType = aEvent.mSpecifiedEventType;
 621     // mSpecifiedEventTypeString should be copied manually if it's necessary.
 622     mTarget = aCopyTargets ? aEvent.mTarget : nullptr;
 623     mCurrentTarget = aCopyTargets ? aEvent.mCurrentTarget : nullptr;
 624     mOriginalTarget = aCopyTargets ? aEvent.mOriginalTarget : nullptr;
 625     mRelatedTarget = aCopyTargets ? aEvent.mRelatedTarget : nullptr;
 626     mOriginalRelatedTarget =
 627         aCopyTargets ? aEvent.mOriginalRelatedTarget : nullptr;
 628   }
 629
 630   /**
 631    * Helper methods for methods of DOM Event.
 632    */
 633   void StopPropagation() { mFlags.StopPropagation(); }
 634   void StopImmediatePropagation() { mFlags.StopImmediatePropagation(); }
 635   void PreventDefault(bool aCalledByDefaultHandler = true,
 636                       nsIPrincipal* aPrincipal = nullptr);
 637
 638   void PreventDefaultBeforeDispatch(
 639       CrossProcessForwarding aCrossProcessForwarding) {
 640     mFlags.PreventDefaultBeforeDispatch(aCrossProcessForwarding);
 641   }
 642   bool DefaultPrevented() const { return mFlags.DefaultPrevented(); }
 643   bool DefaultPreventedByContent() const {
 644     return mFlags.DefaultPreventedByContent();
 645   }
 646   bool IsTrusted() const { return mFlags.IsTrusted(); }
 647   bool PropagationStopped() const { return mFlags.PropagationStopped(); }
 648
 649   /**
 650    * Prevent to be dispatched to remote process.
 651    */
 652   inline void StopCrossProcessForwarding() {
 653     mFlags.StopCrossProcessForwarding();
 654   }
 655   /**
 656    * Return true if the event shouldn't be dispatched to remote process.
 657    */
 658   inline bool IsCrossProcessForwardingStopped() const {
 659     return mFlags.IsCrossProcessForwardingStopped();
 660   }
 661   /**
 662    * Mark the event as waiting reply from remote process.
 663    * Note that this also stops immediate propagation in current process.
 664    */
 665   inline void MarkAsWaitingReplyFromRemoteProcess() {
 666     mFlags.MarkAsWaitingReplyFromRemoteProcess();
 667   }
 668   /**
 669    * Reset "waiting reply from remote process" state.  This is useful when
 670    * you dispatch a copy of an event coming from different process.
 671    */
 672   inline void ResetWaitingReplyFromRemoteProcessState() {
 673     mFlags.ResetWaitingReplyFromRemoteProcessState();
 674   }
 675   /**
 676    * Return true if the event handler should wait reply event.  I.e., if this
 677    * returns true, any event handler should do nothing with the event.
 678    */
 679   inline bool IsWaitingReplyFromRemoteProcess() const {
 680     return mFlags.IsWaitingReplyFromRemoteProcess();
 681   }
 682   /**
 683    * Mark the event as already handled in the remote process.  This should be
 684    * called when initializing reply events.
 685    */
 686   inline void MarkAsHandledInRemoteProcess() {
 687     mFlags.MarkAsHandledInRemoteProcess();
 688   }
 689   /**
 690    * Return true if the event has already been handled in the remote process.
 691    * I.e., if this returns true, the event is a reply event.
 692    */
 693   inline bool IsHandledInRemoteProcess() const {
 694     return mFlags.IsHandledInRemoteProcess();
 695   }
 696   /**
 697    * Return true if the event should be sent back to its parent process.
 698    * So, usual event handlers shouldn't call this.
 699    */
 700   inline bool WantReplyFromContentProcess() const {
 701     return mFlags.WantReplyFromContentProcess();
 702   }
 703   /**
 704    * Mark the event has already posted to a remote process.
 705    */
 706   inline void MarkAsPostedToRemoteProcess() {
 707     mFlags.MarkAsPostedToRemoteProcess();
 708   }
 709   /**
 710    * Reset the cross process dispatching state.  This should be used when a
 711    * process receives the event because the state is in the sender.
 712    */
 713   inline void ResetCrossProcessDispatchingState() {
 714     mFlags.ResetCrossProcessDispatchingState();
 715   }
 716   /**
 717    * Return true if the event has been posted to a remote process.
 718    */
 719   inline bool HasBeenPostedToRemoteProcess() const {
 720     return mFlags.HasBeenPostedToRemoteProcess();
 721   }
 722   /**
 723    * Return true if the event came from another process.
 724    */
 725   inline bool CameFromAnotherProcess() const {
 726     return mFlags.CameFromAnotherProcess();
 727   }
 728   /**
 729    * Mark the event as coming from another process.
 730    */
 731   inline void MarkAsComingFromAnotherProcess() {
 732     mFlags.MarkAsComingFromAnotherProcess();
 733   }
 734   /**
 735    * Mark the event is reserved by chrome.  I.e., shouldn't be dispatched to
 736    * content because it shouldn't be cancelable.
 737    */
 738   inline void MarkAsReservedByChrome() { mFlags.MarkAsReservedByChrome(); }
 739   /**
 740    * Return true if the event is reserved by chrome.
 741    */
 742   inline bool IsReservedByChrome() const { return mFlags.IsReservedByChrome(); }
 743
 744   /**
 745    * Utils for checking event types
 746    */
 747
 748   /**
 749    * As*Event() returns the pointer of the instance only when the instance is
 750    * the class or one of its derived class.
 751    */
 752 #define NS_ROOT_EVENT_CLASS(aPrefix, aName)
 753 #define NS_EVENT_CLASS(aPrefix, aName) \
 754   virtual aPrefix##aName* As##aName(); \
 755   const aPrefix##aName* As##aName() const;
 756
 757 #include "mozilla/EventClassList.h"
 758
 759 #undef NS_EVENT_CLASS
 760 #undef NS_ROOT_EVENT_CLASS
 761
 762   /**
 763    * Returns true if the event is a query content event.
 764    */
 765   bool IsQueryContentEvent() const;
 766   /**
 767    * Returns true if the event is a selection event.
 768    */
 769   bool IsSelectionEvent() const;
 770   /**
 771    * Returns true if the event is a content command event.
 772    */
 773   bool IsContentCommandEvent() const;
 774
 775   /**
 776    * Returns true if the event mMessage is one of mouse events.
 777    */
 778   bool HasMouseEventMessage() const;
 779   /**
 780    * Returns true if the event mMessage is one of drag events.
 781    */
 782   bool HasDragEventMessage() const;
 783   /**
 784    * Returns true if aMessage or mMessage is one of key events.
 785    */
 786   static bool IsKeyEventMessage(EventMessage aMessage);
 787   bool HasKeyEventMessage() const { return IsKeyEventMessage(mMessage); }
 788   /**
 789    * Returns true if the event mMessage is one of composition events or text
 790    * event.
 791    */
 792   bool HasIMEEventMessage() const;
 793   /**
 794    * Returns true if the event mMessage is one of plugin activation events.
 795    */
 796   bool HasPluginActivationEventMessage() const;
 797
 798   /**
 799    * Returns true if the event can be sent to remote process.
 800    */
 801   bool CanBeSentToRemoteProcess() const;
 802   /**
 803    * Returns true if the original target is a remote process and the event
 804    * will be posted to the remote process later.
 805    */
 806   bool WillBeSentToRemoteProcess() const;
 807   /**
 808    * Returns true if the event is related to IME handling.  It includes
 809    * IME events, query content events and selection events.
 810    * Be careful when you use this.
 811    */
 812   bool IsIMERelatedEvent() const;
 813
 814   /**
 815    * Whether the event should be handled by the frame of the mouse cursor
 816    * position or not.  When it should be handled there (e.g., the mouse events),
 817    * this returns true.
 818    */
 819   bool IsUsingCoordinates() const;
 820   /**
 821    * Whether the event should be handled by the focused DOM window in the
 822    * same top level window's or not.  E.g., key events, IME related events
 823    * (including the query content events, they are used in IME transaction)
 824    * should be handled by the (last) focused window rather than the dispatched
 825    * window.
 826    *
 827    * NOTE: Even if this returns true, the event isn't going to be handled by the
 828    * application level active DOM window which is on another top level window.
 829    * So, when the event is fired on a deactive window, the event is going to be
 830    * handled by the last focused DOM window in the last focused window.
 831    */
 832   bool IsTargetedAtFocusedWindow() const;
 833   /**
 834    * Whether the event should be handled by the focused content or not.  E.g.,
 835    * key events, IME related events and other input events which are not handled
 836    * by the frame of the mouse cursor position.
 837    *
 838    * NOTE: Even if this returns true, the event isn't going to be handled by the
 839    * application level active DOM window which is on another top level window.
 840    * So, when the event is fired on a deactive window, the event is going to be
 841    * handled by the last focused DOM element of the last focused DOM window in
 842    * the last focused window.
 843    */
 844   bool IsTargetedAtFocusedContent() const;
 845   /**
 846    * Whether the event should cause a DOM event.
 847    */
 848   bool IsAllowedToDispatchDOMEvent() const;
 849   /**
 850    * Whether the event should be dispatched in system group.
 851    */
 852   bool IsAllowedToDispatchInSystemGroup() const;
 853   /**
 854    * Whether the event should be blocked for fingerprinting resistance.
 855    */
 856   bool IsBlockedForFingerprintingResistance() const;
 857   /**
 858    * Initialize mComposed
 859    */
 860   void SetDefaultComposed() {
 861     switch (mClass) {
 862       case eCompositionEventClass:
 863         mFlags.mComposed =
 864             mMessage == eCompositionStart || mMessage == eCompositionUpdate ||
 865             mMessage == eCompositionChange || mMessage == eCompositionEnd;
 866         break;
 867       case eDragEventClass:
 868         // All drag & drop events are composed
 869         mFlags.mComposed = mMessage == eDrag || mMessage == eDragEnd ||
 870                            mMessage == eDragEnter || mMessage == eDragExit ||
 871                            mMessage == eDragLeave || mMessage == eDragOver ||
 872                            mMessage == eDragStart || mMessage == eDrop;
 873         break;
 874       case eEditorInputEventClass:
 875         mFlags.mComposed =
 876             mMessage == eEditorInput || mMessage == eEditorBeforeInput;
 877         break;
 878       case eFocusEventClass:
 879         mFlags.mComposed = mMessage == eBlur || mMessage == eFocus ||
 880                            mMessage == eFocusOut || mMessage == eFocusIn;
 881         break;
 882       case eKeyboardEventClass:
 883         mFlags.mComposed =
 884             mMessage == eKeyDown || mMessage == eKeyUp || mMessage == eKeyPress;
 885         break;
 886       case eMouseEventClass:
 887         mFlags.mComposed =
 888             mMessage == eMouseClick || mMessage == eMouseDoubleClick ||
 889             mMessage == eMouseAuxClick || mMessage == eMouseDown ||
 890             mMessage == eMouseUp || mMessage == eMouseOver ||
 891             mMessage == eMouseOut || mMessage == eMouseMove ||
 892             mMessage == eContextMenu || mMessage == eXULPopupShowing ||
 893             mMessage == eXULPopupHiding || mMessage == eXULPopupShown ||
 894             mMessage == eXULPopupHidden;
 895         break;
 896       case ePointerEventClass:
 897         // All pointer events are composed
 898         mFlags.mComposed =
 899             mMessage == ePointerDown || mMessage == ePointerMove ||
 900             mMessage == ePointerUp || mMessage == ePointerCancel ||
 901             mMessage == ePointerOver || mMessage == ePointerOut ||
 902             mMessage == ePointerGotCapture || mMessage == ePointerLostCapture;
 903         break;
 904       case eTouchEventClass:
 905         // All touch events are composed
 906         mFlags.mComposed = mMessage == eTouchStart || mMessage == eTouchEnd ||
 907                            mMessage == eTouchMove || mMessage == eTouchCancel;
 908         break;
 909       case eUIEventClass:
 910         mFlags.mComposed = mMessage == eLegacyDOMFocusIn ||
 911                            mMessage == eLegacyDOMFocusOut ||
 912                            mMessage == eLegacyDOMActivate;
 913         break;
 914       case eWheelEventClass:
 915         // All wheel events are composed
 916         mFlags.mComposed = mMessage == eWheel;
 917         break;
 918       case eMouseScrollEventClass:
 919         // Legacy mouse scroll events are composed too, for consistency with
 920         // wheel.
 921         mFlags.mComposed = mMessage == eLegacyMouseLineOrPageScroll ||
 922                            mMessage == eLegacyMousePixelScroll;
 923         break;
 924       default:
 925         mFlags.mComposed = false;
 926         break;
 927     }
 928   }
 929
 930   void SetComposed(const nsAString& aEventTypeArg) {
 931     mFlags.mComposed =  // composition events
 932         aEventTypeArg.EqualsLiteral("compositionstart") ||
 933         aEventTypeArg.EqualsLiteral("compositionupdate") ||
 934         aEventTypeArg.EqualsLiteral("compositionend") ||
 935         aEventTypeArg.EqualsLiteral("text") ||
 936         // drag and drop events
 937         aEventTypeArg.EqualsLiteral("dragstart") ||
 938         aEventTypeArg.EqualsLiteral("drag") ||
 939         aEventTypeArg.EqualsLiteral("dragenter") ||
 940         aEventTypeArg.EqualsLiteral("dragexit") ||
 941         aEventTypeArg.EqualsLiteral("dragleave") ||
 942         aEventTypeArg.EqualsLiteral("dragover") ||
 943         aEventTypeArg.EqualsLiteral("drop") ||
 944         aEventTypeArg.EqualsLiteral("dropend") ||
 945         // editor input events
 946         aEventTypeArg.EqualsLiteral("input") ||
 947         aEventTypeArg.EqualsLiteral("beforeinput") ||
 948         // focus events
 949         aEventTypeArg.EqualsLiteral("blur") ||
 950         aEventTypeArg.EqualsLiteral("focus") ||
 951         aEventTypeArg.EqualsLiteral("focusin") ||
 952         aEventTypeArg.EqualsLiteral("focusout") ||
 953         // keyboard events
 954         aEventTypeArg.EqualsLiteral("keydown") ||
 955         aEventTypeArg.EqualsLiteral("keyup") ||
 956         aEventTypeArg.EqualsLiteral("keypress") ||
 957         // mouse events
 958         aEventTypeArg.EqualsLiteral("click") ||
 959         aEventTypeArg.EqualsLiteral("dblclick") ||
 960         aEventTypeArg.EqualsLiteral("mousedown") ||
 961         aEventTypeArg.EqualsLiteral("mouseup") ||
 962         aEventTypeArg.EqualsLiteral("mouseenter") ||
 963         aEventTypeArg.EqualsLiteral("mouseleave") ||
 964         aEventTypeArg.EqualsLiteral("mouseover") ||
 965         aEventTypeArg.EqualsLiteral("mouseout") ||
 966         aEventTypeArg.EqualsLiteral("mousemove") ||
 967         aEventTypeArg.EqualsLiteral("contextmenu") ||
 968         // pointer events
 969         aEventTypeArg.EqualsLiteral("pointerdown") ||
 970         aEventTypeArg.EqualsLiteral("pointermove") ||
 971         aEventTypeArg.EqualsLiteral("pointerup") ||
 972         aEventTypeArg.EqualsLiteral("pointercancel") ||
 973         aEventTypeArg.EqualsLiteral("pointerover") ||
 974         aEventTypeArg.EqualsLiteral("pointerout") ||
 975         aEventTypeArg.EqualsLiteral("pointerenter") ||
 976         aEventTypeArg.EqualsLiteral("pointerleave") ||
 977         aEventTypeArg.EqualsLiteral("gotpointercapture") ||
 978         aEventTypeArg.EqualsLiteral("lostpointercapture") ||
 979         // touch events
 980         aEventTypeArg.EqualsLiteral("touchstart") ||
 981         aEventTypeArg.EqualsLiteral("touchend") ||
 982         aEventTypeArg.EqualsLiteral("touchmove") ||
 983         aEventTypeArg.EqualsLiteral("touchcancel") ||
 984         // UI legacy events
 985         aEventTypeArg.EqualsLiteral("DOMFocusIn") ||
 986         aEventTypeArg.EqualsLiteral("DOMFocusOut") ||
 987         aEventTypeArg.EqualsLiteral("DOMActivate") ||
 988         // wheel events
 989         aEventTypeArg.EqualsLiteral("wheel");
 990   }
 991
 992   void SetComposed(bool aComposed) { mFlags.mComposed = aComposed; }
 993
 994   void SetDefaultComposedInNativeAnonymousContent() {
 995     // For compatibility concerns, we set mComposedInNativeAnonymousContent to
 996     // false for those events we want to stop propagation.
 997     //
 998     // nsVideoFrame may create anonymous image element which fires eLoad,
 999     // eLoadStart, eLoadEnd, eLoadError. We don't want these events cross
1000     // the boundary of NAC
1001     mFlags.mComposedInNativeAnonymousContent =
1002         mMessage != eLoad && mMessage != eLoadStart && mMessage != eLoadEnd &&
1003         mMessage != eLoadError;
1004   }
1005
1006   bool IsUserAction() const;
1007 };
1008
1009 /******************************************************************************
1010  * mozilla::NativeEventData
1011  *
1012  * WidgetGUIEvent's mPluginEvent member used to be a void* pointer,
1013  * used to reference external, OS-specific data structures.
1014  *
1015  * That void* pointer wasn't serializable by itself, causing
1016  * certain plugin events not to function in e10s. See bug 586656.
1017  *
1018  * To make this serializable, we changed this void* pointer into
1019  * a proper buffer, and copy these external data structures into this
1020  * buffer.
1021  *
1022  * That buffer is NativeEventData::mBuffer below.
1023  *
1024  * We wrap this in that NativeEventData class providing operators to
1025  * be compatible with existing code that was written around
1026  * the old void* field.
1027  ******************************************************************************/
1028
1029 class NativeEventData final {
1030   CopyableTArray<uint8_t> mBuffer;
1031
1032   friend struct IPC::ParamTraits<mozilla::NativeEventData>;
1033
1034  public:
1035   explicit operator bool() const { return !mBuffer.IsEmpty(); }
1036
1037   template <typename T>
1038   explicit operator const T*() const {
1039     return mBuffer.IsEmpty() ? nullptr
1040                              : reinterpret_cast<const T*>(mBuffer.Elements());
1041   }
1042
1043   template <typename T>
1044   void Copy(const T& other) {
1045     static_assert(!std::is_pointer_v<T>, "Don't want a pointer!");
1046     mBuffer.SetLength(sizeof(T));
1047     memcpy(mBuffer.Elements(), &other, mBuffer.Length());
1048   }
1049
1050   void Clear() { mBuffer.Clear(); }
1051 };
1052
1053 /******************************************************************************
1054  * mozilla::WidgetGUIEvent
1055  ******************************************************************************/
1056
1057 class WidgetGUIEvent : public WidgetEvent {
1058  protected:
1059   WidgetGUIEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget,
1060                  EventClassID aEventClassID)
1061       : WidgetEvent(aIsTrusted, aMessage, aEventClassID), mWidget(aWidget) {}
1062
1063   WidgetGUIEvent() = default;
1064
1065  public:
1066   virtual WidgetGUIEvent* AsGUIEvent() override { return this; }
1067
1068   WidgetGUIEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget)
1069       : WidgetEvent(aIsTrusted, aMessage, eGUIEventClass), mWidget(aWidget) {}
1070
1071   virtual WidgetEvent* Duplicate() const override {
1072     MOZ_ASSERT(mClass == eGUIEventClass,
1073                "Duplicate() must be overridden by sub class");
1074     // Not copying widget, it is a weak reference.
1075     WidgetGUIEvent* result = new WidgetGUIEvent(false, mMessage, nullptr);
1076     result->AssignGUIEventData(*this, true);
1077     result->mFlags = mFlags;
1078     return result;
1079   }
1080
1081   // Originator of the event
1082   nsCOMPtr<nsIWidget> mWidget;
1083
1084   /*
1085    * Ideally though, we wouldn't allow arbitrary reinterpret_cast'ing here;
1086    * instead, we would at least store type information here so that
1087    * this class can't be used to reinterpret one structure type into another.
1088    * We can also wonder if it would be possible to properly extend
1089    * WidgetGUIEvent and other Event classes to remove the need for this
1090    * mPluginEvent field.
1091    */
1092   typedef NativeEventData PluginEvent;
1093
1094   // Event for NPAPI plugin
1095   PluginEvent mPluginEvent;
1096
1097   void AssignGUIEventData(const WidgetGUIEvent& aEvent, bool aCopyTargets) {
1098     AssignEventData(aEvent, aCopyTargets);
1099
1100     // widget should be initialized with the constructor.
1101
1102     mPluginEvent = aEvent.mPluginEvent;
1103   }
1104 };
1105
1106 /******************************************************************************
1107  * mozilla::Modifier
1108  *
1109  * All modifier keys should be defined here.  This is used for managing
1110  * modifier states for DOM Level 3 or later.
1111  ******************************************************************************/
1112
1113 enum Modifier {
1114   MODIFIER_NONE = 0x0000,
1115   MODIFIER_ALT = 0x0001,
1116   MODIFIER_ALTGRAPH = 0x0002,
1117   MODIFIER_CAPSLOCK = 0x0004,
1118   MODIFIER_CONTROL = 0x0008,
1119   MODIFIER_FN = 0x0010,
1120   MODIFIER_FNLOCK = 0x0020,
1121   MODIFIER_META = 0x0040,
1122   MODIFIER_NUMLOCK = 0x0080,
1123   MODIFIER_SCROLLLOCK = 0x0100,
1124   MODIFIER_SHIFT = 0x0200,
1125   MODIFIER_SYMBOL = 0x0400,
1126   MODIFIER_SYMBOLLOCK = 0x0800,
1127   MODIFIER_OS = 0x1000
1128 };
1129
1130 /******************************************************************************
1131  * Modifier key names.
1132  ******************************************************************************/
1133
1134 #define NS_DOM_KEYNAME_ALT "Alt"
1135 #define NS_DOM_KEYNAME_ALTGRAPH "AltGraph"
1136 #define NS_DOM_KEYNAME_CAPSLOCK "CapsLock"
1137 #define NS_DOM_KEYNAME_CONTROL "Control"
1138 #define NS_DOM_KEYNAME_FN "Fn"
1139 #define NS_DOM_KEYNAME_FNLOCK "FnLock"
1140 #define NS_DOM_KEYNAME_META "Meta"
1141 #define NS_DOM_KEYNAME_NUMLOCK "NumLock"
1142 #define NS_DOM_KEYNAME_SCROLLLOCK "ScrollLock"
1143 #define NS_DOM_KEYNAME_SHIFT "Shift"
1144 #define NS_DOM_KEYNAME_SYMBOL "Symbol"
1145 #define NS_DOM_KEYNAME_SYMBOLLOCK "SymbolLock"
1146 #define NS_DOM_KEYNAME_OS "OS"
1147
1148 /******************************************************************************
1149  * mozilla::Modifiers
1150  ******************************************************************************/
1151
1152 typedef uint16_t Modifiers;
1153
1154 class MOZ_STACK_CLASS GetModifiersName final : public nsAutoCString {
1155  public:
1156   explicit GetModifiersName(Modifiers aModifiers) {
1157     if (aModifiers & MODIFIER_ALT) {
1158       AssignLiteral(NS_DOM_KEYNAME_ALT);
1159     }
1160     if (aModifiers & MODIFIER_ALTGRAPH) {
1161       MaybeAppendSeparator();
1162       AppendLiteral(NS_DOM_KEYNAME_ALTGRAPH);
1163     }
1164     if (aModifiers & MODIFIER_CAPSLOCK) {
1165       MaybeAppendSeparator();
1166       AppendLiteral(NS_DOM_KEYNAME_CAPSLOCK);
1167     }
1168     if (aModifiers & MODIFIER_CONTROL) {
1169       MaybeAppendSeparator();
1170       AppendLiteral(NS_DOM_KEYNAME_CONTROL);
1171     }
1172     if (aModifiers & MODIFIER_FN) {
1173       MaybeAppendSeparator();
1174       AppendLiteral(NS_DOM_KEYNAME_FN);
1175     }
1176     if (aModifiers & MODIFIER_FNLOCK) {
1177       MaybeAppendSeparator();
1178       AppendLiteral(NS_DOM_KEYNAME_FNLOCK);
1179     }
1180     if (aModifiers & MODIFIER_META) {
1181       MaybeAppendSeparator();
1182       AppendLiteral(NS_DOM_KEYNAME_META);
1183     }
1184     if (aModifiers & MODIFIER_NUMLOCK) {
1185       MaybeAppendSeparator();
1186       AppendLiteral(NS_DOM_KEYNAME_NUMLOCK);
1187     }
1188     if (aModifiers & MODIFIER_SCROLLLOCK) {
1189       MaybeAppendSeparator();
1190       AppendLiteral(NS_DOM_KEYNAME_SCROLLLOCK);
1191     }
1192     if (aModifiers & MODIFIER_SHIFT) {
1193       MaybeAppendSeparator();
1194       AppendLiteral(NS_DOM_KEYNAME_SHIFT);
1195     }
1196     if (aModifiers & MODIFIER_SYMBOL) {
1197       MaybeAppendSeparator();
1198       AppendLiteral(NS_DOM_KEYNAME_SYMBOL);
1199     }
1200     if (aModifiers & MODIFIER_SYMBOLLOCK) {
1201       MaybeAppendSeparator();
1202       AppendLiteral(NS_DOM_KEYNAME_SYMBOLLOCK);
1203     }
1204     if (aModifiers & MODIFIER_OS) {
1205       MaybeAppendSeparator();
1206       AppendLiteral(NS_DOM_KEYNAME_OS);
1207     }
1208     if (IsEmpty()) {
1209       AssignLiteral("none");
1210     }
1211   }
1212
1213  private:
1214   void MaybeAppendSeparator() {
1215     if (!IsEmpty()) {
1216       AppendLiteral(" | ");
1217     }
1218   }
1219 };
1220
1221 /******************************************************************************
1222  * mozilla::WidgetInputEvent
1223  ******************************************************************************/
1224
1225 class WidgetInputEvent : public WidgetGUIEvent {
1226  protected:
1227   WidgetInputEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget,
1228                    EventClassID aEventClassID)
1229       : WidgetGUIEvent(aIsTrusted, aMessage, aWidget, aEventClassID),
1230         mModifiers(0) {}
1231
1232   WidgetInputEvent() : mModifiers(0) {}
1233
1234  public:
1235   virtual WidgetInputEvent* AsInputEvent() override { return this; }
1236
1237   WidgetInputEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget)
1238       : WidgetGUIEvent(aIsTrusted, aMessage, aWidget, eInputEventClass),
1239         mModifiers(0) {}
1240
1241   virtual WidgetEvent* Duplicate() const override {
1242     MOZ_ASSERT(mClass == eInputEventClass,
1243                "Duplicate() must be overridden by sub class");
1244     // Not copying widget, it is a weak reference.
1245     WidgetInputEvent* result = new WidgetInputEvent(false, mMessage, nullptr);
1246     result->AssignInputEventData(*this, true);
1247     result->mFlags = mFlags;
1248     return result;
1249   }
1250
1251   /**
1252    * Returns a modifier of "Accel" virtual modifier which is used for shortcut
1253    * key.
1254    */
1255   static Modifier AccelModifier();
1256
1257   /**
1258    * GetModifier() returns a modifier flag which is activated by aDOMKeyName.
1259    */
1260   static Modifier GetModifier(const nsAString& aDOMKeyName);
1261
1262   // true indicates the accel key on the environment is down
1263   bool IsAccel() const { return ((mModifiers & AccelModifier()) != 0); }
1264
1265   // true indicates the shift key is down
1266   bool IsShift() const { return ((mModifiers & MODIFIER_SHIFT) != 0); }
1267   // true indicates the control key is down
1268   bool IsControl() const { return ((mModifiers & MODIFIER_CONTROL) != 0); }
1269   // true indicates the alt key is down
1270   bool IsAlt() const { return ((mModifiers & MODIFIER_ALT) != 0); }
1271   // true indicates the meta key is down (or, on Mac, the Command key)
1272   bool IsMeta() const { return ((mModifiers & MODIFIER_META) != 0); }
1273   // true indicates the win key is down on Windows. Or the Super or Hyper key
1274   // is down on Linux.
1275   bool IsOS() const { return ((mModifiers & MODIFIER_OS) != 0); }
1276   // true indicates the alt graph key is down
1277   // NOTE: on Mac, the option key press causes both IsAlt() and IsAltGrpah()
1278   //       return true.
1279   bool IsAltGraph() const { return ((mModifiers & MODIFIER_ALTGRAPH) != 0); }
1280   // true indicates the CapLock LED is turn on.
1281   bool IsCapsLocked() const { return ((mModifiers & MODIFIER_CAPSLOCK) != 0); }
1282   // true indicates the NumLock LED is turn on.
1283   bool IsNumLocked() const { return ((mModifiers & MODIFIER_NUMLOCK) != 0); }
1284   // true indicates the ScrollLock LED is turn on.
1285   bool IsScrollLocked() const {
1286     return ((mModifiers & MODIFIER_SCROLLLOCK) != 0);
1287   }
1288
1289   // true indicates the Fn key is down, but this is not supported by native
1290   // key event on any platform.
1291   bool IsFn() const { return ((mModifiers & MODIFIER_FN) != 0); }
1292   // true indicates the FnLock LED is turn on, but we don't know such
1293   // keyboards nor platforms.
1294   bool IsFnLocked() const { return ((mModifiers & MODIFIER_FNLOCK) != 0); }
1295   // true indicates the Symbol is down, but this is not supported by native
1296   // key event on any platforms.
1297   bool IsSymbol() const { return ((mModifiers & MODIFIER_SYMBOL) != 0); }
1298   // true indicates the SymbolLock LED is turn on, but we don't know such
1299   // keyboards nor platforms.
1300   bool IsSymbolLocked() const {
1301     return ((mModifiers & MODIFIER_SYMBOLLOCK) != 0);
1302   }
1303
1304   void InitBasicModifiers(bool aCtrlKey, bool aAltKey, bool aShiftKey,
1305                           bool aMetaKey) {
1306     mModifiers = 0;
1307     if (aCtrlKey) {
1308       mModifiers |= MODIFIER_CONTROL;
1309     }
1310     if (aAltKey) {
1311       mModifiers |= MODIFIER_ALT;
1312     }
1313     if (aShiftKey) {
1314       mModifiers |= MODIFIER_SHIFT;
1315     }
1316     if (aMetaKey) {
1317       mModifiers |= MODIFIER_META;
1318     }
1319   }
1320
1321   Modifiers mModifiers;
1322
1323   void AssignInputEventData(const WidgetInputEvent& aEvent, bool aCopyTargets) {
1324     AssignGUIEventData(aEvent, aCopyTargets);
1325
1326     mModifiers = aEvent.mModifiers;
1327   }
1328 };
1329
1330 /******************************************************************************
1331  * mozilla::InternalUIEvent
1332  *
1333  * XXX Why this inherits WidgetGUIEvent rather than WidgetEvent?
1334  ******************************************************************************/
1335
1336 class InternalUIEvent : public WidgetGUIEvent {
1337  protected:
1338   InternalUIEvent() : mDetail(0), mCausedByUntrustedEvent(false) {}
1339
1340   InternalUIEvent(bool aIsTrusted, EventMessage aMessage, nsIWidget* aWidget,
1341                   EventClassID aEventClassID)
1342       : WidgetGUIEvent(aIsTrusted, aMessage, aWidget, aEventClassID),
1343         mDetail(0),
1344         mCausedByUntrustedEvent(false) {}
1345
1346   InternalUIEvent(bool aIsTrusted, EventMessage aMessage,
1347                   EventClassID aEventClassID)
1348       : WidgetGUIEvent(aIsTrusted, aMessage, nullptr, aEventClassID),
1349         mDetail(0),
1350         mCausedByUntrustedEvent(false) {}
1351
1352  public:
1353   virtual InternalUIEvent* AsUIEvent() override { return this; }
1354
1355   /**
1356    * If the UIEvent is caused by another event (e.g., click event),
1357    * aEventCausesThisEvent should be the event.  If there is no such event,
1358    * this should be nullptr.
1359    */
1360   InternalUIEvent(bool aIsTrusted, EventMessage aMessage,
1361                   const WidgetEvent* aEventCausesThisEvent)
1362       : WidgetGUIEvent(aIsTrusted, aMessage, nullptr, eUIEventClass),
1363         mDetail(0),
1364         mCausedByUntrustedEvent(aEventCausesThisEvent &&
1365                                 !aEventCausesThisEvent->IsTrusted()) {}
1366
1367   virtual WidgetEvent* Duplicate() const override {
1368     MOZ_ASSERT(mClass == eUIEventClass,
1369                "Duplicate() must be overridden by sub class");
1370     InternalUIEvent* result = new InternalUIEvent(false, mMessage, nullptr);
1371     result->AssignUIEventData(*this, true);
1372     result->mFlags = mFlags;
1373     return result;
1374   }
1375
1376   int32_t mDetail;
1377   // mCausedByUntrustedEvent is true if the event is caused by untrusted event.
1378   bool mCausedByUntrustedEvent;
1379
1380   // If you check the event is a trusted event and NOT caused by an untrusted
1381   // event, IsTrustable() returns what you expected.
1382   bool IsTrustable() const { return IsTrusted() && !mCausedByUntrustedEvent; }
1383
1384   void AssignUIEventData(const InternalUIEvent& aEvent, bool aCopyTargets) {
1385     AssignGUIEventData(aEvent, aCopyTargets);
1386
1387     mDetail = aEvent.mDetail;
1388     mCausedByUntrustedEvent = aEvent.mCausedByUntrustedEvent;
1389   }
1390 };
1391
1392 }  // namespace mozilla
1393
1394 #endif  // mozilla_BasicEvents_h__