Method enqueue

gi/toggle.cpp:145–194

}

void ToggleQueue::enqueue(ObjectInstance* obj, ToggleQueue::Direction direction,
                          ToggleQueue::Handler handler) {
    g_assert(owns_lock() && "Unsafe access to queue");

    if (G_UNLIKELY(m_shutdown)) {
        gjs_debug(GJS_DEBUG_GOBJECT,
                  "Enqueuing GObject %p to toggle %s after "
                  "shutdown, probably from another thread (%p).",
                  obj->ptr(), direction == UP ? "UP" : "DOWN", g_thread_self());
        return;
    }

    auto other_item = find_operation_locked(obj, direction == UP ? DOWN : UP);
    if (other_item != q.end()) {
        if (direction == UP) {
            debug("enqueue UP, dequeuing already DOWN object", obj);
        } else {
            debug("enqueue DOWN, dequeuing already UP object", obj);
        }
        q.erase(other_item);
        return;
    }

    /* Only keep an unowned reference on the object here, since if we're here,
     * the JSObject wrapper already has a reference and we don't want to cause
     * any weak notify in case it has lost one already in the main thread. So
     * let's just save the pointer to keep track of the object till we don't
     * handle this toggle.
     *
     * We rely on objects cancelling the queue in case an object gets finalized
     * earlier than we've processed it.
     */
    q.emplace_back(obj, direction);

    if (direction == UP) {
        debug("enqueue UP", obj);
    } else {
        debug("enqueue DOWN", obj);
    }

    if (m_idle_id) {
        g_assert(m_toggle_handler == handler &&
                 "Should always enqueue with the same handler");
        return;
    }

    m_toggle_handler = handler;
    m_idle_id = g_idle_add_full(G_PRIORITY_HIGH, idle_handle_toggle, this,
                                idle_destroy_notify);
}