Method callPromise

valdi/src/valdi/runtime/JavaScript/ValueFunctionWithJSValue.cpp:281–313

            // so this is where the JS thread proves it is responsive again. getFunctionName() is
            // safe here: this is the JS thread, the only writer of its lazy cache.
            auto stillOverdue = taskScheduler->onOverdueDeadlineCallCompleted();
            if (stillOverdue == 0) {
                [[maybe_unused]] auto failedFast = taskScheduler->takeFastFailedDeadlineCalls();
                [[maybe_unused]] auto lateByMs = std::chrono::duration_cast<std::chrono::milliseconds>(
                                                     std::chrono::steady_clock::now() - call->dispatchedAt)
                                                     .count();
                VALDI_WARN(self->getContext()->getLogger(),
                           "JS thread caught up on overdue sync call to '{}' {}ms after dispatch; {} bounded calls "
                           "were failed fast meanwhile",
                           self->getFunctionName(),
                           lateByMs,
                           failedFast);
            }
        });

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

    // Count before claiming the timeout so the JS task, which decrements only after it observes
    // TimedOut, can never see the counter at zero.
    taskScheduler->onDeadlineCallTimedOut();
    auto expected = DeadlineCall::State::Pending;
    if (!call->state.compare_exchange_strong(expected, DeadlineCall::State::TimedOut)) {
        taskScheduler->onOverdueDeadlineCallCompleted();
        return future.get();
    }

    // Name what the JS thread is doing instead of running us. The attribution only has content
    // when ANR diagnostics are on, and it is the one signal that tells a slow JS thread apart from
    // a JS thread that is itself blocked on the main thread.
    // Built from the immutable ReferenceInfo rather than getFunctionName(): that cache is lazily
    // written on the JS thread (doJsCall), which may be initializing it right now.
    [[maybe_unused]] auto waitedMs =
        std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - call->dispatchedAt)
            .count();