summaryrefslogtreecommitdiffstats
path: root/dom/events/JSEventHandler.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:22:09 +0000
commit43a97878ce14b72f0981164f87f2e35e14151312 (patch)
tree620249daf56c0258faa40cbdcf9cfba06de2a846 /dom/events/JSEventHandler.cpp
parentInitial commit. (diff)
downloadfirefox-upstream.tar.xz
firefox-upstream.zip
Adding upstream version 110.0.1.upstream/110.0.1upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'dom/events/JSEventHandler.cpp')
-rw-r--r--dom/events/JSEventHandler.cpp229
1 files changed, 229 insertions, 0 deletions
diff --git a/dom/events/JSEventHandler.cpp b/dom/events/JSEventHandler.cpp
new file mode 100644
index 0000000000..8304ec6582
--- /dev/null
+++ b/dom/events/JSEventHandler.cpp
@@ -0,0 +1,229 @@
+/* -*- 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 http://mozilla.org/MPL/2.0/. */
+#include "nsJSUtils.h"
+#include "nsString.h"
+#include "nsIScriptContext.h"
+#include "nsIScriptGlobalObject.h"
+#include "nsVariant.h"
+#include "nsGkAtoms.h"
+#include "xpcpublic.h"
+#include "nsJSEnvironment.h"
+#include "nsDOMJSUtils.h"
+#include "mozilla/ContentEvents.h"
+#include "mozilla/CycleCollectedJSContext.h"
+#include "mozilla/HoldDropJSObjects.h"
+#include "mozilla/JSEventHandler.h"
+#include "mozilla/Likely.h"
+#include "mozilla/dom/BeforeUnloadEvent.h"
+#include "mozilla/dom/ErrorEvent.h"
+#include "mozilla/dom/WorkerPrivate.h"
+
+namespace mozilla {
+
+using namespace dom;
+
+JSEventHandler::JSEventHandler(EventTarget* aTarget, nsAtom* aType,
+ const TypedEventHandler& aTypedHandler)
+ : mTarget(aTarget), mEventName(aType), mTypedHandler(aTypedHandler) {
+ // Note, we call HoldJSObjects to get CanSkip called before CC.
+ HoldJSObjects(this);
+}
+
+JSEventHandler::~JSEventHandler() {
+ NS_ASSERTION(!mTarget, "Should have called Disconnect()!");
+ DropJSObjects(this);
+}
+
+NS_IMPL_CYCLE_COLLECTION_CLASS(JSEventHandler)
+
+NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(JSEventHandler)
+ tmp->mTypedHandler.ForgetHandler();
+NS_IMPL_CYCLE_COLLECTION_UNLINK_END
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INTERNAL(JSEventHandler)
+ if (MOZ_UNLIKELY(cb.WantDebugInfo()) && tmp->mEventName) {
+ nsAutoCString name;
+ name.AppendLiteral("JSEventHandler handlerName=");
+ name.Append(
+ NS_ConvertUTF16toUTF8(nsDependentAtomString(tmp->mEventName)).get());
+ cb.DescribeRefCountedNode(tmp->mRefCnt.get(), name.get());
+ } else {
+ NS_IMPL_CYCLE_COLLECTION_DESCRIBE(JSEventHandler, tmp->mRefCnt.get())
+ }
+ NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mTypedHandler.Ptr())
+NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_BEGIN(JSEventHandler)
+ if (tmp->IsBlackForCC()) {
+ return true;
+ }
+ // If we have a target, it is the one which has tmp as onfoo handler.
+ if (tmp->mTarget) {
+ nsXPCOMCycleCollectionParticipant* cp = nullptr;
+ CallQueryInterface(tmp->mTarget, &cp);
+ nsISupports* canonical = nullptr;
+ tmp->mTarget->QueryInterface(NS_GET_IID(nsCycleCollectionISupports),
+ reinterpret_cast<void**>(&canonical));
+ // Usually CanSkip ends up unmarking the event listeners of mTarget,
+ // so tmp may become black.
+ if (cp && canonical && cp->CanSkip(canonical, true)) {
+ return tmp->IsBlackForCC();
+ }
+ }
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_BEGIN(JSEventHandler)
+ return tmp->IsBlackForCC();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_IN_CC_END
+
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_BEGIN(JSEventHandler)
+ return tmp->IsBlackForCC();
+NS_IMPL_CYCLE_COLLECTION_CAN_SKIP_THIS_END
+
+NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(JSEventHandler)
+ NS_INTERFACE_MAP_ENTRY(nsIDOMEventListener)
+ NS_INTERFACE_MAP_ENTRY(nsISupports)
+ NS_INTERFACE_MAP_ENTRY(JSEventHandler)
+NS_INTERFACE_MAP_END
+
+NS_IMPL_CYCLE_COLLECTING_ADDREF(JSEventHandler)
+NS_IMPL_CYCLE_COLLECTING_RELEASE(JSEventHandler)
+
+bool JSEventHandler::IsBlackForCC() {
+ // We can claim to be black if all the things we reference are
+ // effectively black already.
+ return !mTypedHandler.HasEventHandler() ||
+ mTypedHandler.Ptr()->IsBlackForCC();
+}
+
+nsresult JSEventHandler::HandleEvent(Event* aEvent) {
+ nsCOMPtr<EventTarget> target = mTarget;
+ if (!target || !mTypedHandler.HasEventHandler() ||
+ !GetTypedEventHandler().Ptr()->CallbackPreserveColor()) {
+ return NS_ERROR_FAILURE;
+ }
+
+ bool isMainThread = aEvent->IsMainThreadEvent();
+ bool isChromeHandler =
+ isMainThread
+ ? nsContentUtils::ObjectPrincipal(
+ GetTypedEventHandler().Ptr()->CallbackGlobalOrNull()) ==
+ nsContentUtils::GetSystemPrincipal()
+ : mozilla::dom::IsCurrentThreadRunningChromeWorker();
+
+ if (mTypedHandler.Type() == TypedEventHandler::eOnError) {
+ MOZ_ASSERT_IF(mEventName, mEventName == nsGkAtoms::onerror);
+
+ nsString errorMsg, file;
+ EventOrString msgOrEvent;
+ Optional<nsAString> fileName;
+ Optional<uint32_t> lineNumber;
+ Optional<uint32_t> columnNumber;
+ Optional<JS::Handle<JS::Value>> error;
+
+ NS_ENSURE_TRUE(aEvent, NS_ERROR_UNEXPECTED);
+ ErrorEvent* scriptEvent = aEvent->AsErrorEvent();
+ if (scriptEvent) {
+ scriptEvent->GetMessage(errorMsg);
+ msgOrEvent.SetAsString().ShareOrDependUpon(errorMsg);
+
+ scriptEvent->GetFilename(file);
+ fileName = &file;
+
+ lineNumber.Construct();
+ lineNumber.Value() = scriptEvent->Lineno();
+
+ columnNumber.Construct();
+ columnNumber.Value() = scriptEvent->Colno();
+
+ error.Construct(RootingCx());
+ scriptEvent->GetError(&error.Value());
+ } else {
+ msgOrEvent.SetAsEvent() = aEvent;
+ }
+
+ RefPtr<OnErrorEventHandlerNonNull> handler =
+ mTypedHandler.OnErrorEventHandler();
+ ErrorResult rv;
+ JS::Rooted<JS::Value> retval(RootingCx());
+ handler->Call(target, msgOrEvent, fileName, lineNumber, columnNumber, error,
+ &retval, rv);
+ if (rv.Failed()) {
+ return rv.StealNSResult();
+ }
+
+ if (retval.isBoolean() && retval.toBoolean() == bool(scriptEvent)) {
+ aEvent->PreventDefaultInternal(isChromeHandler);
+ }
+ return NS_OK;
+ }
+
+ if (mTypedHandler.Type() == TypedEventHandler::eOnBeforeUnload) {
+ MOZ_ASSERT(mEventName == nsGkAtoms::onbeforeunload);
+
+ RefPtr<OnBeforeUnloadEventHandlerNonNull> handler =
+ mTypedHandler.OnBeforeUnloadEventHandler();
+ ErrorResult rv;
+ nsString retval;
+ handler->Call(target, *aEvent, retval, rv);
+ if (rv.Failed()) {
+ return rv.StealNSResult();
+ }
+
+ BeforeUnloadEvent* beforeUnload = aEvent->AsBeforeUnloadEvent();
+ NS_ENSURE_STATE(beforeUnload);
+
+ if (!DOMStringIsNull(retval)) {
+ aEvent->PreventDefaultInternal(isChromeHandler);
+
+ nsAutoString text;
+ beforeUnload->GetReturnValue(text);
+
+ // Set the text in the beforeUnload event as long as it wasn't
+ // already set (through event.returnValue, which takes
+ // precedence over a value returned from a JS function in IE)
+ if (text.IsEmpty()) {
+ beforeUnload->SetReturnValue(retval);
+ }
+ }
+
+ return NS_OK;
+ }
+
+ MOZ_ASSERT(mTypedHandler.Type() == TypedEventHandler::eNormal);
+ ErrorResult rv;
+ RefPtr<EventHandlerNonNull> handler = mTypedHandler.NormalEventHandler();
+ JS::Rooted<JS::Value> retval(RootingCx());
+ handler->Call(target, *aEvent, &retval, rv);
+ if (rv.Failed()) {
+ return rv.StealNSResult();
+ }
+
+ // If the handler returned false, then prevent default.
+ if (retval.isBoolean() && !retval.toBoolean()) {
+ aEvent->PreventDefaultInternal(isChromeHandler);
+ }
+
+ return NS_OK;
+}
+
+} // namespace mozilla
+
+using namespace mozilla;
+
+/*
+ * Factory functions
+ */
+
+nsresult NS_NewJSEventHandler(mozilla::dom::EventTarget* aTarget,
+ nsAtom* aEventType,
+ const TypedEventHandler& aTypedHandler,
+ JSEventHandler** aReturn) {
+ NS_ENSURE_ARG(aEventType || !NS_IsMainThread());
+ JSEventHandler* it = new JSEventHandler(aTarget, aEventType, aTypedHandler);
+ NS_ADDREF(*aReturn = it);
+
+ return NS_OK;
+}