commit 6f868b76a0dae219c9950360a47931c196d0fa94
author Scott Haseley <shaseley@chromium.org> Tue Oct 18 20:00:25 2022
committer Chromium LUCI CQ <chromium-scoped@luci-project-accounts.iam.gserviceaccount.com> Tue Oct 18 20:00:25 2022
tree 118c1de985dde981d3ba89776a81db4250abaef7
parent 713b6ddb334a1e70ddaf3c394d35db05ae71c4d3

[dom] Introduce AbortSignal::AlgorithmHandle and implement removal

This is the first CL aimed at making abort algorithm lifetime explicit.
Signals created by AbortSignal.any() need to remain alive as long as a
source signal can abort and the abort effect can be observed, which
includes abort algorithms having an effect. But we don't want source
signals to indefinitely keep dependent signals alive, so instead we
will tie the lifetime of dependent signals to the algorithms and enforce
algorithm lifetime management.

The full conversion is here: crrev.com/c/3712492. This is being split
because the conversion requires reasoning about algorithm lifetime for
each usage, and there are multiple directories/owners.

Changes in this CL:
 1. Introduce an AlgorithmHandle class and update AddAlgorithm() to
    return a handle
 2. Change AbortSignal to store a map of handles to algorithms, and
    implement removal as RemoveAlgorithm(handle)
 3. Introduce AbortSignalRegistry to help manage algorithm lifetime
    for event listeners. This class is used further in the any()
    implementation, but is used here to minimize the memory footprint
    of handles for event listeners (see the design doc).
 4. Add a helper class, ScopedAbortState, to help with cases where
    removal should be scoped to an operation, e.g. where removal
    can't wait for GC. Convert modules/eyedropper to use this.
 5. Convert a couple uses of AddAlgorithm() where lifetime management
    is straightforward
 6. Wrap all of this behind a feature/kill switch. This required
    factoring out the abort algorithm collection interface and
    making two subclasses.

Followup work for after all the callsites have been converted:
 1. Make AddAlgorithm() [[nodiscard]] to enforce callers use the
    handle
 2. Make the AbortSignal's algorithm map hold a weak pointer to
    handles, which we can't do this until all the callsites are
    converted
 3. When we implement AbortSignal.any(), we'll subclass
    AlgorithmHandle to store a strong reference to the signal for
    dependent signals, tying their lifetime to the algorithm

Testing:
 1. An internal wpt test is added to over the event listeners/registry
    change.
 2. Unit tests cover the expected removal behavior, but will need
    to be modified once the algorithm collection stores weak pointers.
 3. Callsites that depend on RemoveAlgorithm() will be flag-guarded and
    keep the old behavior. Both code paths are tested via a virtual
    test suite (eyedropper is added here as an example).

Design doc:
https://docs.google.com/document/d/1UMZrd5-RztLLUZ2g4vf4Nk7MBTnpfdihNi1Xh5qrND8/edit?usp=sharing&resourcekey=0-Xd_3IULrml81fZ7CGrltYw

Bug: 1296280, 1323391
LOW_COVERAGE_REASON = New code has coverage. event_target has coverage for new lines and eyedropper is missing some coverage for abort.

Change-Id: I8805d2ce01dab10c0319df46098d2aee485c2f8c
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/3931192
Reviewed-by: Nate Chapin <japhet@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Mason Freed <masonf@chromium.org>
Commit-Queue: Scott Haseley <shaseley@chromium.org>
Cr-Commit-Position: refs/heads/main@{#1060639}