dom/events/EventTarget.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "mozilla/EventListenerManager.h"
   8 #include "mozilla/dom/EventTarget.h"
   9 #include "mozilla/dom/EventTargetBinding.h"
  10 #include "mozilla/dom/ConstructibleEventTarget.h"
  11 #include "mozilla/dom/Nullable.h"
  12 #include "mozilla/dom/WindowProxyHolder.h"
  13 #include "nsGlobalWindowInner.h"
  14 #include "nsGlobalWindowOuter.h"
  15 #include "nsIGlobalObject.h"
  16 #include "nsPIDOMWindow.h"
  17 #include "nsThreadUtils.h"
  18
  19 namespace mozilla::dom {
  20
  21 /* static */
  22 already_AddRefed<EventTarget> EventTarget::Constructor(
  23     const GlobalObject& aGlobal, ErrorResult& aRv) {
  24   nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(aGlobal.GetAsSupports());
  25   if (!global) {
  26     aRv.Throw(NS_ERROR_UNEXPECTED);
  27     return nullptr;
  28   }
  29   RefPtr<EventTarget> target = new ConstructibleEventTarget(global);
  30   return target.forget();
  31 }
  32
  33 bool EventTarget::ComputeWantsUntrusted(
  34     const Nullable<bool>& aWantsUntrusted,
  35     const AddEventListenerOptionsOrBoolean* aOptions, ErrorResult& aRv) {
  36   if (aOptions && aOptions->IsAddEventListenerOptions()) {
  37     const auto& options = aOptions->GetAsAddEventListenerOptions();
  38     if (options.mWantUntrusted.WasPassed()) {
  39       return options.mWantUntrusted.Value();
  40     }
  41   }
  42
  43   if (!aWantsUntrusted.IsNull()) {
  44     return aWantsUntrusted.Value();
  45   }
  46
  47   bool defaultWantsUntrusted = ComputeDefaultWantsUntrusted(aRv);
  48   if (aRv.Failed()) {
  49     return false;
  50   }
  51
  52   return defaultWantsUntrusted;
  53 }
  54
  55 void EventTarget::AddEventListener(
  56     const nsAString& aType, EventListener* aCallback,
  57     const AddEventListenerOptionsOrBoolean& aOptions,
  58     const Nullable<bool>& aWantsUntrusted, ErrorResult& aRv) {
  59   bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, &aOptions, aRv);
  60   if (aRv.Failed()) {
  61     return;
  62   }
  63
  64   EventListenerManager* elm = GetOrCreateListenerManager();
  65   if (!elm) {
  66     aRv.Throw(NS_ERROR_UNEXPECTED);
  67     return;
  68   }
  69
  70   elm->AddEventListener(aType, aCallback, aOptions, wantsUntrusted);
  71 }
  72
  73 nsresult EventTarget::AddEventListener(const nsAString& aType,
  74                                        nsIDOMEventListener* aListener,
  75                                        bool aUseCapture,
  76                                        const Nullable<bool>& aWantsUntrusted) {
  77   ErrorResult rv;
  78   bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, nullptr, rv);
  79   if (rv.Failed()) {
  80     return rv.StealNSResult();
  81   }
  82
  83   EventListenerManager* elm = GetOrCreateListenerManager();
  84   NS_ENSURE_STATE(elm);
  85   elm->AddEventListener(aType, aListener, aUseCapture, wantsUntrusted);
  86   return NS_OK;
  87 }
  88
  89 void EventTarget::RemoveEventListener(
  90     const nsAString& aType, EventListener* aListener,
  91     const EventListenerOptionsOrBoolean& aOptions, ErrorResult& aRv) {
  92   EventListenerManager* elm = GetExistingListenerManager();
  93   if (elm) {
  94     elm->RemoveEventListener(aType, aListener, aOptions);
  95   }
  96 }
  97
  98 void EventTarget::RemoveEventListener(const nsAString& aType,
  99                                       nsIDOMEventListener* aListener,
 100                                       bool aUseCapture) {
 101   EventListenerManager* elm = GetExistingListenerManager();
 102   if (elm) {
 103     elm->RemoveEventListener(aType, aListener, aUseCapture);
 104   }
 105 }
 106
 107 nsresult EventTarget::AddSystemEventListener(
 108     const nsAString& aType, nsIDOMEventListener* aListener, bool aUseCapture,
 109     const Nullable<bool>& aWantsUntrusted) {
 110   ErrorResult rv;
 111   bool wantsUntrusted = ComputeWantsUntrusted(aWantsUntrusted, nullptr, rv);
 112   if (rv.Failed()) {
 113     return rv.StealNSResult();
 114   }
 115
 116   EventListenerManager* elm = GetOrCreateListenerManager();
 117   NS_ENSURE_STATE(elm);
 118
 119   EventListenerFlags flags;
 120   flags.mInSystemGroup = true;
 121   flags.mCapture = aUseCapture;
 122   flags.mAllowUntrustedEvents = wantsUntrusted;
 123   elm->AddEventListenerByType(aListener, aType, flags);
 124   return NS_OK;
 125 }
 126
 127 void EventTarget::RemoveSystemEventListener(const nsAString& aType,
 128                                             nsIDOMEventListener* aListener,
 129                                             bool aUseCapture) {
 130   EventListenerManager* elm = GetExistingListenerManager();
 131   if (elm) {
 132     EventListenerFlags flags;
 133     flags.mInSystemGroup = true;
 134     flags.mCapture = aUseCapture;
 135     elm->RemoveEventListenerByType(aListener, aType, flags);
 136   }
 137 }
 138
 139 EventHandlerNonNull* EventTarget::GetEventHandler(nsAtom* aType) {
 140   EventListenerManager* elm = GetExistingListenerManager();
 141   return elm ? elm->GetEventHandler(aType) : nullptr;
 142 }
 143
 144 void EventTarget::SetEventHandler(const nsAString& aType,
 145                                   EventHandlerNonNull* aHandler,
 146                                   ErrorResult& aRv) {
 147   if (!StringBeginsWith(aType, u"on"_ns)) {
 148     aRv.Throw(NS_ERROR_INVALID_ARG);
 149     return;
 150   }
 151   RefPtr<nsAtom> type = NS_Atomize(aType);
 152   SetEventHandler(type, aHandler);
 153 }
 154
 155 void EventTarget::SetEventHandler(nsAtom* aType,
 156                                   EventHandlerNonNull* aHandler) {
 157   GetOrCreateListenerManager()->SetEventHandler(aType, aHandler);
 158 }
 159
 160 bool EventTarget::HasNonSystemGroupListenersForUntrustedKeyEvents() const {
 161   EventListenerManager* elm = GetExistingListenerManager();
 162   return elm && elm->HasNonSystemGroupListenersForUntrustedKeyEvents();
 163 }
 164
 165 bool EventTarget::HasNonPassiveNonSystemGroupListenersForUntrustedKeyEvents()
 166     const {
 167   EventListenerManager* elm = GetExistingListenerManager();
 168   return elm &&
 169          elm->HasNonPassiveNonSystemGroupListenersForUntrustedKeyEvents();
 170 }
 171
 172 bool EventTarget::IsApzAware() const {
 173   EventListenerManager* elm = GetExistingListenerManager();
 174   return elm && elm->HasApzAwareListeners();
 175 }
 176
 177 void EventTarget::DispatchEvent(Event& aEvent) {
 178   // The caller type doesn't really matter if we don't care about the
 179   // return value, but let's be safe and pass NonSystem.
 180   Unused << DispatchEvent(aEvent, CallerType::NonSystem, IgnoreErrors());
 181 }
 182
 183 void EventTarget::DispatchEvent(Event& aEvent, ErrorResult& aRv) {
 184   // The caller type doesn't really matter if we don't care about the
 185   // return value, but let's be safe and pass NonSystem.
 186   Unused << DispatchEvent(aEvent, CallerType::NonSystem, IgnoreErrors());
 187 }
 188
 189 Nullable<WindowProxyHolder> EventTarget::GetOwnerGlobalForBindings() {
 190   nsPIDOMWindowOuter* win = GetOwnerGlobalForBindingsInternal();
 191   if (!win) {
 192     return nullptr;
 193   }
 194
 195   return WindowProxyHolder(win->GetBrowsingContext());
 196 }
 197
 198 nsPIDOMWindowInner* EventTarget::GetAsWindowInner() {
 199   return IsInnerWindow() ? static_cast<nsGlobalWindowInner*>(this) : nullptr;
 200 }
 201
 202 const nsPIDOMWindowInner* EventTarget::GetAsWindowInner() const {
 203   return IsInnerWindow() ? static_cast<const nsGlobalWindowInner*>(this)
 204                          : nullptr;
 205 }
 206
 207 nsPIDOMWindowOuter* EventTarget::GetAsWindowOuter() {
 208   return IsOuterWindow() ? static_cast<nsGlobalWindowOuter*>(this) : nullptr;
 209 }
 210
 211 const nsPIDOMWindowOuter* EventTarget::GetAsWindowOuter() const {
 212   return IsOuterWindow() ? static_cast<const nsGlobalWindowOuter*>(this)
 213                          : nullptr;
 214 }
 215
 216 nsPIDOMWindowInner* EventTarget::AsWindowInner() {
 217   MOZ_DIAGNOSTIC_ASSERT(IsInnerWindow());
 218   return static_cast<nsGlobalWindowInner*>(this);
 219 }
 220
 221 const nsPIDOMWindowInner* EventTarget::AsWindowInner() const {
 222   MOZ_DIAGNOSTIC_ASSERT(IsInnerWindow());
 223   return static_cast<const nsGlobalWindowInner*>(this);
 224 }
 225
 226 nsPIDOMWindowOuter* EventTarget::AsWindowOuter() {
 227   MOZ_DIAGNOSTIC_ASSERT(IsOuterWindow());
 228   return static_cast<nsGlobalWindowOuter*>(this);
 229 }
 230
 231 const nsPIDOMWindowOuter* EventTarget::AsWindowOuter() const {
 232   MOZ_DIAGNOSTIC_ASSERT(IsOuterWindow());
 233   return static_cast<const nsGlobalWindowOuter*>(this);
 234 }
 235
 236 }  // namespace mozilla::dom