Method callSync

valdi/src/valdi/runtime/JavaScript/ValueFunctionWithJSValue.cpp:147–208

    ~MainThreadThrottledCall() override = default;
};

Result<Value> ValueFunctionWithJSValue::dispatchAndWaitOnJsThread(const Ref<JavaScriptTaskScheduler>& taskScheduler,
                                                                  const std::chrono::steady_clock::time_point& deadline,
                                                                  const Value* parameters,
                                                                  size_t parametersSize) {
    auto promise = std::make_shared<std::promise<Result<Value>>>();
    auto future = promise->get_future();

    taskScheduler->dispatchOnJsThreadAsync(
        getContext(),
        [self = strongSmallRef(this), parameters = captureParameters(parameters, parametersSize), promise](
            auto& jsEntry) {
            MainThreadBatchAllowScope mainThreadBatchAllowScope;
            auto result = self->doJsCall(jsEntry, parameters.data(), parameters.size(), nullptr, false);
            promise->set_value(Result(std::move(result)));
        });

    if (std::future_status::ready == future.wait_until(deadline)) {
        return future.get();
    }

    return Error("JS function timeout");
}

Value ValueFunctionWithJSValue::callSync(ValueFunctionFlags flags,
                                         const Ref<JavaScriptTaskScheduler>& taskScheduler,
                                         const ValueFunctionCallContext& callContext) {
    auto retValue = Value::undefined();
    getContext()->withAttribution([&]() {
        auto shouldStartMainThreadBatch =
            _shouldBlockMainThread && _mainThreadManager != nullptr && _mainThreadManager->currentThreadIsMainThread();
        auto propagatesError = ((flags & ValueFunctionFlagsPropagatesError) != ValueFunctionFlagsNone);

        if (shouldStartMainThreadBatch) {
            _mainThreadManager->beginBatch();

            if ((flags & ValueFunctionFlagsAllowThrottling) != ValueFunctionFlagsNone) {
                // When using a main thread batch with allow throttling, we only allow locking
                // the main thread for up to 100ms

                auto throttledCall =
                    makeShared<MainThreadThrottledCall>(++_callSequence, captureParameters(callContext));
                auto future = throttledCall->promise.get_future();

                taskScheduler->dispatchOnJsThreadAsync(
                    getContext(), [self = strongSmallRef(this), throttledCall](auto& jsEntry) {
                        auto currentCallId = self->_callSequence.load();
                        if (currentCallId != throttledCall->callId) {
                            // Throttling call, our callId doesn't match what is in the
                            // sequence.
                            throttledCall->promise.set_value();
                            return;
                        }

                        MainThreadBatchAllowScope mainThreadBatchAllowScope;
                        self->doJsCall(
                            jsEntry, throttledCall->parameters.data(), throttledCall->parameters.size(), nullptr, true);
                        throttledCall->promise.set_value();