Method operator()

valdi/src/valdi/runtime/JavaScript/ValueFunctionWithJSValue.cpp:210–279

            } else if ((flags & ValueFunctionFlagsBoundedMainThreadSync) != ValueFunctionFlagsNone) {
                // The main thread must not be held for an unbounded time waiting on the JS queue.
                // Unlike the throttled path above, the call is never coalesced away, so nothing is
                // dropped, only the return value on timeout. Uses the longer shared input deadline
                // rather than the throttled bound: a throttled call is fire-and-forget by design,
                // whereas these carry side effects the caller wants to land.
                auto result = dispatchAndWaitOnJsThread(taskScheduler,
                                                        std::chrono::steady_clock::now() + kInputSyncCallDeadline,
                                                        callContext.getParameters(),
                                                        callContext.getParametersSize());
                if (result.success()) {
                    retValue = result.value();
                }
            } else {
                taskScheduler->dispatchOnJsThreadSync(getContext(), [&](auto& jsEntry) {
                    MainThreadBatchAllowScope mainThreadBatchAllowScope;
                    retValue = this->doJsCall(jsEntry,
                                              callContext.getParameters(),
                                              callContext.getParametersSize(),
                                              propagatesError ? &callContext.getExceptionTracker() : nullptr,
                                              false);
                });
            }

            _mainThreadManager->endBatch();
        } else {
            taskScheduler->dispatchOnJsThreadSync(getContext(), [&](auto& jsEntry) {
                retValue = this->doJsCall(jsEntry,
                                          callContext.getParameters(),
                                          callContext.getParametersSize(),
                                          propagatesError ? &callContext.getExceptionTracker() : nullptr,
                                          false);
            });
        }
    });

    return retValue;
}

Value ValueFunctionWithJSValue::operator()(const ValueFunctionCallContext& callContext) noexcept {
    auto taskScheduler = getTaskScheduler();
    if (taskScheduler == nullptr) {
        return Value::undefined();
    }
    if (_ignoreIfValdiContextIsDestroyed) {
        if (Context::isDestroyedContextFixEnabled()) {
            auto ctx = _creationContext.lock();
            if (ctx == nullptr || ctx->isDestroyed()) {
                VALDI_WARN(getContext()->getLogger(),
                           "Function call skipped: creation context {} is destroyed (function: {})",
                           ctx != nullptr ? std::to_string(ctx->getContextId()) : "expired",
                           getReferenceInfo().toString());
                return Value::undefined();
            }
        } else if (getContext()->isDestroyed()) {
            VALDI_WARN(getContext()->getLogger(),
                       "Function call skipped: ValdiContext {} is destroyed (function: {})",
                       getContext()->getContextId(),
                       getReferenceInfo().toString());
            return Value::undefined();