dom/events/DOMEventTargetHelper.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 "nsContentUtils.h"
   8 #include "mozilla/dom/Document.h"
   9 #include "mozilla/Sprintf.h"
  10 #include "mozilla/dom/Event.h"
  11 #include "mozilla/DOMEventTargetHelper.h"
  12 #include "mozilla/EventDispatcher.h"
  13 #include "mozilla/EventListenerManager.h"
  14 #include "mozilla/Likely.h"
  15 #include "MainThreadUtils.h"
  16
  17 namespace mozilla {
  18
  19 using namespace dom;
  20
  21 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(DOMEventTargetHelper)
  22
  23 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(DOMEventTargetHelper)
  24   if (MOZ_UNLIKELY(cb.WantDebugInfo())) {
  25     char name[512];
  26     nsAutoString uri;
  27     if (tmp->GetOwner() && tmp->GetOwner()->GetExtantDoc()) {
  28       Unused << tmp->GetOwner()->GetExtantDoc()->GetDocumentURI(uri);
  29     }
  30
  31     nsXPCOMCycleCollectionParticipant* participant = nullptr;
  32     CallQueryInterface(tmp, &participant);
  33
  34     SprintfLiteral(name, "%s %s", participant->ClassName(),
  35                    NS_ConvertUTF16toUTF8(uri).get());
  36     cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name);
  37   } else {
  38     NS_IMPL_CYCLE_COLLECTION_DESCRIBE(DOMEventTargetHelper, tmp->mRefCnt.get())
  39   }
  40
  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   if (tmp->mListenerManager) {
  47     tmp->mListenerManager->Disconnect();
  48     NS_IMPL_CYCLE_COLLECTION_UNLINK(mListenerManager)
  49   }
  50   tmp->MaybeDontKeepAlive();
  51 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  52
  53 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(DOMEventTargetHelper)
  54   bool hasLiveWrapper = tmp->HasKnownLiveWrapper();
  55   if (hasLiveWrapper || tmp->IsCertainlyAliveForCC()) {
  56     if (tmp->mListenerManager) {
  57       tmp->mListenerManager->MarkForCC();
  58     }
  59     if (!hasLiveWrapper && tmp->PreservingWrapper()) {
  60       tmp->MarkWrapperLive();
  61     }
  62     return true;
  63   }
  64 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
  65
  66 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(DOMEventTargetHelper)
  67   return tmp->HasKnownLiveWrapperAndDoesNotNeedTracing(
  68       static_cast<dom::EventTarget*>(tmp));
  69 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
  70
  71 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(DOMEventTargetHelper)
  72   return tmp->HasKnownLiveWrapper();
  73 NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
  74
  75 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMEventTargetHelper)
  76   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
  77   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, EventTarget)
  78   NS_INTERFACE_MAP_ENTRY(GlobalTeardownObserver)
  79   NS_INTERFACE_MAP_ENTRY(dom::EventTarget)
  80   NS_INTERFACE_MAP_ENTRY_CONCRETE(DOMEventTargetHelper)
  81 NS_INTERFACE_MAP_END
  82
  83 NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMEventTargetHelper)
  84 NS_IMPL_CYCLE_COLLECTING_RELEASE_WITH_LAST_RELEASE(DOMEventTargetHelper,
  85                                                    LastRelease())
  86
  87 DOMEventTargetHelper::DOMEventTargetHelper() = default;
  88
  89 DOMEventTargetHelper::DOMEventTargetHelper(nsPIDOMWindowInner* aWindow)
  90     : GlobalTeardownObserver(aWindow ? aWindow->AsGlobal() : nullptr) {}
  91
  92 DOMEventTargetHelper::DOMEventTargetHelper(nsIGlobalObject* aGlobalObject)
  93     : GlobalTeardownObserver(aGlobalObject) {}
  94
  95 DOMEventTargetHelper::DOMEventTargetHelper(DOMEventTargetHelper* aOther)
  96     : GlobalTeardownObserver(aOther ? aOther->GetParentObject() : nullptr,
  97                              aOther ? aOther->HasOrHasHadOwner() : false) {}
  98
  99 DOMEventTargetHelper::~DOMEventTargetHelper() {
 100   if (mListenerManager) {
 101     mListenerManager->Disconnect();
 102   }
 103   ReleaseWrapper(this);
 104 }
 105
 106 void DOMEventTargetHelper::DisconnectFromOwner() {
 107   GlobalTeardownObserver::DisconnectFromOwner();
 108
 109   // Event listeners can't be handled anymore, so we can release them here.
 110   if (mListenerManager) {
 111     mListenerManager->Disconnect();
 112     mListenerManager = nullptr;
 113   }
 114
 115   MaybeDontKeepAlive();
 116 }
 117
 118 nsPIDOMWindowInner* DOMEventTargetHelper::GetWindowIfCurrent() const {
 119   if (NS_FAILED(CheckCurrentGlobalCorrectness())) {
 120     return nullptr;
 121   }
 122
 123   return GetOwner();
 124 }
 125
 126 Document* DOMEventTargetHelper::GetDocumentIfCurrent() const {
 127   nsPIDOMWindowInner* win = GetWindowIfCurrent();
 128   if (!win) {
 129     return nullptr;
 130   }
 131
 132   return win->GetDoc();
 133 }
 134
 135 bool DOMEventTargetHelper::ComputeDefaultWantsUntrusted(ErrorResult& aRv) {
 136   bool wantsUntrusted;
 137   nsresult rv = WantsUntrusted(&wantsUntrusted);
 138   if (NS_FAILED(rv)) {
 139     aRv.Throw(rv);
 140     return false;
 141   }
 142   return wantsUntrusted;
 143 }
 144
 145 bool DOMEventTargetHelper::DispatchEvent(Event& aEvent, CallerType aCallerType,
 146                                          ErrorResult& aRv) {
 147   nsEventStatus status = nsEventStatus_eIgnore;
 148   nsresult rv = EventDispatcher::DispatchDOMEvent(this, nullptr, &aEvent,
 149                                                   nullptr, &status);
 150   bool retval = !aEvent.DefaultPrevented(aCallerType);
 151   if (NS_FAILED(rv)) {
 152     aRv.Throw(rv);
 153   }
 154   return retval;
 155 }
 156
 157 nsresult DOMEventTargetHelper::DispatchTrustedEvent(
 158     const nsAString& aEventName) {
 159   RefPtr<Event> event = NS_NewDOMEvent(this, nullptr, nullptr);
 160   event->InitEvent(aEventName, false, false);
 161
 162   return DispatchTrustedEvent(event);
 163 }
 164
 165 nsresult DOMEventTargetHelper::DispatchTrustedEvent(Event* event) {
 166   event->SetTrusted(true);
 167
 168   ErrorResult rv;
 169   DispatchEvent(*event, rv);
 170   return rv.StealNSResult();
 171 }
 172
 173 void DOMEventTargetHelper::GetEventTargetParent(
 174     EventChainPreVisitor& aVisitor) {
 175   aVisitor.mCanHandle = true;
 176   aVisitor.SetParentTarget(nullptr, false);
 177 }
 178
 179 nsresult DOMEventTargetHelper::PostHandleEvent(
 180     EventChainPostVisitor& aVisitor) {
 181   return NS_OK;
 182 }
 183
 184 EventListenerManager* DOMEventTargetHelper::GetOrCreateListenerManager() {
 185   if (!mListenerManager) {
 186     mListenerManager = new EventListenerManager(this);
 187   }
 188
 189   return mListenerManager;
 190 }
 191
 192 EventListenerManager* DOMEventTargetHelper::GetExistingListenerManager() const {
 193   return mListenerManager;
 194 }
 195
 196 nsresult DOMEventTargetHelper::WantsUntrusted(bool* aRetVal) {
 197   nsresult rv = CheckCurrentGlobalCorrectness();
 198   NS_ENSURE_SUCCESS(rv, rv);
 199
 200   nsCOMPtr<Document> doc = GetDocumentIfCurrent();
 201   // We can let listeners on workers to always handle all the events.
 202   *aRetVal = (doc && !nsContentUtils::IsChromeDoc(doc)) || !NS_IsMainThread();
 203   return rv;
 204 }
 205
 206 void DOMEventTargetHelper::EventListenerAdded(nsAtom* aType) {
 207   MaybeUpdateKeepAlive();
 208 }
 209
 210 void DOMEventTargetHelper::EventListenerRemoved(nsAtom* aType) {
 211   MaybeUpdateKeepAlive();
 212 }
 213
 214 void DOMEventTargetHelper::KeepAliveIfHasListenersFor(nsAtom* aType) {
 215   mKeepingAliveTypes.AppendElement(aType);
 216   MaybeUpdateKeepAlive();
 217 }
 218
 219 void DOMEventTargetHelper::IgnoreKeepAliveIfHasListenersFor(nsAtom* aType) {
 220   mKeepingAliveTypes.RemoveElement(aType);
 221   MaybeUpdateKeepAlive();
 222 }
 223
 224 void DOMEventTargetHelper::MaybeUpdateKeepAlive() {
 225   bool shouldBeKeptAlive = false;
 226
 227   if (NS_SUCCEEDED(CheckCurrentGlobalCorrectness())) {
 228     if (!mKeepingAliveTypes.IsEmpty()) {
 229       for (uint32_t i = 0; i < mKeepingAliveTypes.Length(); ++i) {
 230         if (HasListenersFor(mKeepingAliveTypes[i])) {
 231           shouldBeKeptAlive = true;
 232           break;
 233         }
 234       }
 235     }
 236   }
 237
 238   if (shouldBeKeptAlive == mIsKeptAlive) {
 239     return;
 240   }
 241
 242   mIsKeptAlive = shouldBeKeptAlive;
 243   if (mIsKeptAlive) {
 244     AddRef();
 245   } else {
 246     Release();
 247   }
 248 }
 249
 250 void DOMEventTargetHelper::MaybeDontKeepAlive() {
 251   if (mIsKeptAlive) {
 252     mIsKeptAlive = false;
 253     Release();
 254   }
 255 }
 256
 257 bool DOMEventTargetHelper::HasListenersFor(const nsAString& aType) const {
 258   return mListenerManager && mListenerManager->HasListenersFor(aType);
 259 }
 260
 261 bool DOMEventTargetHelper::HasListenersFor(nsAtom* aTypeWithOn) const {
 262   return mListenerManager && mListenerManager->HasListenersFor(aTypeWithOn);
 263 }
 264
 265 }  // namespace mozilla