commit 6d8788fd15726d8661d6f1a37cc276cc4acd833c
parent 7326d5e59a3b5816e5597a1e3e8ee095b6d602d7
Author: Matthew Gaudet <mgaudet@mozilla.com>
Date: Mon, 10 Nov 2025 23:09:50 +0000
Bug 1993582 - Rename JS::MicroTask to JS::GenericMicroTask r=arai
Differential Revision: https://phabricator.services.mozilla.com/D271832
Diffstat:
6 files changed, 64 insertions(+), 54 deletions(-)
diff --git a/js/public/friend/MicroTask.h b/js/public/friend/MicroTask.h
@@ -58,15 +58,16 @@ namespace JS {
//
// An embedding is free to do with non-JS MicroTasks as it
// sees fit.
-using MicroTask = JS::Value;
+using GenericMicroTask = JS::Value;
-JS_PUBLIC_API bool IsJSMicroTask(const JS::MicroTask& hv);
+JS_PUBLIC_API bool IsJSMicroTask(const JS::GenericMicroTask& hv);
// Run a MicroTask that is known to be a JS MicroTask. This will crash
// if provided an invalid task kind.
//
// This will return false if an exception is thrown while processing.
-JS_PUBLIC_API bool RunJSMicroTask(JSContext* cx, Handle<MicroTask> entry);
+JS_PUBLIC_API bool RunJSMicroTask(JSContext* cx,
+ Handle<GenericMicroTask> entry);
// Queue Management. This is done per-JSContext.
//
@@ -82,9 +83,12 @@ JS_PUBLIC_API bool RunJSMicroTask(JSContext* cx, Handle<MicroTask> entry);
// patterns used by Gecko.
//
// These methods only fail for OOM.
-JS_PUBLIC_API bool EnqueueMicroTask(JSContext* cx, const MicroTask& entry);
-JS_PUBLIC_API bool EnqueueDebugMicroTask(JSContext* cx, const MicroTask& entry);
-JS_PUBLIC_API bool PrependMicroTask(JSContext* cx, const MicroTask& entry);
+JS_PUBLIC_API bool EnqueueMicroTask(JSContext* cx,
+ const GenericMicroTask& entry);
+JS_PUBLIC_API bool EnqueueDebugMicroTask(JSContext* cx,
+ const GenericMicroTask& entry);
+JS_PUBLIC_API bool PrependMicroTask(JSContext* cx,
+ const GenericMicroTask& entry);
// Dequeue the next MicroTask. If there are no MicroTasks of the appropriate
// kind, each of the below API returns JS::NullValue().
@@ -100,9 +104,9 @@ JS_PUBLIC_API bool PrependMicroTask(JSContext* cx, const MicroTask& entry);
//
// so checking for emptiness before calling these is not required, and is
// very slightly less efficient.
-JS_PUBLIC_API MicroTask DequeueNextMicroTask(JSContext* cx);
-JS_PUBLIC_API MicroTask DequeueNextDebuggerMicroTask(JSContext* cx);
-JS_PUBLIC_API MicroTask DequeueNextRegularMicroTask(JSContext* cx);
+JS_PUBLIC_API GenericMicroTask DequeueNextMicroTask(JSContext* cx);
+JS_PUBLIC_API GenericMicroTask DequeueNextDebuggerMicroTask(JSContext* cx);
+JS_PUBLIC_API GenericMicroTask DequeueNextRegularMicroTask(JSContext* cx);
// Returns true if there are -any- microtasks pending in the queue.
JS_PUBLIC_API bool HasAnyMicroTasks(JSContext* cx);
@@ -119,7 +123,7 @@ JS_PUBLIC_API size_t GetRegularMicroTaskCount(JSContext* cx);
// This is the global associated with the realm RunJSMicroTask expects to be in.
JS_PUBLIC_API JSObject* GetExecutionGlobalFromJSMicroTask(
- const MicroTask& entry);
+ const GenericMicroTask& entry);
// To handle cases where the queue needs to be set aside for some reason
// (mostly the Debugger API), we provide a Save and Restore API.
@@ -148,21 +152,22 @@ JS_PUBLIC_API void RestoreMicroTaskQueue(
// All of these may return null if there's no data, or if there's a
// security error.
JS_PUBLIC_API JSObject* MaybeGetHostDefinedDataFromJSMicroTask(
- const MicroTask& entry);
+ const GenericMicroTask& entry);
JS_PUBLIC_API JSObject* MaybeGetAllocationSiteFromJSMicroTask(
- const MicroTask& entry);
+ const GenericMicroTask& entry);
// In some circumstances an entry may not have host defined data but may
// still have a host defined global;
JS_PUBLIC_API JSObject* MaybeGetHostDefinedGlobalFromJSMicroTask(
- const MicroTask& entry);
+ const GenericMicroTask& entry);
-JS_PUBLIC_API JSObject* MaybeGetPromiseFromJSMicroTask(const MicroTask& entry);
+JS_PUBLIC_API JSObject* MaybeGetPromiseFromJSMicroTask(
+ const GenericMicroTask& entry);
// Get the flow ID from a JS microtask for profiler markers.
// This only returns false if entry has become a dead wrapper,
// in which case the microtask doesn't run anyhow.
-JS_PUBLIC_API bool GetFlowIdFromJSMicroTask(const MicroTask& entry,
+JS_PUBLIC_API bool GetFlowIdFromJSMicroTask(const GenericMicroTask& entry,
uint64_t* uid);
} // namespace JS
diff --git a/js/src/builtin/Promise.cpp b/js/src/builtin/Promise.cpp
@@ -1678,7 +1678,7 @@ static bool ResolvePromiseFunction(JSContext* cx, unsigned argc, Value* vp) {
return true;
}
-static bool EnqueueJob(JSContext* cx, JS::MicroTask&& job) {
+static bool EnqueueJob(JSContext* cx, JS::GenericMicroTask&& job) {
MOZ_ASSERT(cx->realm());
GeckoProfilerRuntime& profiler = cx->runtime()->geckoProfiler();
if (profiler.enabled()) {
@@ -7633,7 +7633,8 @@ void PromiseObject::dumpOwnStringContent(js::GenericPrinter& out) const {}
return true;
}
-JS_PUBLIC_API bool JS::RunJSMicroTask(JSContext* cx, Handle<MicroTask> entry) {
+JS_PUBLIC_API bool JS::RunJSMicroTask(JSContext* cx,
+ Handle<JS::GenericMicroTask> entry) {
#ifdef DEBUG
MOZ_ASSERT(entry.isObject());
JSObject* global = JS::GetExecutionGlobalFromJSMicroTask(entry);
@@ -7691,7 +7692,7 @@ inline bool JSObject::is<MicroTaskEntry>() const {
}
JS_PUBLIC_API JSObject* JS::MaybeGetHostDefinedDataFromJSMicroTask(
- const MicroTask& entry) {
+ const JS::GenericMicroTask& entry) {
if (!entry.isObject()) {
return nullptr;
}
@@ -7714,7 +7715,7 @@ JS_PUBLIC_API JSObject* JS::MaybeGetHostDefinedDataFromJSMicroTask(
}
JS_PUBLIC_API JSObject* JS::MaybeGetAllocationSiteFromJSMicroTask(
- const MicroTask& entry) {
+ const JS::GenericMicroTask& entry) {
if (!entry.isObject()) {
return nullptr;
}
@@ -7739,7 +7740,7 @@ JS_PUBLIC_API JSObject* JS::MaybeGetAllocationSiteFromJSMicroTask(
}
JS_PUBLIC_API JSObject* JS::MaybeGetHostDefinedGlobalFromJSMicroTask(
- const MicroTask& entry) {
+ const JS::GenericMicroTask& entry) {
if (!entry.isObject()) {
return nullptr;
}
@@ -7758,7 +7759,7 @@ JS_PUBLIC_API JSObject* JS::MaybeGetHostDefinedGlobalFromJSMicroTask(
}
JS_PUBLIC_API JSObject* JS::GetExecutionGlobalFromJSMicroTask(
- const MicroTask& entry) {
+ const JS::GenericMicroTask& entry) {
MOZ_RELEASE_ASSERT(entry.isObject(), "Only use on JSMicroTasks");
JSObject* unwrapped = UncheckedUnwrap(&entry.toObject());
@@ -7790,7 +7791,7 @@ JS_PUBLIC_API JSObject* JS::GetExecutionGlobalFromJSMicroTask(
}
JS_PUBLIC_API JSObject* JS::MaybeGetPromiseFromJSMicroTask(
- const MicroTask& entry) {
+ const JS::GenericMicroTask& entry) {
MOZ_RELEASE_ASSERT(entry.isObject(), "Only use on JSMicroTasks");
JSObject* unwrapped = UncheckedUnwrap(&entry.toObject());
@@ -7804,8 +7805,8 @@ JS_PUBLIC_API JSObject* JS::MaybeGetPromiseFromJSMicroTask(
return nullptr;
}
-JS_PUBLIC_API bool JS::GetFlowIdFromJSMicroTask(const MicroTask& entry,
- uint64_t* uid) {
+JS_PUBLIC_API bool JS::GetFlowIdFromJSMicroTask(
+ const JS::GenericMicroTask& entry, uint64_t* uid) {
MOZ_RELEASE_ASSERT(entry.isObject(), "Only use on JSMicroTasks");
// We want to make sure we get the flow id from the target object
@@ -7821,7 +7822,7 @@ JS_PUBLIC_API bool JS::GetFlowIdFromJSMicroTask(const MicroTask& entry,
return true;
}
-JS_PUBLIC_API bool JS::IsJSMicroTask(const JS::MicroTask& hv) {
+JS_PUBLIC_API bool JS::IsJSMicroTask(const JS::GenericMicroTask& hv) {
if (!hv.isObject()) {
return false;
}
diff --git a/js/src/vm/JSContext.cpp b/js/src/vm/JSContext.cpp
@@ -890,7 +890,7 @@ void InternalJobQueue::runJobs(JSContext* cx) {
if (JS::Prefs::use_js_microtask_queue()) {
// Execute jobs in a loop until we've reached the end of the queue.
- JS::Rooted<JS::MicroTask> job(cx);
+ JS::Rooted<JS::GenericMicroTask> job(cx);
while (JS::HasAnyMicroTasks(cx)) {
MOZ_ASSERT(queue.empty());
// A previous job might have set this flag. E.g., the js shell
@@ -1070,7 +1070,7 @@ void js::MicroTaskQueueElement::trace(JSTracer* trc) {
}
}
-JS::MicroTask js::MicroTaskQueueSet::popDebugFront() {
+JS::GenericMicroTask js::MicroTaskQueueSet::popDebugFront() {
JS_LOG(mtq, Info, "JS Drain Queue: popDebugFront");
if (!debugMicroTaskQueue.empty()) {
JS::Value p = debugMicroTaskQueue.front();
@@ -1080,7 +1080,7 @@ JS::MicroTask js::MicroTaskQueueSet::popDebugFront() {
return JS::NullValue();
}
-JS::MicroTask js::MicroTaskQueueSet::popFront() {
+JS::GenericMicroTask js::MicroTaskQueueSet::popFront() {
JS_LOG(mtq, Info, "JS Drain Queue");
if (!debugMicroTaskQueue.empty()) {
JS::Value p = debugMicroTaskQueue.front();
@@ -1097,49 +1097,52 @@ JS::MicroTask js::MicroTaskQueueSet::popFront() {
}
bool js::MicroTaskQueueSet::enqueueRegularMicroTask(
- JSContext* cx, const JS::MicroTask& entry) {
+ JSContext* cx, const JS::GenericMicroTask& entry) {
JS_LOG(mtq, Verbose, "JS: Enqueue Regular MT");
JS::JobQueueMayNotBeEmpty(cx);
return microTaskQueue.pushBack(entry);
}
bool js::MicroTaskQueueSet::prependRegularMicroTask(
- JSContext* cx, const JS::MicroTask& entry) {
+ JSContext* cx, const JS::GenericMicroTask& entry) {
JS_LOG(mtq, Verbose, "JS: Prepend Regular MT");
JS::JobQueueMayNotBeEmpty(cx);
return microTaskQueue.emplaceFront(entry);
}
-bool js::MicroTaskQueueSet::enqueueDebugMicroTask(JSContext* cx,
- const JS::MicroTask& entry) {
+bool js::MicroTaskQueueSet::enqueueDebugMicroTask(
+ JSContext* cx, const JS::GenericMicroTask& entry) {
JS_LOG(mtq, Verbose, "JS: Enqueue Debug MT");
return debugMicroTaskQueue.pushBack(entry);
}
-JS_PUBLIC_API bool JS::EnqueueMicroTask(JSContext* cx, const MicroTask& entry) {
+JS_PUBLIC_API bool JS::EnqueueMicroTask(JSContext* cx,
+ const JS::GenericMicroTask& entry) {
JS_LOG(mtq, Info, "Enqueue of non JS MT");
return cx->microTaskQueues->enqueueRegularMicroTask(cx, entry);
}
-JS_PUBLIC_API bool JS::EnqueueDebugMicroTask(JSContext* cx,
- const MicroTask& entry) {
+JS_PUBLIC_API bool JS::EnqueueDebugMicroTask(
+ JSContext* cx, const JS::GenericMicroTask& entry) {
JS_LOG(mtq, Info, "Enqueue of non JS MT");
return cx->microTaskQueues->enqueueDebugMicroTask(cx, entry);
}
-JS_PUBLIC_API bool JS::PrependMicroTask(JSContext* cx, const MicroTask& entry) {
+JS_PUBLIC_API bool JS::PrependMicroTask(JSContext* cx,
+ const JS::GenericMicroTask& entry) {
JS_LOG(mtq, Info, "Prepend job to MTQ");
return cx->microTaskQueues->prependRegularMicroTask(cx, entry);
}
-JS_PUBLIC_API JS::MicroTask JS::DequeueNextMicroTask(JSContext* cx) {
+JS_PUBLIC_API JS::GenericMicroTask JS::DequeueNextMicroTask(JSContext* cx) {
return cx->microTaskQueues->popFront();
}
-JS_PUBLIC_API JS::MicroTask JS::DequeueNextDebuggerMicroTask(JSContext* cx) {
+JS_PUBLIC_API JS::GenericMicroTask JS::DequeueNextDebuggerMicroTask(
+ JSContext* cx) {
return cx->microTaskQueues->popDebugFront();
}
@@ -1189,10 +1192,11 @@ JS_PUBLIC_API bool JS::HasRegularMicroTasks(JSContext* cx) {
return !cx->microTaskQueues->microTaskQueue.empty();
}
-JS_PUBLIC_API JS::MicroTask JS::DequeueNextRegularMicroTask(JSContext* cx) {
+JS_PUBLIC_API JS::GenericMicroTask JS::DequeueNextRegularMicroTask(
+ JSContext* cx) {
auto& queue = cx->microTaskQueues->microTaskQueue;
if (!queue.empty()) {
- JS::MicroTask p = queue.front();
+ JS::GenericMicroTask p = queue.front();
queue.popFront();
return p;
}
diff --git a/js/src/vm/JSContext.h b/js/src/vm/JSContext.h
@@ -189,12 +189,12 @@ struct MicroTaskQueueSet {
MicroTaskQueueSet(const MicroTaskQueueSet&) = delete;
MicroTaskQueueSet& operator=(const MicroTaskQueueSet&) = delete;
- bool enqueueRegularMicroTask(JSContext* cx, const JS::MicroTask&);
- bool enqueueDebugMicroTask(JSContext* cx, const JS::MicroTask&);
- bool prependRegularMicroTask(JSContext* cx, const JS::MicroTask&);
+ bool enqueueRegularMicroTask(JSContext* cx, const JS::GenericMicroTask&);
+ bool enqueueDebugMicroTask(JSContext* cx, const JS::GenericMicroTask&);
+ bool prependRegularMicroTask(JSContext* cx, const JS::GenericMicroTask&);
- JS::MicroTask popFront();
- JS::MicroTask popDebugFront();
+ JS::GenericMicroTask popFront();
+ JS::GenericMicroTask popDebugFront();
bool empty() { return microTaskQueue.empty() && debugMicroTaskQueue.empty(); }
diff --git a/xpcom/base/CycleCollectedJSContext.cpp b/xpcom/base/CycleCollectedJSContext.cpp
@@ -852,9 +852,9 @@ void CycleCollectedJSContext::AddPendingIDBTransaction(
//
// - This means runnables in the queue have their refcounts stay above zero for
// the duration of the time they are in the queue.
-JS::MicroTask RunnableToMicroTask(
+JS::GenericMicroTask RunnableToMicroTask(
already_AddRefed<MicroTaskRunnable>& aRunnable) {
- JS::MicroTask v;
+ JS::GenericMicroTask v;
auto* r = aRunnable.take();
MOZ_ASSERT(r);
v.setPrivate(r);
@@ -864,13 +864,13 @@ JS::MicroTask RunnableToMicroTask(
bool EnqueueMicroTask(JSContext* aCx,
already_AddRefed<MicroTaskRunnable> aRunnable) {
MOZ_ASSERT(StaticPrefs::javascript_options_use_js_microtask_queue());
- JS::MicroTask v = RunnableToMicroTask(aRunnable);
+ JS::GenericMicroTask v = RunnableToMicroTask(aRunnable);
return JS::EnqueueMicroTask(aCx, v);
}
bool EnqueueDebugMicroTask(JSContext* aCx,
already_AddRefed<MicroTaskRunnable> aRunnable) {
MOZ_ASSERT(StaticPrefs::javascript_options_use_js_microtask_queue());
- JS::MicroTask v = RunnableToMicroTask(aRunnable);
+ JS::GenericMicroTask v = RunnableToMicroTask(aRunnable);
return JS::EnqueueDebugMicroTask(aCx, v);
}
diff --git a/xpcom/base/CycleCollectedJSContext.h b/xpcom/base/CycleCollectedJSContext.h
@@ -159,8 +159,8 @@ class MustConsumeMicroTask {
// This is a non-owning conversion: This class still owns the refcount.
MicroTaskRunnable* MaybeUnwrapTaskToRunnable() const;
- // Take ownership of a non-JS task inside a JS::MicroTask - This clears the
- // contents of the value to make it clear that we've transfered ownership.
+ // Take ownership of a non-JS task inside a JS::GenericMicroTask - This clears
+ // the contents of the value to make it clear that we've transfered ownership.
// `this` is marked is only edited if unwrapping succeeds, and so
// you can conditionally try to consume as owned;
//
@@ -196,7 +196,7 @@ class MustConsumeMicroTask {
// consuming the contents.
JSObject* GetExecutionGlobalFromJSMicroTask(JSContext* aCx) const {
MOZ_ASSERT(IsJSMicroTask());
- JS::Rooted<JS::MicroTask> task(aCx, mMicroTask);
+ JS::Rooted<JS::GenericMicroTask> task(aCx, mMicroTask);
return JS::GetExecutionGlobalFromJSMicroTask(task);
}
@@ -239,10 +239,10 @@ class MustConsumeMicroTask {
}
private:
- explicit MustConsumeMicroTask(JS::MicroTask&& aMicroTask)
+ explicit MustConsumeMicroTask(JS::GenericMicroTask&& aMicroTask)
: mMicroTask(aMicroTask) {}
- JS::Heap<JS::MicroTask> mMicroTask;
+ JS::Heap<JS::GenericMicroTask> mMicroTask;
};
class SuppressedMicroTaskList final : public MicroTaskRunnable {
