Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / event_loop / task_queue.lucb

#==============================================================================================
#
#   task_queue - HTML::TaskQueue: an event loop's queue of tasks
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp (lines 1-115) with the inline
#       functions of TaskQueue.h (lines 1-52). Adding a task schedules the event loop; the
#       event loop takes the first runnable task, skipping rendering tasks while the rendering
#       task runs and dropping tasks that can never run.
#
#       Copyright (c) 2021-2025, Andreas Kling <andreas@ladybird.org>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

## heap.allocate<HTML::TaskQueue>(event_loop): a TaskQueue cell constructed under DeferGC.
pub func heap_allocate_html_task_queue(heap: gc.Heap*, event_loop: HtmlEventLoop*) -> HtmlTaskQueue*:
    let this = (HtmlTaskQueue*)web_heap_allocate_cell(heap, &html_task_queue_class)
    gc.heap_defer_gc(heap)
    html_task_queue_construct(this, event_loop)
    gc.heap_undefer_gc(heap)
    return this

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:16 Web::HTML::TaskQueue::TaskQueue.
pub func html_task_queue_construct(this: HtmlTaskQueue*, event_loop: HtmlEventLoop*):
    this.m_event_loop = event_loop

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:23 Web::HTML::TaskQueue::visit_edges (override).
pub func html_task_queue_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (HtmlTaskQueue*)base
    gc.cell_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t_2(visitor, this.m_event_loop)
    gc.cell_visitor_visit_vector(visitor, &this.m_tasks)

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:30 Web::HTML::TaskQueue::add.
pub func html_task_queue_add(this: HtmlTaskQueue*, task: HtmlTask*):
    # AD-HOC: Don't enqueue tasks for temporary (inert) documents used for fragment parsing.
    # FIXME: There's ongoing spec work to remove such documents: https://github.com/whatwg/html/pull/11970
    if let document = html_task_document(task):
        if dom_document_is_temporary_document_for_fragment_parsing(document):
            return

    ak.vector_append_t(&this.m_tasks, task)
    html_event_loop_schedule(this.m_event_loop)

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:41 Web::HTML::TaskQueue::take_first_runnable.
pub func html_task_queue_take_first_runnable(this: HtmlTaskQueue*) -> HtmlTask*?:
    if html_event_loop_execution_paused(this.m_event_loop):
        return none

    var i: usize = 0
    while i < ak.vector_size(&this.m_tasks):
        let task = *ak.vector_at(&this.m_tasks, i)
        if html_event_loop_running_rendering_task(this.m_event_loop) and html_task_source(task) == HtmlTaskSource.rendering:
            i += 1
            continue

        if html_task_is_runnable(task):
            return ak.vector_take(&this.m_tasks, i)

        if html_task_is_permanently_unrunnable(task):
            ak.vector_remove(&this.m_tasks, i)
            continue

        i += 1
    return none

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:65 Web::HTML::TaskQueue::has_runnable_tasks.
pub func html_task_queue_has_runnable_tasks(this: HtmlTaskQueue*) -> bool:
    if html_event_loop_execution_paused(this.m_event_loop):
        return false

    for task in ak.vector_span(&this.m_tasks):
        if html_event_loop_running_rendering_task(this.m_event_loop) and html_task_source(task) == HtmlTaskSource.rendering:
            continue
        if html_task_is_runnable(task):
            return true
    return false

## The C++ Function<bool(Task const&)> as the predicate Vector::remove_all_matching takes.
struct HtmlTaskQueueTaskFilter:
    var filter: ak.Function1[HtmlTask*, bool]

    static func call(context: void*?, task: const (HtmlTask*)*) -> bool:
        let captures = (HtmlTaskQueueTaskFilter*)(context else trap("no captures"))
        return ak.function1_call(&captures.filter, *task)

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:79 Web::HTML::TaskQueue::remove_tasks_matching.
pub func html_task_queue_remove_tasks_matching(this: HtmlTaskQueue*, filter: ak.Function1[HtmlTask*, bool]):
    var captures = HtmlTaskQueueTaskFilter(filter = filter)
    _ = ak.vector_remove_all_matching(&this.m_tasks, ak.Function1[const (HtmlTask*)*, bool](call = HtmlTaskQueueTaskFilter.call, context = &captures))

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:84 Web::HTML::TaskQueue::take_first_runnable_matching.
pub func html_task_queue_take_first_runnable_matching(this: HtmlTaskQueue*, filter: ak.Function1[HtmlTask*, bool]) -> HtmlTask*?:
    var i: usize = 0
    while i < ak.vector_size(&this.m_tasks):
        let task = *ak.vector_at(&this.m_tasks, i)

        if html_task_is_runnable(task) and ak.function1_call(&filter, task):
            return ak.vector_take(&this.m_tasks, i)

        if html_task_is_permanently_unrunnable(task):
            ak.vector_remove(&this.m_tasks, i)
            continue

        i += 1

    return none

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:103 Web::HTML::TaskQueue::last_added_task.
pub func html_task_queue_last_added_task(this: HtmlTaskQueue*) -> HtmlTask*?:
    if ak.vector_is_empty(&this.m_tasks):
        return none
    return *ak.vector_last(&this.m_tasks)

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.cpp:110 Web::HTML::TaskQueue::has_rendering_tasks.
pub func html_task_queue_has_rendering_tasks(this: HtmlTaskQueue*) -> bool:
    for task in ak.vector_span(&this.m_tasks):
        if html_task_source(task) == HtmlTaskSource.rendering:
            return true
    return false

# mark: TaskQueue.h =============================================================================

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.h:23 Web::HTML::TaskQueue::is_empty.
pub func html_task_queue_is_empty(this: HtmlTaskQueue*) -> bool:
    return ak.vector_is_empty(&this.m_tasks)

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.h:31 Web::HTML::TaskQueue::enqueue.
pub func html_task_queue_enqueue(this: HtmlTaskQueue*, task: HtmlTask*):
    html_task_queue_add(this, task)

## Ported from Libraries/LibWeb/HTML/EventLoop/TaskQueue.h:32 Web::HTML::TaskQueue::dequeue.
pub func html_task_queue_dequeue(this: HtmlTaskQueue*) -> HtmlTask*?:
    if ak.vector_is_empty(&this.m_tasks):
        return none
    return ak.vector_take_first(&this.m_tasks)