From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- dom/promise/gtest/NativeThenHandler.cpp | 160 +++++++++++++++++++++ dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp | 158 ++++++++++++++++++++ dom/promise/gtest/moz.build | 14 ++ 3 files changed, 332 insertions(+) create mode 100644 dom/promise/gtest/NativeThenHandler.cpp create mode 100644 dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp create mode 100644 dom/promise/gtest/moz.build (limited to 'dom/promise/gtest') diff --git a/dom/promise/gtest/NativeThenHandler.cpp b/dom/promise/gtest/NativeThenHandler.cpp new file mode 100644 index 0000000000..13ed6d2c11 --- /dev/null +++ b/dom/promise/gtest/NativeThenHandler.cpp @@ -0,0 +1,160 @@ +/* -*- 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 "gtest/gtest.h" + +#include "js/TypeDecls.h" +#include "js/Value.h" +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/Promise-inl.h" +#include "xpcpublic.h" + +using namespace mozilla; +using namespace mozilla::dom; + +struct TraceCounts { + int32_t mValue = 0; + int32_t mId = 0; + int32_t mObject = 0; + int32_t mWrapperCache = 0; + int32_t mTenuredHeapObject = 0; + int32_t mString = 0; + int32_t mScript = 0; + int32_t mFunction = 0; +}; + +struct DummyCallbacks final : public TraceCallbacks { + void Trace(JS::Heap*, const char*, void* aClosure) const override { + static_cast(aClosure)->mValue++; + } + + void Trace(JS::Heap*, const char*, void* aClosure) const override { + static_cast(aClosure)->mId++; + } + + void Trace(JS::Heap*, const char*, void* aClosure) const override { + static_cast(aClosure)->mObject++; + } + + void Trace(nsWrapperCache*, const char* aName, + void* aClosure) const override { + static_cast(aClosure)->mWrapperCache++; + } + + void Trace(JS::TenuredHeap*, const char*, + void* aClosure) const override { + static_cast(aClosure)->mTenuredHeapObject++; + } + + void Trace(JS::Heap*, const char*, void* aClosure) const override { + static_cast(aClosure)->mString++; + } + + void Trace(JS::Heap*, const char*, void* aClosure) const override { + static_cast(aClosure)->mScript++; + } + + void Trace(JS::Heap*, const char*, + void* aClosure) const override { + static_cast(aClosure)->mFunction++; + } +}; + +TEST(NativeThenHandler, TraceValue) +{ + auto onResolve = [](JSContext*, JS::Handle, ErrorResult&, + JS::Handle) -> already_AddRefed { + return nullptr; + }; + auto onReject = [](JSContext*, JS::Handle, ErrorResult&, + JS::Handle) -> already_AddRefed { + return nullptr; + }; + + // Explicit type for backward compatibility with clang<7 / gcc<8 + using HandlerType = + NativeThenHandler, + std::tuple>; + RefPtr handler = new HandlerType( + nullptr, Some(onResolve), Some(onReject), std::make_tuple(), + std::make_tuple(JS::UndefinedHandleValue)); + + TraceCounts counts; + NS_CYCLE_COLLECTION_PARTICIPANT(HandlerType) + ->Trace(handler.get(), DummyCallbacks(), &counts); + + EXPECT_EQ(counts.mValue, 1); +} + +TEST(NativeThenHandler, TraceObject) +{ + auto onResolve = [](JSContext*, JS::Handle, ErrorResult&, + JS::Handle) -> already_AddRefed { + return nullptr; + }; + auto onReject = [](JSContext*, JS::Handle, ErrorResult&, + JS::Handle) -> already_AddRefed { + return nullptr; + }; + + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + JS::Rooted obj(cx, JS_NewPlainObject(cx)); + + // Explicit type for backward compatibility with clang<7 / gcc<8 + using HandlerType = + NativeThenHandler, + std::tuple>; + RefPtr handler = new HandlerType( + nullptr, Some(onResolve), Some(onReject), std::make_tuple(), + std::make_tuple(JS::HandleObject(obj))); + + TraceCounts counts; + NS_CYCLE_COLLECTION_PARTICIPANT(HandlerType) + ->Trace(handler.get(), DummyCallbacks(), &counts); + + EXPECT_EQ(counts.mObject, 1); +} + +TEST(NativeThenHandler, TraceMixed) +{ + auto onResolve = [](JSContext*, JS::Handle, ErrorResult&, + nsIGlobalObject*, Promise*, JS::Handle, + JS::Handle) -> already_AddRefed { + return nullptr; + }; + auto onReject = [](JSContext*, JS::Handle, ErrorResult&, + nsIGlobalObject*, Promise*, JS::Handle, + JS::Handle) -> already_AddRefed { + return nullptr; + }; + + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + nsCOMPtr global = xpc::CurrentNativeGlobal(cx); + JS::Rooted obj(cx, JS_NewPlainObject(cx)); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + + // Explicit type for backward compatibility with clang<7 / gcc<8 + using HandlerType = + NativeThenHandler, RefPtr>, + std::tuple>; + RefPtr handler = new HandlerType( + nullptr, Some(onResolve), Some(onReject), + std::make_tuple(global, promise), + std::make_tuple(JS::UndefinedHandleValue, JS::HandleObject(obj))); + + TraceCounts counts; + NS_CYCLE_COLLECTION_PARTICIPANT(HandlerType) + ->Trace(handler.get(), DummyCallbacks(), &counts); + + EXPECT_EQ(counts.mValue, 1); + EXPECT_EQ(counts.mObject, 1); +} diff --git a/dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp b/dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp new file mode 100644 index 0000000000..31b9fde3ca --- /dev/null +++ b/dom/promise/gtest/ThenWithCycleCollectedArgsJS.cpp @@ -0,0 +1,158 @@ +/* -*- 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 "gtest/gtest.h" + +#include "mozilla/dom/Promise.h" +#include "mozilla/dom/Promise-inl.h" +#include "xpcpublic.h" + +using namespace mozilla; +using namespace mozilla::dom; + +TEST(ThenWithCycleCollectedArgsJS, Empty) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&) { return nullptr; }, + std::make_tuple(), std::make_tuple()); +} + +TEST(ThenWithCycleCollectedArgsJS, nsCOMPtr) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&, nsIGlobalObject*) { + return nullptr; + }, + std::make_tuple(global), std::make_tuple()); +} + +TEST(ThenWithCycleCollectedArgsJS, RefPtr) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&, Promise*) { + return nullptr; + }, + std::make_tuple(promise), std::make_tuple()); +} + +TEST(ThenWithCycleCollectedArgsJS, RefPtrAndJSHandle) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle v, ErrorResult&, Promise*, + JS::Handle) { return nullptr; }, + std::make_tuple(promise), std::make_tuple(JS::UndefinedHandleValue)); +} + +TEST(ThenWithCycleCollectedArgsJS, Mixed) +{ + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + nsCOMPtr global = xpc::CurrentNativeGlobal(cx); + JS::Rooted obj(cx, JS_NewPlainObject(cx)); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&, nsIGlobalObject*, + Promise*, JS::Handle, + JS::Handle) { return nullptr; }, + std::make_tuple(global, promise), + std::make_tuple(JS::UndefinedHandleValue, JS::HandleObject(obj))); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, Empty) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&) { return nullptr; }, + [](JSContext*, JS::Handle, ErrorResult&) { return nullptr; }, + std::make_tuple(), std::make_tuple()); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, nsCOMPtr) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&, nsIGlobalObject*) { + return nullptr; + }, + [](JSContext*, JS::Handle, ErrorResult&, nsIGlobalObject*) { + return nullptr; + }, + std::make_tuple(global), std::make_tuple()); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, RefPtr) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&, Promise*) { + return nullptr; + }, + [](JSContext*, JS::Handle, ErrorResult&, Promise*) { + return nullptr; + }, + std::make_tuple(promise), std::make_tuple()); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, RefPtrAndJSHandle) +{ + nsCOMPtr global = + xpc::NativeGlobal(xpc::PrivilegedJunkScope()); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle v, ErrorResult&, Promise*, + JS::Handle) { return nullptr; }, + [](JSContext*, JS::Handle v, ErrorResult&, Promise*, + JS::Handle) { return nullptr; }, + std::make_tuple(promise), std::make_tuple(JS::UndefinedHandleValue)); +} + +TEST(ThenCatchWithCycleCollectedArgsJS, Mixed) +{ + AutoJSAPI jsapi; + MOZ_ALWAYS_TRUE(jsapi.Init(xpc::PrivilegedJunkScope())); + JSContext* cx = jsapi.cx(); + nsCOMPtr global = xpc::CurrentNativeGlobal(cx); + JS::Rooted obj(cx, JS_NewPlainObject(cx)); + + RefPtr promise = Promise::Create(global, IgnoreErrors()); + auto result = promise->ThenCatchWithCycleCollectedArgsJS( + [](JSContext*, JS::Handle, ErrorResult&, nsIGlobalObject*, + Promise*, JS::Handle, + JS::Handle) { return nullptr; }, + [](JSContext*, JS::Handle, ErrorResult&, nsIGlobalObject*, + Promise*, JS::Handle, + JS::Handle) { return nullptr; }, + std::make_tuple(global, promise), + std::make_tuple(JS::UndefinedHandleValue, JS::HandleObject(obj))); +} diff --git a/dom/promise/gtest/moz.build b/dom/promise/gtest/moz.build new file mode 100644 index 0000000000..a220822834 --- /dev/null +++ b/dom/promise/gtest/moz.build @@ -0,0 +1,14 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# 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/. + +UNIFIED_SOURCES += [ + "NativeThenHandler.cpp", + "ThenWithCycleCollectedArgsJS.cpp", +] + +LOCAL_INCLUDES += ["/dom/promise"] + +FINAL_LIBRARY = "xul-gtest" -- cgit v1.2.3