dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWeb/CSS/CSSStyleSheet.h

172 lines
7 KiB
C
Raw Permalink Normal View History

LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
/*
Meta: Update my e-mail address everywhere
2024-10-04 08:19:50 -03:00
* Copyright (c) 2019-2021, Andreas Kling <andreas@ladybird.org>
LibWeb: Add `CSSStyleSheet.ownerRule` attribute This returns the `CSSImportRule` corresponding to the `@import` at-rule that imported the stylesheet into the document. If the stylesheet wasn't imported then this property is null.
2024-02-24 04:46:59 -03:00
* Copyright (c) 2024, Tim Ledbetter <timledbetter@gmail.com>
LibWeb/CSS: Wait for resources to load to fire `<style>` load event Previously, we fired the load event immediately, without waiting for anything. This was good for not timing out, but bad for anything that wanted to wait for the load to complete. CSSStyleSheet now maintains a list of critical subresources, and waits for all of them to complete before it then tells its owner that it is ready. "Complete" here means the network request completed with or without an error. This is done by having those subresources (just `@import` for now) notify their style sheet when they complete. This then propagates up as an `@import` tells its style sheet, which then would tell its parent `@import` if it had one. There are other subresources we should wait for (specifically fonts and background images) but this commit just adds `@import` as a first step.
2026-02-05 14:40:15 -03:00
* Copyright (c) 2026, Sam Atkins <sam@ladybird.org>
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 05:24:48 -03:00
* SPDX-License-Identifier: BSD-2-Clause
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
*/
#pragma once
LibWeb: Resolve cyclic dependency between StyleSheet and ImportRule Previously: CSSImportRule::loaded_style_sheet() (and others) depend on the definition of class CSSStyleSheet. Meanwhile, CSSStyleSheet::template for_each_effective_style_rule (and others) depend on the definition of class CSSImportRule. This hasn't caused any problems so far because CSSStyleSheet.h happened to be always included after CSSImportRule.h (in part due to alphabetical ordering). However, a compilation unit that (for example) only contains #include <Userland/Libraries/LibWeb/CSSImportRule.h> would fail to compile. This patch resolves this issue by pushing the inline definition of Web::CSS::CSSStyleSheet::for_each_effective_style_rule and for_first_not_loaded_import_rule into a different file, and adding the missing headers.
2021-09-30 17:57:35 -03:00
#include <AK/Function.h>
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
#include <AK/NonnullRefPtr.h>
#include <AK/RefPtr.h>
LibWeb/Bindings: Generate struct definitions from IDL dictionaries Previously we were inconsistent by generating code for enum definitions but not generating code for dictionaries. With future changes to the IDL generator to expose helpers to convert to and from IDL values this produced circular depdendencies. To solve this problem, also generate the dictionary definitions in bindings headers.
2026-05-01 14:01:23 -03:00
#include <LibWeb/Bindings/CSSStyleSheet.h>
LibWeb: Speed up CSS namespace checking CSSStyleSheet now caches the CSSNamespaceRule for the default namespace, which is the only one we currently care about. This saves us from iterating over its list of rules every time we want to know what that default namespace is. The spec dictates that `@namespace` rules are only valid near the start of a stylesheet, so we also take advantage of that to quit searching for namespaces as soon as we see a non-import rule. Also renamed `namespace_filter()` to `default_namespace()` since that's what it actually returns. This makes github.com/serenityos/serenity snappy again. :^)
2023-07-31 13:46:57 -03:00
#include <LibWeb/CSS/CSSNamespaceRule.h>
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
#include <LibWeb/CSS/CSSRule.h>
LibWeb: Use a CSSRuleList inside CSSStyleSheet This better matches the spec. :^)
2021-09-28 12:18:20 -03:00
#include <LibWeb/CSS/CSSRuleList.h>
LibWeb: Resolve cyclic dependency between StyleSheet and ImportRule Previously: CSSImportRule::loaded_style_sheet() (and others) depend on the definition of class CSSStyleSheet. Meanwhile, CSSStyleSheet::template for_each_effective_style_rule (and others) depend on the definition of class CSSImportRule. This hasn't caused any problems so far because CSSStyleSheet.h happened to be always included after CSSImportRule.h (in part due to alphabetical ordering). However, a compilation unit that (for example) only contains #include <Userland/Libraries/LibWeb/CSSImportRule.h> would fail to compile. This patch resolves this issue by pushing the inline definition of Web::CSS::CSSStyleSheet::for_each_effective_style_rule and for_first_not_loaded_import_rule into a different file, and adding the missing headers.
2021-09-30 17:57:35 -03:00
#include <LibWeb/CSS/CSSStyleRule.h>
LibWeb: Avoid cold rule cache builds for :has() checks Cache lightweight selector insights on each stylesheet so cold style scopes can answer whether :has() invalidation is relevant without building a complete rule cache. This avoids forcing rule caches for shadow roots whose active sheets do not contain :has() selectors. Imported sheets contribute to their parent sheet's effective rules, so an imported sheet load or CSSOM change also clears ancestor selector insight caches. Add test-only counters and regression coverage for cold shadow roots with and without :has() selectors, plus delayed imported :has() rules.
2026-05-23 08:16:30 -03:00
#include <LibWeb/CSS/SelectorInsights.h>
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
#include <LibWeb/CSS/StyleSheet.h>
LibWeb: Start fetching CSS image resources before document load event Both Chromium and Gecko delay the document's load event for CSS image resource requests (background-image, mask-image, etc). We now start fetching CSS image resources as soon as their stylesheet is associated with a document, rather than deferring until layout. This is done by collecting ImageStyleValues during stylesheet parsing and initiating their fetches when the stylesheet is added to the document. Fixes #3448
2026-03-19 07:22:18 -03:00
#include <LibWeb/CSS/StyleValues/ImageStyleValue.h>
AK+LibWeb: Reduce recompilation impact of DOM/Node.h Remove includes from Node.h that are only needed for forward declarations (AccessibilityTreeNode.h, XMLSerializer.h, JsonObjectSerializer.h). Extract StyleInvalidationReason and FragmentSerializationMode enums into standalone lightweight headers so downstream headers (CSSStyleSheet.h, CSSStyleProperties.h, HTMLParser.h) can include just the enum they need instead of all of Node.h. Replace Node.h with forward declarations in headers that only use Node by pointer/reference. This breaks the circular dependency between Node.h and AccessibilityTreeNode.h, reducing AccessibilityTreeNode.h's recompilation footprint from ~1399 to ~25 files.
2026-02-11 05:20:13 -03:00
#include <LibWeb/DOM/StyleInvalidationReason.h>
LibWeb: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-19 23:35:33 -03:00
#include <LibWeb/Export.h>
LibWeb: Implement `CSSStyleSheet.addRule()` This is a legacy method that has been superseded by `insertRule()`, although it is supported by all modern browser engines.
2024-02-24 04:46:59 -03:00
#include <LibWeb/WebIDL/Types.h>
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
namespace Web::CSS {
LibWeb: Resolve cyclic dependency between StyleSheet and ImportRule Previously: CSSImportRule::loaded_style_sheet() (and others) depend on the definition of class CSSStyleSheet. Meanwhile, CSSStyleSheet::template for_each_effective_style_rule (and others) depend on the definition of class CSSImportRule. This hasn't caused any problems so far because CSSStyleSheet.h happened to be always included after CSSImportRule.h (in part due to alphabetical ordering). However, a compilation unit that (for example) only contains #include <Userland/Libraries/LibWeb/CSSImportRule.h> would fail to compile. This patch resolves this issue by pushing the inline definition of Web::CSS::CSSStyleSheet::for_each_effective_style_rule and for_first_not_loaded_import_rule into a different file, and adding the missing headers.
2021-09-30 17:57:35 -03:00
class CSSImportRule;
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
class StyleScope;
LibWeb: Scope broad shadow-root stylesheet invalidation When invalidate_owners() runs on a stylesheet scoped to a shadow root, we previously dirtied the host and its light-DOM side too broadly. That forced restyles on nodes the shadow-scoped stylesheet cannot match. Inspect the sheet's effective selectors and dependent features up front. Only dirty assigned nodes, the host, the host root, or host-side animation consumers when the sheet can actually reach them, while keeping purely shadow-local mutations inside the shadow tree.
2026-04-22 17:34:46 -03:00
struct ShadowRootStylesheetEffects;
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
struct StyleCache;
LibWeb: Resolve cyclic dependency between StyleSheet and ImportRule Previously: CSSImportRule::loaded_style_sheet() (and others) depend on the definition of class CSSStyleSheet. Meanwhile, CSSStyleSheet::template for_each_effective_style_rule (and others) depend on the definition of class CSSImportRule. This hasn't caused any problems so far because CSSStyleSheet.h happened to be always included after CSSImportRule.h (in part due to alphabetical ordering). However, a compilation unit that (for example) only contains #include <Userland/Libraries/LibWeb/CSSImportRule.h> would fail to compile. This patch resolves this issue by pushing the inline definition of Web::CSS::CSSStyleSheet::for_each_effective_style_rule and for_first_not_loaded_import_rule into a different file, and adding the missing headers.
2021-09-30 17:57:35 -03:00
LibWeb/CSS: Qualify uses of LibURL To prepare for introducing a CSS::URL type, we need to qualify any use of LibURL as `::URL::foo` instead of `URL::foo` so the compiler doesn't get confused. Many of these uses will be replaced, but I don't want to mix this in with what will likely already be a large change.
2025-04-08 09:35:26 -03:00
// https://drafts.csswg.org/cssom-1/#cssstylesheet
LibWeb: Enable EXPLICIT_SYMBOL_EXPORT
2025-07-19 23:35:33 -03:00
class WEB_API CSSStyleSheet final : public StyleSheet {
LibWeb+LibJS: Make the EventTarget hierarchy (incl. DOM) GC-allocated This is a monster patch that turns all EventTargets into GC-allocated PlatformObjects. Their C++ wrapper classes are removed, and the LibJS garbage collector is now responsible for their lifetimes. There's a fair amount of hacks and band-aids in this patch, and we'll have a lot of cleanup to do after this.
2022-08-28 08:42:07 -03:00
WEB_PLATFORM_OBJECT(CSSStyleSheet, StyleSheet);
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC_DECLARE_ALLOCATOR(CSSStyleSheet);
LibWeb: Start exposing CSS style sheets to JavaScript :^) This patch adds bindings for the following objects: - StyleSheet - StyleSheetList - CSSStyleSheet You can get to a document's style sheets via Document.styleSheets and iterate through them using StyleSheetList's item() and length(). That's it in terms of functionality at this point, but still neat. :^)
2021-03-08 07:22:18 -03:00
LibWeb: Make StyleSheet and CSSStyleSheet GC-allocated
2022-08-07 08:14:54 -03:00
public:
LibWeb/CSS: Wait for resources to load to fire `<style>` load event Previously, we fired the load event immediately, without waiting for anything. This was good for not timing out, but bad for anything that wanted to wait for the load to complete. CSSStyleSheet now maintains a list of critical subresources, and waits for all of them to complete before it then tells its owner that it is ready. "Complete" here means the network request completed with or without an error. This is done by having those subresources (just `@import` for now) notify their style sheet when they complete. This then propagates up as an `@import` tells its style sheet, which then would tell its parent `@import` if it had one. There are other subresources we should wait for (specifically fonts and background images) but this commit just adds `@import` as a first step.
2026-02-05 14:40:15 -03:00
enum class LoadingState : u8 {
Unloaded,
Loading,
Loaded,
Error,
};
static StringView loading_state_name(LoadingState);
class Subresource {
public:
virtual ~Subresource() = default;
virtual GC::Ptr<CSSStyleSheet> parent_style_sheet_for_subresource() = 0;
LoadingState loading_state() const { return m_loading_state; }
virtual void visit_edges(Cell::Visitor&) = 0;
void set_loading_state(LoadingState);
private:
LoadingState m_loading_state { LoadingState::Unloaded };
};
LibWeb/CSS: Qualify uses of LibURL To prepare for introducing a CSS::URL type, we need to qualify any use of LibURL as `::URL::foo` instead of `URL::foo` so the compiler doesn't get confused. Many of these uses will be replaced, but I don't want to mix this in with what will likely already be a large change.
2025-04-08 09:35:26 -03:00
[[nodiscard]] static GC::Ref<CSSStyleSheet> create(JS::Realm&, CSSRuleList&, MediaList&, Optional<::URL::URL> location);
LibWeb/Bindings: Generate struct definitions from IDL dictionaries Previously we were inconsistent by generating code for enum definitions but not generating code for dictionaries. With future changes to the IDL generator to expose helpers to convert to and from IDL values this produced circular depdendencies. To solve this problem, also generate the dictionary definitions in bindings headers.
2026-05-01 14:01:23 -03:00
static WebIDL::ExceptionOr<GC::Ref<CSSStyleSheet>> construct_impl(JS::Realm&, Optional<Bindings::CSSStyleSheetInit> const& options = {});
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
virtual ~CSSStyleSheet() override;
LibWeb: Implement StyleSheet.type This just returns "text/css" on CSSStyleSheet, nothing exciting.
2021-03-08 12:16:28 -03:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC::Ptr<CSSRule const> owner_rule() const { return m_owner_css_rule; }
GC::Ptr<CSSRule> owner_rule() { return m_owner_css_rule; }
LibWeb: Reimplement the <style> element following the spec We now follow the "update a style block" algorithm from the HTML spec instead of using the ad-hoc CSSLoader mechanism. This necessitated improving our StyleSheet and CSSStyleSheet classes as well, so that's baked into this commit.
2021-09-29 18:46:16 -03:00
void set_owner_css_rule(CSSRule* rule) { m_owner_css_rule = rule; }
LibWeb: Port CSSStyleSheet interface from DeprecatedString to String
2023-09-02 23:19:49 -03:00
virtual String type() const override { return "text/css"_string; }
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
LibWeb: Make CSSRuleList GC-allocated
2022-08-07 08:51:40 -03:00
CSSRuleList const& rules() const { return *m_rules; }
CSSRuleList& rules() { return *m_rules; }
LibWeb: Make CSSRule and CSSRuleList available to JavaScript :^) This patch makes both of these classes inherit from RefCounted and Bindings::Wrappable, plus some minimal rejigging to allow us to keep using them internally while also exposing them to web content.
2021-09-29 14:41:46 -03:00
CSSRuleList* css_rules() { return m_rules; }
CSSRuleList const* css_rules() const { return m_rules; }
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 13:03:42 -03:00
WebIDL::ExceptionOr<unsigned> insert_rule(StringView rule, unsigned index);
LibWeb: Implement `CSSStyleSheet.addRule()` This is a legacy method that has been superseded by `insertRule()`, although it is supported by all modern browser engines.
2024-02-24 04:46:59 -03:00
WebIDL::ExceptionOr<WebIDL::Long> add_rule(Optional<String> selector, Optional<String> style, Optional<WebIDL::UnsignedLong> index);
LibWeb: Remove first rule if no argument is given for `remove_rule()` While this isn't explicitly mentioned in the specification, there is a WPT test that checks for this behavior.
2024-02-24 04:46:59 -03:00
WebIDL::ExceptionOr<void> remove_rule(Optional<WebIDL::UnsignedLong> index);
LibWeb: Move ExceptionOr from DOM/ to WebIDL/ This is a concept fully defined in the Web IDL spec and doesn't belong in the DOM directory/namespace - not even DOMException, despite the name :^)
2022-09-25 13:03:42 -03:00
WebIDL::ExceptionOr<void> delete_rule(unsigned index);
LibWeb: Add CSSStyleSheet.{insert,delete,remove}Rule() APIs Note that insertRule() is really just a big TODO right now.
2021-09-29 15:28:32 -03:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC::Ref<WebIDL::Promise> replace(String text);
LibWeb: Implement `CSSStyleSheet.replaceSync()` This method behaves the same as `CSSStyleSheet.replace()` but the operation is performed synchronously.
2024-02-24 04:46:59 -03:00
WebIDL::ExceptionOr<void> replace_sync(StringView text);
LibWeb: Implement `CSSStyleSheet.replace()` This method asynchronously replaces the content of the given stylesheet with the content passed to it. An exception is thrown if this method is used by a stylesheet not created with the `CSSStyleSheet()` constructor.
2024-02-24 04:46:59 -03:00
LibWeb/CSS: Replace style-rule iteration methods with a generic one I didn't want to add another set of boilerplatey tree-walking methods, so here's a general-purpose one. :^) `for_each_effective_rule()` walks the tree of effective style rules, and runs the callback on each one, in either pre- or postorder. The previous `for_each_effective_style/keyframes_rule()` methods of `CSSStyleSheet` are then reimplemented in terms of `for_each_effective_rule()`, and we can get rid of their equivalents elsewhere.
2024-09-03 07:43:20 -03:00
void for_each_effective_rule(TraversalOrder, Function<void(CSSRule const&)> const& callback) const;
LibWeb/CSS: Process style properties from CSSNestedDeclarations rules These are created when a style rule has properties listed after another rule. For example: ```css .test { --a: 1; --b: 1; --c: 1; .thing { /* ... */ } /* These are after a rule (.thing) so they're wrapped in a CSSNestedDeclarations: */ --d: 1; --e: 1; --f: 1; } ``` They're treated like a nested style rule with the exact same selectors as their containing style rule.
2024-10-17 09:48:00 -03:00
void for_each_effective_style_producing_rule(Function<void(CSSRule const&)> const& callback) const;
LibWeb: Only invalidate styles if a `@media` rule changes match status
2022-02-17 09:34:36 -03:00
// Returns whether the match state of any media queries changed after evaluation.
LibWeb: Use document's viewport when resolving lengths in media queries Previously we would always use the window's viewport which was incorrect if we were within an iframe. This is likely applicable to all uses of `Length::ResolutionContext::for_window`.
2025-10-06 08:54:19 -03:00
bool evaluate_media_queries(DOM::Document const&);
LibWeb: Target media query change invalidation When @media rules change match state, avoid treating that as a whole-document stylesheet change. Record the rules under the query that became effective or ineffective, build the normal stylesheet invalidation set from those rules, and invalidate only matching elements. Keep broad invalidation for rule kinds whose effects are not selector-targetable. Preserve cascade-wide fallout by reusing stylesheet-change shadow effect analysis for broad invalidations inside shadow roots. This keeps :host and slotted content current when active rules in the same shadow scope can match there. Also report an imported stylesheet's owner rule when the imported sheet's own media gate changes. Layered @import rules can affect layer ordering even when the imported sheet contributes no rules, so they need the same broad invalidation treatment as other cascade-wide rules. Add viewport resize coverage for media query breakpoints, broad shadow-root media invalidation, and empty layered imports whose media gate changes layer order.
2026-05-25 13:00:37 -03:00
bool evaluate_media_queries(DOM::Document const&, Function<void(CSSRule const&)> const& changed_rule_callback);
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 17:00:54 -03:00
void for_each_effective_keyframes_at_rule(Function<void(CSSKeyframesRule const&)> const& callback) const;
LibWeb: Rename `for_each_counter_style_at_rule` This only iterates effective rules which should be reflected in the name
2026-03-06 22:46:54 -03:00
void for_each_effective_counter_style_at_rule(Function<void(CSSCounterStyleRule const&)> const& callback) const;
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
LibWeb: Fix crash removing link stylesheet nested in a shadow tree HTMLLinkElement::removed_from() used `old_root` to find the StyleSheetList to remove the link's stylesheet from. That's wrong when the link element lives inside a shadow tree that is itself nested within a larger removed subtree: Node::remove() hands every shadow-including descendant the outer subtree's root as `old_root`, not the descendant's own containing root. So we'd look in the document's list while the sheet was actually in the shadow root's list, failing the did_remove VERIFY in StyleSheetList::remove_sheet. Fix by using the sheet's own owning-root tracking. A link-owned sheet always has exactly one owning document or shadow root (only constructed stylesheets can be adopted, and link sheets are never constructed), so we can just read that entry. Also make owning_documents_or_shadow_roots() return by const reference instead of copying the HashTable on every call, which benefits existing iterating callers too. Fixes a crash on https://nytimes.com/.
2026-04-23 12:47:53 -03:00
HashTable<GC::Ptr<DOM::Node>> const& owning_documents_or_shadow_roots() const { return m_owning_documents_or_shadow_roots; }
LibWeb: Fix insert/delete rule invalidation for adopted style sheets Invalidation for adopted style sheets was broken because we had an assumption that "active" style sheet is always attached to StyleSheetList which is not true for adopted style sheets. This change addresses that by keeping track of all documents/shadow roots that own a style sheet and notifying them about invalidation instead of going through the StyleSheetList.
2025-01-10 14:00:43 -03:00
void add_owning_document_or_shadow_root(DOM::Node& document_or_shadow_root);
void remove_owning_document_or_shadow_root(DOM::Node& document_or_shadow_root);
LibWeb: Scope broad shadow-root stylesheet invalidation When invalidate_owners() runs on a stylesheet scoped to a shadow root, we previously dirtied the host and its light-DOM side too broadly. That forced restyles on nodes the shadow-scoped stylesheet cannot match. Inspect the sheet's effective selectors and dependent features up front. Only dirty assigned nodes, the host, the host root, or host-side animation consumers when the sheet can actually reach them, while keeping purely shadow-local mutations inside the shadow tree.
2026-04-22 17:34:46 -03:00
void invalidate_owners(DOM::StyleInvalidationReason, ShadowRootStylesheetEffects const* previous_sheet_effects = nullptr);
LibWeb/CSS: Expose owning document of CSSStyleSheet This will be needed for fetching images from CSS.
2025-04-10 12:01:17 -03:00
GC::Ptr<DOM::Document> owning_document() const;
LibWeb: Invalidate stylesheet owners when disabled state changes Toggling CSSStyleSheet::disabled previously cleared the cached media match bits and reloaded fonts, but never informed the owning documents or shadow roots that style resolution was now stale. Worse, the IDL binding for the disabled attribute dispatches through a non-virtual setter on StyleSheet, so any override on CSSStyleSheet was bypassed entirely. Make set_disabled() virtual so the CSSStyleSheet override actually runs, snapshot the pre-mutation shadow-root stylesheet effects before flipping the flag, and hand them to invalidate_owners() so a disable that strips the last host-reaching rule still tears down host-side style correctly.
2026-04-22 17:35:21 -03:00
virtual void set_disabled(bool) override;
LibWeb: Add `CSSStyleSheet::for_each_owning_style_scope`
2026-04-07 04:56:37 -03:00
void for_each_owning_style_scope(Function<void(StyleScope&)> const&) const;
LibWeb: Build style invalidation data lazily Split StyleCache's rule matching data from its invalidation metadata. Allow callers to build either payload independently. Style invalidation queries no longer force a full rule cache rebuild, and rule matching no longer builds invalidation metadata as a side effect. Previously, callers often treated an absent rule cache as proof that no style invalidation metadata existed. That made some invalidation paths do nothing until something else had populated the rule cache first. Build invalidation data before reading it instead, so these paths use the metadata whenever stylesheet rules require it. Rebaseline style invalidation counter expectations for the new lazy build points. Flush setup style work in the structural :has() feature filter test before measuring each mutation, so the recomputation counters describe the mutation itself instead of leftover setup work.
2026-06-18 08:34:09 -03:00
NonnullRefPtr<StyleCache> shared_single_constructed_sheet_style_cache();
LibWeb: Avoid cold rule cache builds for :has() checks Cache lightweight selector insights on each stylesheet so cold style scopes can answer whether :has() invalidation is relevant without building a complete rule cache. This avoids forcing rule caches for shadow roots whose active sheets do not contain :has() selectors. Imported sheets contribute to their parent sheet's effective rules, so an imported sheet load or CSSOM change also clears ancestor selector insight caches. Add test-only counters and regression coverage for cold shadow roots with and without :has() selectors, plus delayed imported :has() rules.
2026-05-23 08:16:30 -03:00
SelectorInsights const& selector_insights() const;
LibWeb: Invalidate style after CSSStyleSheet.{insert,remove}Rule() When rules are inserted or removed via the CSSOM API, we now invalidate document style to ensure that any changes made are reflected. 1% progression on ACID3. :^)
2022-03-09 15:57:15 -03:00
LibWeb: Fix UAF in CSSStyleSheet CSSNamespaceRule returns a copy of a DeprecatedString, meaning that the view returned by the namespace in CSSStyleSheet is into a temporary string.
2023-11-24 03:14:24 -03:00
Optional<FlyString> default_namespace() const;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC::Ptr<CSSNamespaceRule> default_namespace_rule() const { return m_default_namespace_rule; }
LibWeb: Treat CSS selectors containing undeclared namespaces as invalid Selectors containing undeclared namespaces should be considered invalid, not just not matching any elements. Gains us 3 new WPT passes.
2025-06-23 07:40:37 -03:00
HashTable<FlyString> declared_namespaces() const;
LibWeb: Avoid copying the CSS @namespace every time we run a selector
2024-03-16 04:03:46 -03:00
LibWeb: Fix UAF in CSSStyleSheet CSSNamespaceRule returns a copy of a DeprecatedString, meaning that the view returned by the namespace in CSSStyleSheet is into a temporary string.
2023-11-24 03:14:24 -03:00
Optional<FlyString> namespace_uri(StringView namespace_prefix) const;
LibWeb: Rough implementation of CSS namespace rule This provides a rough implementation of the CSS @namespace rule. Currently we just support default namespaces, namespace prefixes are still to come.
2023-07-29 13:51:15 -03:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
Vector<GC::Ref<CSSImportRule>> const& import_rules() const { return m_import_rules; }
LibWeb: Keep track of each CSSStyleSheet's CSSImportRules This will be used to gather up a list of all loaded style sheets for the inspector.
2024-08-23 12:46:33 -03:00
LibWeb/CSS: Qualify uses of LibURL To prepare for introducing a CSS::URL type, we need to qualify any use of LibURL as `::URL::foo` instead of `URL::foo` so the compiler doesn't get confused. Many of these uses will be replaced, but I don't want to mix this in with what will likely already be a large change.
2025-04-08 09:35:26 -03:00
Optional<::URL::URL> base_url() const { return m_base_url; }
void set_base_url(Optional<::URL::URL> base_url) { m_base_url = move(base_url); }
LibWeb: Add CSSStyleSheet constructor binding
2024-02-24 04:46:59 -03:00
LibWeb: Start fetching CSS image resources before document load event Both Chromium and Gecko delay the document's load event for CSS image resource requests (background-image, mask-image, etc). We now start fetching CSS image resources as soon as their stylesheet is associated with a document, rather than deferring until layout. This is done by collecting ImageStyleValues during stylesheet parsing and initiating their fetches when the stylesheet is added to the document. Fixes #3448
2026-03-19 07:22:18 -03:00
void register_pending_image_value(ImageStyleValue& value) { m_pending_image_values.append(value); }
void load_pending_image_resources(DOM::Document&);
LibWeb: Add CSSStyleSheet constructor binding
2024-02-24 04:46:59 -03:00
bool constructed() const { return m_constructed; }
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC::Ptr<DOM::Document const> constructor_document() const { return m_constructor_document; }
void set_constructor_document(GC::Ptr<DOM::Document const> constructor_document) { m_constructor_document = constructor_document; }
LibWeb: Add CSSStyleSheet constructor binding
2024-02-24 04:46:59 -03:00
LibWeb: Implement `CSSStyleSheet.replace()` This method asynchronously replaces the content of the given stylesheet with the content passed to it. An exception is thrown if this method is used by a stylesheet not created with the `CSSStyleSheet()` constructor.
2024-02-24 04:46:59 -03:00
bool disallow_modification() const { return m_disallow_modification; }
LibWeb+LibDevTools: Report applied style rules to Firefox Collect the style rules that apply to an inspected element and expose them through the existing DOM node inspection path. This gives Firefox's Rules panel real rule forms instead of the previous empty getApplied response.
2026-06-04 12:59:14 -03:00
void set_source_text(String source) { m_source_text = move(source); }
Optional<String> source_text() const { return m_source_text; }
LibWeb/CSS: Store the style sheet's source text on the CSSStyleSheet This is to enable the inspector to show this source. There's a fairly hefty FIXME here because duplicating the source text is a significant waste of memory. But I don't want to get too sidetracked.
2024-08-22 13:23:54 -03:00
LibWeb/CSS: Wait for resources to load to fire `<style>` load event Previously, we fired the load event immediately, without waiting for anything. This was good for not timing out, but bad for anything that wanted to wait for the load to complete. CSSStyleSheet now maintains a list of critical subresources, and waits for all of them to complete before it then tells its owner that it is ready. "Complete" here means the network request completed with or without an error. This is done by having those subresources (just `@import` for now) notify their style sheet when they complete. This then propagates up as an `@import` tells its style sheet, which then would tell its parent `@import` if it had one. There are other subresources we should wait for (specifically fonts and background images) but this commit just adds `@import` as a first step.
2026-02-05 14:40:15 -03:00
void add_critical_subresource(Subresource&);
void remove_critical_subresource(Subresource&);
LoadingState loading_state() const;
void check_if_loading_completed();
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
private:
LibWeb/CSS: Qualify uses of LibURL To prepare for introducing a CSS::URL type, we need to qualify any use of LibURL as `::URL::foo` instead of `URL::foo` so the compiler doesn't get confused. Many of these uses will be replaced, but I don't want to mix this in with what will likely already be a large change.
2025-04-08 09:35:26 -03:00
CSSStyleSheet(JS::Realm&, CSSRuleList&, MediaList&, Optional<::URL::URL> location);
LibWeb: Remove unecessary dependence on Window from CSS classes These classes only needed Window to get at its realm. Pass a realm directly to construct CSS classes.
2022-09-24 19:34:04 -03:00
LibJS: Make Cell::initialize() return void Stop worrying about tiny OOMs. Work towards #20405
2023-08-07 03:41:28 -03:00
virtual void initialize(JS::Realm&) override;
LibWeb: Make StyleSheetList GC-allocated
2022-08-07 08:29:49 -03:00
virtual void visit_edges(Cell::Visitor&) override;
LibWeb: Account stylesheet storage as external memory Report stylesheet source text, rule lists, namespace caches, declaration vectors, custom property maps, and owner sets through the GC external memory hook.
2026-05-06 03:36:34 -03:00
virtual size_t external_memory_size() const override;
LibWeb: Make StyleSheetList GC-allocated
2022-08-07 08:29:49 -03:00
LibWeb: Keep track of each CSSStyleSheet's CSSImportRules This will be used to gather up a list of all loaded style sheets for the inspector.
2024-08-23 12:46:33 -03:00
void recalculate_rule_caches();
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
void invalidate_shared_style_cache();
LibWeb: Speed up CSS namespace checking CSSStyleSheet now caches the CSSNamespaceRule for the default namespace, which is the only one we currently care about. This saves us from iterating over its list of rules every time we want to know what that default namespace is. The spec dictates that `@namespace` rules are only valid near the start of a stylesheet, so we also take advantage of that to quit searching for namespaces as soon as we see a non-import rule. Also renamed `namespace_filter()` to `default_namespace()` since that's what it actually returns. This makes github.com/serenityos/serenity snappy again. :^)
2023-07-31 13:46:57 -03:00
LibWeb: Add CSSStyleSheet constructor binding
2024-02-24 04:46:59 -03:00
void set_constructed(bool constructed) { m_constructed = constructed; }
LibWeb: Implement `CSSStyleSheet.replace()` This method asynchronously replaces the content of the given stylesheet with the content passed to it. An exception is thrown if this method is used by a stylesheet not created with the `CSSStyleSheet()` constructor.
2024-02-24 04:46:59 -03:00
void set_disallow_modification(bool disallow_modification) { m_disallow_modification = disallow_modification; }
LibWeb: Add CSSStyleSheet constructor binding
2024-02-24 04:46:59 -03:00
LibWeb/CSS: Extract CSSStyleSheet's ParsingParams code into a method This repeated code is a bit unwieldy.
2025-04-08 14:10:38 -03:00
Parser::ParsingParams make_parsing_params() const;
LibWeb/CSS: Store the style sheet's source text on the CSSStyleSheet This is to enable the inspector to show this source. There's a fairly hefty FIXME here because duplicating the source text is a significant waste of memory. But I don't want to get too sidetracked.
2024-08-22 13:23:54 -03:00
Optional<String> m_source_text;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC::Ptr<CSSRuleList> m_rules;
GC::Ptr<CSSNamespaceRule> m_default_namespace_rule;
HashMap<FlyString, GC::Ptr<CSSNamespaceRule>> m_namespace_rules;
Vector<GC::Ref<CSSImportRule>> m_import_rules;
LibWeb: Reimplement the <style> element following the spec We now follow the "update a style block" algorithm from the HTML spec instead of using the ad-hoc CSSLoader mechanism. This necessitated improving our StyleSheet and CSSStyleSheet classes as well, so that's baked into this commit.
2021-09-29 18:46:16 -03:00
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC::Ptr<CSSRule> m_owner_css_rule;
LibWeb: Add CSSStyleSheet constructor binding
2024-02-24 04:46:59 -03:00
LibWeb/CSS: Qualify uses of LibURL To prepare for introducing a CSS::URL type, we need to qualify any use of LibURL as `::URL::foo` instead of `URL::foo` so the compiler doesn't get confused. Many of these uses will be replaced, but I don't want to mix this in with what will likely already be a large change.
2025-04-08 09:35:26 -03:00
Optional<::URL::URL> m_base_url;
LibGC+Everywhere: Factor out a LibGC from LibJS Resulting in a massive rename across almost everywhere! Alongside the namespace change, we now have the following names: * JS::NonnullGCPtr -> GC::Ref * JS::GCPtr -> GC::Ptr * JS::HeapFunction -> GC::Function * JS::CellImpl -> GC::Cell * JS::Handle -> GC::Root
2024-11-14 12:01:23 -03:00
GC::Ptr<DOM::Document const> m_constructor_document;
LibWeb: Fix insert/delete rule invalidation for adopted style sheets Invalidation for adopted style sheets was broken because we had an assumption that "active" style sheet is always attached to StyleSheetList which is not true for adopted style sheets. This change addresses that by keeping track of all documents/shadow roots that own a style sheet and notifying them about invalidation instead of going through the StyleSheetList.
2025-01-10 14:00:43 -03:00
HashTable<GC::Ptr<DOM::Node>> m_owning_documents_or_shadow_roots;
LibWeb: Add CSSStyleSheet constructor binding
2024-02-24 04:46:59 -03:00
bool m_constructed { false };
LibWeb: Implement `CSSStyleSheet.replace()` This method asynchronously replaces the content of the given stylesheet with the content passed to it. An exception is thrown if this method is used by a stylesheet not created with the `CSSStyleSheet()` constructor.
2024-02-24 04:46:59 -03:00
bool m_disallow_modification { false };
LibWeb: Avoid calling matches before evaluate
2024-08-11 12:34:37 -03:00
Optional<bool> m_did_match;
LibWeb: Avoid cold rule cache builds for :has() checks Cache lightweight selector insights on each stylesheet so cold style scopes can answer whether :has() invalidation is relevant without building a complete rule cache. This avoids forcing rule caches for shadow roots whose active sheets do not contain :has() selectors. Imported sheets contribute to their parent sheet's effective rules, so an imported sheet load or CSSOM change also clears ancestor selector insight caches. Add test-only counters and regression coverage for cold shadow roots with and without :has() selectors, plus delayed imported :has() rules.
2026-05-23 08:16:30 -03:00
mutable Optional<SelectorInsights> m_selector_insights;
LibWeb: Share singleton constructed stylesheet rule caches Share the style cache for shadow roots whose only active author sheet is the same constructed stylesheet. Matching already carries the effective shadow root separately, so the cache can be reused while selectors such as :host and ::slotted() still evaluate against each consuming shadow root. Keep the optimization conservative by falling back to the existing per-scope cache whenever the shadow root has multiple active sheets, a non-constructed sheet, or a page user stylesheet. Drop the shared cache when the stylesheet rules or media query match state change. Add coverage for two shadow roots adopting the same constructed sheet, including :host, ::slotted(), and replaceSync() invalidation.
2026-04-28 05:27:31 -03:00
RefPtr<StyleCache> m_shared_single_constructed_sheet_style_cache;
LibWeb: Remove all font loaders linked to a StyleSheet when it's deleted When a style sheet is removed, all font loaders created from that style sheet should also be removed.
2024-09-22 13:10:46 -03:00
LibWeb/CSS: Wait for resources to load to fire `<style>` load event Previously, we fired the load event immediately, without waiting for anything. This was good for not timing out, but bad for anything that wanted to wait for the load to complete. CSSStyleSheet now maintains a list of critical subresources, and waits for all of them to complete before it then tells its owner that it is ready. "Complete" here means the network request completed with or without an error. This is done by having those subresources (just `@import` for now) notify their style sheet when they complete. This then propagates up as an `@import` tells its style sheet, which then would tell its parent `@import` if it had one. There are other subresources we should wait for (specifically fonts and background images) but this commit just adds `@import` as a first step.
2026-02-05 14:40:15 -03:00
Vector<Subresource&> m_critical_subresources;
LibWeb: Start fetching CSS image resources before document load event Both Chromium and Gecko delay the document's load event for CSS image resource requests (background-image, mask-image, etc). We now start fetching CSS image resources as soon as their stylesheet is associated with a document, rather than deferring until layout. This is done by collecting ImageStyleValues during stylesheet parsing and initiating their fetches when the stylesheet is added to the document. Fixes #3448
2026-03-19 07:22:18 -03:00
LibWeb: Avoid stale CSS image style GC pointers ImageStyleValue stored GC-managed request, stylesheet, and animation timer references as strong GC::Ptr fields even though image style values are refcounted objects. When such a style value outlives the GC object that normally visits it, those fields can keep stale pointers after GC collects the referents. On Steam this allowed a stale image resource request to be read as unrelated image data, making carousel SVG arrows render at the wrong size. Store these back references as GC::Weak instead. Reachable style values still use live requests, stylesheets, and timers normally, but detached values observe null after the GC collects the referent and can reload or skip the now-dead association instead of dereferencing reused GC memory. Keep a local timer handle while installing the timeout callback so setup does not rely on the weak member. With the image style values no longer hiding strong GC edges, remove the obsolete IGNORE_GC annotation from CSSStyleSheet's pending image list.
2026-05-24 23:29:10 -03:00
Vector<WeakPtr<ImageStyleValue>> m_pending_image_values;
LibWeb: Split CSS::StyleSheet into StyleSheet and CSSStyleSheet This is a little convoluted but matches the CSSOM specification.
2021-03-07 12:14:04 -03:00
};
}
Reference in a new issue Copy permalink