dom/events/DOMEventTargetHelper.cpp

   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 #include "nsContentUtils.h"
   7 #include "nsIDocument.h"
   8 #include "prprf.h"
   9 #include "nsGlobalWindow.h"
  10 #include "ScriptSettings.h"
  11 #include "mozilla/DOMEventTargetHelper.h"
  12 #include "mozilla/EventDispatcher.h"
  13 #include "mozilla/EventListenerManager.h"
  14 #include "mozilla/Likely.h"
  15
  16 namespace mozilla {
  17
  18 using namespace dom;
  19
  20 NS_IMPL_CYCLE_COLLECTION_CLASS(DOMEventTargetHelper)
  21
  22 NS_IMPL_CYCLE_COLLECTION_TRACE_BEGIN(DOMEventTargetHelper)
  23   NS_IMPL_CYCLE_COLLECTION_TRACE_PRESERVED_WRAPPER
  24 NS_IMPL_CYCLE_COLLECTION_TRACE_END
  25
  26 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(DOMEventTargetHelper)
  27   if (MOZ_UNLIKELY(cb.WantDebugInfo())) {
  28     char name[512];
  29     nsAutoString uri;
  30     if (tmp->mOwnerWindow && tmp->mOwnerWindow->GetExtantDoc()) {
  31       tmp->mOwnerWindow->GetExtantDoc()->GetDocumentURI(uri);
  32     }
  33     PR_snprintf(name, sizeof(name), "DOMEventTargetHelper %s",
  34                 NS_ConvertUTF16toUTF8(uri).get());
  35     cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name);
  36   } else {
  37     NS_IMPL_CYCLE_COLLECTION_DESCRIBE(DOMEventTargetHelper, tmp->mRefCnt.get())
  38   }
  39
  40   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
  41   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mListenerManager)
  42 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  43
  44 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(DOMEventTargetHelper)
  45   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
  46   NS_IMPL_CYCLE_COLLECTION_UNLINK(mListenerManager)
  47 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  48
  49 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(DOMEventTargetHelper)
  50   if (tmp->IsBlack()) {
  51     if (tmp->mListenerManager) {
  52       tmp->mListenerManager->MarkForCC();
  53     }
  54     return true;
  55   }
  56 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
  57
  58 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(DOMEventTargetHelper)
  59   return tmp->IsBlackAndDoesNotNeedTracing(tmp);
  60 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
  61
  62 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(DOMEventTargetHelper)
  63   return tmp->IsBlack();
  64 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
  65
  66 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMEventTargetHelper)
  67   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  68   NS_INTERFACE_MAP_ENTRY(nsISupports)
  69   NS_INTERFACE_MAP_ENTRY(nsIDOMEventTarget)
  70   NS_INTERFACE_MAP_ENTRY(dom::EventTarget)
  71   NS_INTERFACE_MAP_ENTRY(DOMEventTargetHelper)
  72 NS_INTERFACE_MAP_END
  73
  74 NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMEventTargetHelper)
  75 NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(DOMEventTargetHelper,
  76                                                    LastRelease())
  77
  78 NS_IMPL_DOMTARGET_DEFAULTS(DOMEventTargetHelper)
  79
  80 DOMEventTargetHelper::~DOMEventTargetHelper()
  81 {
  82   if (nsPIDOMWindow* owner = GetOwner()) {
  83     static_cast<nsGlobalWindow*>(owner)->RemoveEventTargetObject(this);
  84   }
  85   if (mListenerManager) {
  86     mListenerManager->Disconnect();
  87   }
  88   ReleaseWrapper(this);
  89 }
  90
  91 void
  92 DOMEventTargetHelper::BindToOwner(nsPIDOMWindow* aOwner)
  93 {
  94   MOZ_ASSERT_IF(aOwner, aOwner->IsInnerWindow());
  95   nsCOMPtr<nsIGlobalObject> glob = do_QueryInterface(aOwner);
  96   BindToOwner(glob);
  97 }
  98
  99 void
 100 DOMEventTargetHelper::BindToOwner(nsIGlobalObject* aOwner)
 101 {
 102   if (mParentObject) {
 103     if (mOwnerWindow) {
 104       static_cast<nsGlobalWindow*>(mOwnerWindow)->RemoveEventTargetObject(this);
 105       mOwnerWindow = nullptr;
 106     }
 107     mParentObject = nullptr;
 108     mHasOrHasHadOwnerWindow = false;
 109   }
 110   if (aOwner) {
 111     mParentObject = aOwner;
 112     // Let's cache the result of this QI for fast access and off main thread usage
 113     mOwnerWindow = nsCOMPtr<nsPIDOMWindow>(do_QueryInterface(aOwner)).get();
 114     if (mOwnerWindow) {
 115       MOZ_ASSERT(mOwnerWindow->IsInnerWindow());
 116       mHasOrHasHadOwnerWindow = true;
 117       static_cast<nsGlobalWindow*>(mOwnerWindow)->AddEventTargetObject(this);
 118     }
 119   }
 120 }
 121
 122 void
 123 DOMEventTargetHelper::BindToOwner(DOMEventTargetHelper* aOther)
 124 {
 125   if (mOwnerWindow) {
 126     static_cast<nsGlobalWindow*>(mOwnerWindow)->RemoveEventTargetObject(this);
 127     mOwnerWindow = nullptr;
 128     mParentObject = nullptr;
 129     mHasOrHasHadOwnerWindow = false;
 130   }
 131   if (aOther) {
 132     mHasOrHasHadOwnerWindow = aOther->HasOrHasHadOwner();
 133     if (aOther->GetParentObject()) {
 134       mParentObject = aOther->GetParentObject();
 135       // Let's cache the result of this QI for fast access and off main thread usage
 136       mOwnerWindow = nsCOMPtr<nsPIDOMWindow>(do_QueryInterface(mParentObject)).get();
 137       if (mOwnerWindow) {
 138         MOZ_ASSERT(mOwnerWindow->IsInnerWindow());
 139         mHasOrHasHadOwnerWindow = true;
 140         static_cast<nsGlobalWindow*>(mOwnerWindow)->AddEventTargetObject(this);
 141       }
 142     }
 143   }
 144 }
 145
 146 void
 147 DOMEventTargetHelper::DisconnectFromOwner()
 148 {
 149   mOwnerWindow = nullptr;
 150   mParentObject = nullptr;
 151   // Event listeners can't be handled anymore, so we can release them here.
 152   if (mListenerManager) {
 153     mListenerManager->Disconnect();
 154     mListenerManager = nullptr;
 155   }
 156 }
 157
 158 NS_IMETHODIMP
 159 DOMEventTargetHelper::RemoveEventListener(const nsAString& aType,
 160                                           nsIDOMEventListener* aListener,
 161                                           bool aUseCapture)
 162 {
 163   EventListenerManager* elm = GetExistingListenerManager();
 164   if (elm) {
 165     elm->RemoveEventListener(aType, aListener, aUseCapture);
 166   }
 167
 168   return NS_OK;
 169 }
 170
 171 NS_IMPL_REMOVE_SYSTEM_EVENT_LISTENER(DOMEventTargetHelper)
 172
 173 NS_IMETHODIMP
 174 DOMEventTargetHelper::AddEventListener(const nsAString& aType,
 175                                        nsIDOMEventListener* aListener,
 176                                        bool aUseCapture,
 177                                        bool aWantsUntrusted,
 178                                        uint8_t aOptionalArgc)
 179 {
 180   NS_ASSERTION(!aWantsUntrusted || aOptionalArgc > 1,
 181                "Won't check if this is chrome, you want to set "
 182                "aWantsUntrusted to false or make the aWantsUntrusted "
 183                "explicit by making aOptionalArgc non-zero.");
 184
 185   if (aOptionalArgc < 2) {
 186     nsresult rv = WantsUntrusted(&aWantsUntrusted);
 187     NS_ENSURE_SUCCESS(rv, rv);
 188   }
 189
 190   EventListenerManager* elm = GetOrCreateListenerManager();
 191   NS_ENSURE_STATE(elm);
 192   elm->AddEventListener(aType, aListener, aUseCapture, aWantsUntrusted);
 193   return NS_OK;
 194 }
 195
 196 void
 197 DOMEventTargetHelper::AddEventListener(const nsAString& aType,
 198                                        EventListener* aListener,
 199                                        bool aUseCapture,
 200                                        const Nullable<bool>& aWantsUntrusted,
 201                                        ErrorResult& aRv)
 202 {
 203   bool wantsUntrusted;
 204   if (aWantsUntrusted.IsNull()) {
 205     nsresult rv = WantsUntrusted(&wantsUntrusted);
 206     if (NS_FAILED(rv)) {
 207       aRv.Throw(rv);
 208       return;
 209     }
 210   } else {
 211     wantsUntrusted = aWantsUntrusted.Value();
 212   }
 213
 214   EventListenerManager* elm = GetOrCreateListenerManager();
 215   if (!elm) {
 216     aRv.Throw(NS_ERROR_UNEXPECTED);
 217     return;
 218   }
 219   elm->AddEventListener(aType, aListener, aUseCapture, wantsUntrusted);
 220 }
 221
 222 NS_IMETHODIMP
 223 DOMEventTargetHelper::AddSystemEventListener(const nsAString& aType,
 224                                              nsIDOMEventListener* aListener,
 225                                              bool aUseCapture,
 226                                              bool aWantsUntrusted,
 227                                              uint8_t aOptionalArgc)
 228 {
 229   NS_ASSERTION(!aWantsUntrusted || aOptionalArgc > 1,
 230                "Won't check if this is chrome, you want to set "
 231                "aWantsUntrusted to false or make the aWantsUntrusted "
 232                "explicit by making aOptionalArgc non-zero.");
 233
 234   if (aOptionalArgc < 2) {
 235     nsresult rv = WantsUntrusted(&aWantsUntrusted);
 236     NS_ENSURE_SUCCESS(rv, rv);
 237   }
 238
 239   return NS_AddSystemEventListener(this, aType, aListener, aUseCapture,
 240                                    aWantsUntrusted);
 241 }
 242
 243 NS_IMETHODIMP
 244 DOMEventTargetHelper::DispatchEvent(nsIDOMEvent* aEvent, bool* aRetVal)
 245 {
 246   nsEventStatus status = nsEventStatus_eIgnore;
 247   nsresult rv =
 248     EventDispatcher::DispatchDOMEvent(this, nullptr, aEvent, nullptr, &status);
 249
 250   *aRetVal = (status != nsEventStatus_eConsumeNoDefault);
 251   return rv;
 252 }
 253
 254 nsresult
 255 DOMEventTargetHelper::DispatchTrustedEvent(const nsAString& aEventName)
 256 {
 257   nsCOMPtr<nsIDOMEvent> event;
 258   NS_NewDOMEvent(getter_AddRefs(event), this, nullptr, nullptr);
 259   nsresult rv = event->InitEvent(aEventName, false, false);
 260   NS_ENSURE_SUCCESS(rv, rv);
 261
 262   return DispatchTrustedEvent(event);
 263 }
 264
 265 nsresult
 266 DOMEventTargetHelper::DispatchTrustedEvent(nsIDOMEvent* event)
 267 {
 268   event->SetTrusted(true);
 269
 270   bool dummy;
 271   return DispatchEvent(event, &dummy);
 272 }
 273
 274 nsresult
 275 DOMEventTargetHelper::SetEventHandler(nsIAtom* aType,
 276                                       JSContext* aCx,
 277                                       const JS::Value& aValue)
 278 {
 279   nsRefPtr<EventHandlerNonNull> handler;
 280   JS::Rooted<JSObject*> callable(aCx);
 281   if (aValue.isObject() && JS::IsCallable(callable = &aValue.toObject())) {
 282     handler = new EventHandlerNonNull(callable, dom::GetIncumbentGlobal());
 283   }
 284   SetEventHandler(aType, EmptyString(), handler);
 285   return NS_OK;
 286 }
 287
 288 void
 289 DOMEventTargetHelper::GetEventHandler(nsIAtom* aType,
 290                                       JSContext* aCx,
 291                                       JS::Value* aValue)
 292 {
 293   EventHandlerNonNull* handler = GetEventHandler(aType, EmptyString());
 294   if (handler) {
 295     *aValue = JS::ObjectValue(*handler->Callable());
 296   } else {
 297     *aValue = JS::NullValue();
 298   }
 299 }
 300
 301 nsresult
 302 DOMEventTargetHelper::PreHandleEvent(EventChainPreVisitor& aVisitor)
 303 {
 304   aVisitor.mCanHandle = true;
 305   aVisitor.mParentTarget = nullptr;
 306   return NS_OK;
 307 }
 308
 309 nsresult
 310 DOMEventTargetHelper::PostHandleEvent(EventChainPostVisitor& aVisitor)
 311 {
 312   return NS_OK;
 313 }
 314
 315 nsresult
 316 DOMEventTargetHelper::DispatchDOMEvent(WidgetEvent* aEvent,
 317                                        nsIDOMEvent* aDOMEvent,
 318                                        nsPresContext* aPresContext,
 319                                        nsEventStatus* aEventStatus)
 320 {
 321   return EventDispatcher::DispatchDOMEvent(this, aEvent, aDOMEvent,
 322                                            aPresContext, aEventStatus);
 323 }
 324
 325 EventListenerManager*
 326 DOMEventTargetHelper::GetOrCreateListenerManager()
 327 {
 328   if (!mListenerManager) {
 329     mListenerManager = new EventListenerManager(this);
 330   }
 331
 332   return mListenerManager;
 333 }
 334
 335 EventListenerManager*
 336 DOMEventTargetHelper::GetExistingListenerManager() const
 337 {
 338   return mListenerManager;
 339 }
 340
 341 nsIScriptContext*
 342 DOMEventTargetHelper::GetContextForEventHandlers(nsresult* aRv)
 343 {
 344   *aRv = CheckInnerWindowCorrectness();
 345   if (NS_FAILED(*aRv)) {
 346     return nullptr;
 347   }
 348   nsPIDOMWindow* owner = GetOwner();
 349   return owner ? static_cast<nsGlobalWindow*>(owner)->GetContextInternal()
 350                : nullptr;
 351 }
 352
 353 nsresult
 354 DOMEventTargetHelper::WantsUntrusted(bool* aRetVal)
 355 {
 356   nsresult rv;
 357   nsIScriptContext* context = GetContextForEventHandlers(&rv);
 358   NS_ENSURE_SUCCESS(rv, rv);
 359   nsCOMPtr<nsIDocument> doc =
 360     nsContentUtils::GetDocumentFromScriptContext(context);
 361   // We can let listeners on workers to always handle all the events.
 362   *aRetVal = (doc && !nsContentUtils::IsChromeDoc(doc)) || !NS_IsMainThread();
 363   return rv;
 364 }
 365
 366 void
 367 DOMEventTargetHelper::EventListenerAdded(nsIAtom* aType)
 368 {
 369   ErrorResult rv;
 370   EventListenerWasAdded(Substring(nsDependentAtomString(aType), 2), rv);
 371 }
 372
 373 void
 374 DOMEventTargetHelper::EventListenerRemoved(nsIAtom* aType)
 375 {
 376   ErrorResult rv;
 377   EventListenerWasRemoved(Substring(nsDependentAtomString(aType), 2), rv);
 378 }
 379
 380 } // namespace mozilla