Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.1

0.6.1 / src / web / html / session_history_traversal_queue.lucb

#==============================================================================================
#
#   session_history_traversal_queue - HTML::SessionHistoryTraversalQueue: a traversable's queue
#   of session history traversal steps
#
#   DESCRIPTION:
#       Port of Libraries/LibWeb/HTML/SessionHistoryTraversalQueue.cpp (lines 1-98) with the
#       inline functions of SessionHistoryTraversalQueue.h. The steps' signals are
#       Core::Promise<Empty> (LibCore, phase 2 closure stubs).
#
#       Copyright (c) 2023, Aliaksandr Kalenik <kalenik.aliaksandr@gmail.com>
#       SPDX-License-Identifier: BSD-2-Clause
#
#==============================================================================================

# mark: SessionHistoryTraversalQueueEntry =======================================================

## Ported from SessionHistoryTraversalQueue.cpp:15 Web::HTML::SessionHistoryTraversalQueueEntry::create.
pub func html_session_history_traversal_queue_entry_create(vm: Vm*, steps: gc.Function1[CorePromise[ak.Empty, ak.AkError]*, unit]*, target_navigable: HtmlNavigable*?) -> HtmlSessionHistoryTraversalQueueEntry*:
    let heap = vm_heap(vm)
    let entry = (HtmlSessionHistoryTraversalQueueEntry*)web_heap_allocate_cell(heap, &html_session_history_traversal_queue_entry_class)
    gc.heap_defer_gc(heap)
    html_session_history_traversal_queue_entry_construct(entry, steps, target_navigable)
    gc.heap_undefer_gc(heap)
    return entry

## Ported from SessionHistoryTraversalQueue.h:35 Web::HTML::SessionHistoryTraversalQueueEntry::SessionHistoryTraversalQueueEntry.
pub func html_session_history_traversal_queue_entry_construct(this: HtmlSessionHistoryTraversalQueueEntry*, steps: gc.Function1[CorePromise[ak.Empty, ak.AkError]*, unit]*, target_navigable: HtmlNavigable*?):
    this.m_steps = steps
    this.m_target_navigable = target_navigable

## Ported from SessionHistoryTraversalQueue.cpp:20 Web::HTML::SessionHistoryTraversalQueueEntry::visit_edges (override).
pub func html_session_history_traversal_queue_entry_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (HtmlSessionHistoryTraversalQueueEntry*)base
    gc.cell_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_t_2(visitor, this.m_steps)
    gc.cell_visitor_visit_t(visitor, this.m_target_navigable)

## Ported from SessionHistoryTraversalQueue.h:31 Web::HTML::SessionHistoryTraversalQueueEntry::target_navigable.
pub func html_session_history_traversal_queue_entry_target_navigable(this: HtmlSessionHistoryTraversalQueueEntry*) -> HtmlNavigable*?:
    return this.m_target_navigable

## Ported from SessionHistoryTraversalQueue.h:32 Web::HTML::SessionHistoryTraversalQueueEntry::execute_steps.
pub func html_session_history_traversal_queue_entry_execute_steps(this: HtmlSessionHistoryTraversalQueueEntry*, promise: CorePromise[ak.Empty, ak.AkError]*):
    ak.function1_call(&this.m_steps.function, promise)

# mark: SessionHistoryTraversalQueue ============================================================

## `vm().heap().allocate<SessionHistoryTraversalQueue>()`: a queue cell constructed under DeferGC.
pub func heap_allocate_html_session_history_traversal_queue(heap: gc.Heap*) -> HtmlSessionHistoryTraversalQueue*:
    let queue = (HtmlSessionHistoryTraversalQueue*)web_heap_allocate_cell(heap, &html_session_history_traversal_queue_class)
    gc.heap_defer_gc(heap)
    html_session_history_traversal_queue_construct(queue)
    gc.heap_undefer_gc(heap)
    return queue

## Ported from SessionHistoryTraversalQueue.cpp:27 Web::HTML::SessionHistoryTraversalQueue::SessionHistoryTraversalQueue
## (`= default`).
pub func html_session_history_traversal_queue_construct(this: HtmlSessionHistoryTraversalQueue*):
    this.m_processing_scheduled = false

## process_queue's `when_resolved` callback: process the queue again.
func html_session_history_traversal_queue_resume(context: void*?, arg0: ak.Empty*):
    html_session_history_traversal_queue_process_queue((HtmlSessionHistoryTraversalQueue*)(context else trap("no queue")))

