Method callSync

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

            exceptionTracker->onError(jsEntry.exceptionTracker.extractError());
        }
        return Value::undefined();
    }

    auto retValue = callJsFunction(jsEntry, jsValue, parameters, parametersSize, ignoreRetValue);
    if (!jsEntry.exceptionTracker && exceptionTracker != nullptr) {
        exceptionTracker->onError(jsEntry.exceptionTracker.extractError());
    }

    if (_isSingleCall) {
        clearJsValue(jsEntry.jsContext);
    }

    return retValue;
}

void ValueFunctionWithJSValue::setIgnoreIfValdiContextIsDestroyed(bool ignoreIfValdiContextIsDestroyed) {
    _ignoreIfValdiContextIsDestroyed = ignoreIfValdiContextIsDestroyed;
}

static Valdi::SmallVector<Value, 2> captureParameters(const Value* parameters, size_t parametersSize) {
    return Valdi::SmallVector<Value, 2>(parameters, parameters + parametersSize);
}

static Valdi::SmallVector<Value, 2> captureParameters(const ValueFunctionCallContext& callContext) {
    return captureParameters(callContext.getParameters(), callContext.getParametersSize());
}

struct MainThreadThrottledCall : public SimpleRefCountable {
    std::promise<void> promise;
    int callId;
    Valdi::SmallVector<Value, 2> parameters;

    MainThreadThrottledCall(int callId, Valdi::SmallVector<Value, 2>&& parameters)
        : callId(callId), parameters(std::move(parameters)) {}
    ~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();

    // The JS callback may need locks this thread holds (e.g. the ViewNodeTree lock when the call
    // originates from the scroll path); suspend them while parked so the JS thread can make
    // progress instead of stalling until the deadline. Same pattern as
    // DeferredViewTransaction::flush before dispatchSync.
    DropAllTrackedLocks dropAllTrackedLocks;

    taskScheduler->dispatchOnJsThreadAsync(
        getContext(),
        getANRAttribution(),
        [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)));