#include "config.h"
#include "JSPromise.h"
#if ENABLE(PROMISES)
#include "Error.h"
#include "JSCJSValueInlines.h"
#include "JSCellInlines.h"
#include "JSPromiseConstructor.h"
#include "JSPromiseReaction.h"
#include "Microtask.h"
#include "SlotVisitorInlines.h"
#include "StructureInlines.h"
namespace JSC {
static void triggerPromiseReactions(VM&, JSGlobalObject*, Vector<WriteBarrier<JSPromiseReaction>>&, JSValue);
const ClassInfo JSPromise::s_info = { "Promise", &Base::s_info, 0, 0, CREATE_METHOD_TABLE(JSPromise) };
JSPromise* JSPromise::create(VM& vm, JSGlobalObject* globalObject, JSPromiseConstructor* constructor)
{
JSPromise* promise = new (NotNull, allocateCell<JSPromise>(vm.heap)) JSPromise(vm, globalObject->promiseStructure());
promise->finishCreation(vm, constructor);
return promise;
}
Structure* JSPromise::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
}
JSPromise::JSPromise(VM& vm, Structure* structure)
: JSDestructibleObject(vm, structure)
, m_status(Status::Unresolved)
{
}
void JSPromise::finishCreation(VM& vm, JSPromiseConstructor* constructor)
{
Base::finishCreation(vm);
ASSERT(inherits(info()));
m_constructor.set(vm, this, constructor);
}
void JSPromise::destroy(JSCell* cell)
{
static_cast<JSPromise*>(cell)->JSPromise::~JSPromise();
}
void JSPromise::visitChildren(JSCell* cell, SlotVisitor& visitor)
{
JSPromise* thisObject = jsCast<JSPromise*>(cell);
ASSERT_GC_OBJECT_INHERITS(thisObject, info());
COMPILE_ASSERT(StructureFlags & OverridesVisitChildren, OverridesVisitChildrenWithoutSettingFlag);
ASSERT(thisObject->structure()->typeInfo().overridesVisitChildren());
Base::visitChildren(thisObject, visitor);
visitor.append(&thisObject->m_result);
visitor.append(&thisObject->m_constructor);
visitor.append(thisObject->m_resolveReactions.begin(), thisObject->m_resolveReactions.end());
visitor.append(thisObject->m_rejectReactions.begin(), thisObject->m_rejectReactions.end());
}
void JSPromise::reject(VM& vm, JSValue reason)
{
if (m_status != Status::Unresolved)
return;
DeferGC deferGC(vm.heap);
Vector<WriteBarrier<JSPromiseReaction>> reactions;
reactions.swap(m_rejectReactions);
m_result.set(vm, this, reason);
m_resolveReactions.clear();
m_status = Status::HasRejection;
triggerPromiseReactions(vm, globalObject(), reactions, reason);
}
void JSPromise::resolve(VM& vm, JSValue resolution)
{
if (m_status != Status::Unresolved)
return;
DeferGC deferGC(vm.heap);
Vector<WriteBarrier<JSPromiseReaction>> reactions;
reactions.swap(m_resolveReactions);
m_result.set(vm, this, resolution);
m_rejectReactions.clear();
m_status = Status::HasResolution;
triggerPromiseReactions(vm, globalObject(), reactions, resolution);
}
void JSPromise::appendResolveReaction(VM& vm, JSPromiseReaction* reaction)
{
m_resolveReactions.append(WriteBarrier<JSPromiseReaction>(vm, this, reaction));
}
void JSPromise::appendRejectReaction(VM& vm, JSPromiseReaction* reaction)
{
m_rejectReactions.append(WriteBarrier<JSPromiseReaction>(vm, this, reaction));
}
void triggerPromiseReactions(VM& vm, JSGlobalObject* globalObject, Vector<WriteBarrier<JSPromiseReaction>>& reactions, JSValue argument)
{
for (auto& reaction : reactions) {
globalObject->queueMicrotask(createExecutePromiseReactionMicrotask(vm, reaction.get(), argument));
}
}
}
#endif // ENABLE(PROMISES)