## Ported from SessionHistoryTraversalQueue.cpp:29 Web::HTML::SessionHistoryTraversalQueue::process_queue.
func html_session_history_traversal_queue_process_queue(this: HtmlSessionHistoryTraversalQueue*):
    while ak.vector_size(&this.m_queue) > 0:
        if let current_promise = this.m_current_promise:
            if not core_promise_is_resolved(current_promise) and not core_promise_is_rejected(current_promise):
                _ = core_promise_when_resolved(current_promise, ak.Function1[ak.Empty*, unit](call = html_session_history_traversal_queue_resume, context = this))
                return

        let entry = ak.vector_take_first(&this.m_queue)
        let promise = core_promise_construct[ak.Empty, ak.AkError]()
        this.m_current_promise = promise
        html_session_history_traversal_queue_entry_execute_steps(entry, promise)

## Ported from SessionHistoryTraversalQueue.cpp:45 Web::HTML::SessionHistoryTraversalQueue::visit_edges (override).
pub func html_session_history_traversal_queue_visit_edges_impl(base: gc.Cell*, visitor: gc.CellVisitor*):
    let this = (HtmlSessionHistoryTraversalQueue*)base
    gc.cell_visit_edges_impl(base, visitor)
    gc.cell_visitor_visit_vector(visitor, &this.m_queue)

## Ported from SessionHistoryTraversalQueue.cpp:51 Web::HTML::SessionHistoryTraversalQueue::append.
pub func html_session_history_traversal_queue_append(this: HtmlSessionHistoryTraversalQueue*, steps: gc.Function1[CorePromise[ak.Empty, ak.AkError]*, unit]*):
    ak.vector_append_t(&this.m_queue, html_session_history_traversal_queue_entry_create(js_cell_vm(this.js_cell()), steps, none))
    html_session_history_traversal_queue_schedule_processing(this)

## Ported from SessionHistoryTraversalQueue.cpp:57 Web::HTML::SessionHistoryTraversalQueue::append_sync.
pub func html_session_history_traversal_queue_append_sync(this: HtmlSessionHistoryTraversalQueue*, steps: gc.Function1[CorePromise[ak.Empty, ak.AkError]*, unit]*, target_navigable: HtmlNavigable*?):
    ak.vector_append_t(&this.m_queue, html_session_history_traversal_queue_entry_create(js_cell_vm(this.js_cell()), steps, target_navigable))
    html_session_history_traversal_queue_schedule_processing(this)

## schedule_processing's deferred invocation.
func html_session_history_traversal_queue_scheduled(context: void*?):
    let this = (HtmlSessionHistoryTraversalQueue*)(context else trap("no queue"))
    this.m_processing_scheduled = false
    html_session_history_traversal_queue_process_queue(this)

## Ported from SessionHistoryTraversalQueue.cpp:63 Web::HTML::SessionHistoryTraversalQueue::schedule_processing.
func html_session_history_traversal_queue_schedule_processing(this: HtmlSessionHistoryTraversalQueue*):
    if not this.m_processing_scheduled:
        this.m_processing_scheduled = true
        core_deferred_invoke(ak.Function0[unit](call = html_session_history_traversal_queue_scheduled, context = this))

## Ported from SessionHistoryTraversalQueue.cpp:75 Web::HTML::SessionHistoryTraversalQueue::first_synchronous_navigation_steps_with_target_navigable_not_contained_in.
# https://html.spec.whatwg.org/multipage/browsing-the-web.html#sync-navigations-jump-queue
pub func html_session_history_traversal_queue_first_synchronous_navigation_steps_with_target_navigable_not_contained_in(this: HtmlSessionHistoryTraversalQueue*, set: const ak.HashTable[HtmlNavigable*, ak.PtrTraits[HtmlNavigable]]*) -> HtmlSessionHistoryTraversalQueueEntry*?:
    var index: usize? = none
    for i in 0..<ak.vector_size(&this.m_queue):
        let entry = *ak.vector_at(&this.m_queue, i)
        let target_navigable = html_session_history_traversal_queue_entry_target_navigable(entry) else continue

        if ak.hash_table_contains_t(set, target_navigable):
            continue

        # A newly created child navigable is not yet discoverable through get_session_history_entries()
        # until its creation bookkeeping has run on the traversal queue. Do not let synchronous
        # navigation steps for that child jump ahead of the bookkeeping step that installs it.
        if not html_navigable_has_session_history_entry_and_ready_for_navigation(target_navigable):
            continue

        index = i
        break
    if let found = index:
        return ak.vector_take(&this.m_queue, found)
    return none