Method PumpTimerLoopCallback

test-app/runtime/src/main/cpp/Timers.cpp:267–325

* ALooper callback. * Responsible for checking if the callback is still scheduled and entering the isolate to trigger it */

 * Responsible for checking if the callback is still scheduled and entering the isolate to trigger it
 */
int Timers::PumpTimerLoopCallback(int fd, int events, void *data) {
    int timerId;
    read(fd, &timerId, sizeof(int));

    auto thiz = static_cast<Timers *>(data);
    auto isolate = thiz->isolate_;
    if (thiz->stopped || isolate == nullptr || isolate->IsDead()) {
        return 0;
    }
    // thread safety is important!
    v8::Locker locker(thiz->isolate_);
    v8::Isolate::Scope isolate_scope(isolate);
    v8::HandleScope handleScope(isolate);
    auto it = thiz->timerMap_.find(timerId);
    if (it != thiz->timerMap_.end()) {
        auto task = it->second;
        // task is no longer in queue to be executed
        task->queued_ = false;
        thiz->nesting = task->nestingLevel_;
        if (task->repeats_) {
            // the reason we're doing this in kind of a convoluted way is to follow more closely the chromium implementation than the node implementation
            // imagine an interval of 1000ms
            // node's setInterval drifts slightly (1000, 2001, 3001, 4002, some busy work 5050, 6050)
            // chromium will be consistent: (1000, 2001, 3000, 4000, some busy work 5050, 6000)
            task->startTime_ = task->dueTime_;
            thiz->addTask(task);
        }
        v8::Local<v8::Function> cb = task->callback_.Get(isolate);
        Runtime* runtime = Runtime::GetRuntime(isolate);
        v8::Local<v8::Context> context = runtime->GetContext();
        Context::Scope context_scope(context);
        TryCatch tc(isolate);
        auto argc = task->args_.get() == nullptr ? 0 : task->args_->size();
        if (argc > 0) {
            Local<Value> argv[argc];
            for (int i = 0; i < argc; i++) {
                argv[i] = task->args_->at(i)->Get(isolate);
            }
            cb->Call(context, context->Global(), argc, argv);
        } else {
            cb->Call(context, context->Global(), 0, nullptr);
        }
        // task is not queued, so it's either a setTimeout or a cleared setInterval
        // ensure we remove it
        if (!task->queued_) {
            thiz->removeTask(task);
        }

        thiz->nesting = 0;

        if (tc.HasCaught()) {
            NativeScriptException(tc).ReThrowToJava();
        }


    }
    thiz->bufferFull.notify_one();
    return 1;