script: Create CSSStyleOwner::Null for getComputedStyle (#36272)

This new `CSSStyleOwner` variant is used when the pseudo-element
argument fails to parse properly or is for some unknown or unsupported
pseudo-element.

Testing: There are tests for this change. Various tests start to pass
and some start to
fail. New failures are due to partial or fully missing support for
pseudo-elements such
as:
 - `::selection`
 - `::first-letter` and `::first-line`
 - `::marker`

Co-authored-by: Oriol Brufau <obrufau@igalia.com>
Signed-off-by: Martin Robinson <mrobinson@igalia.com>

Signed-off-by: Martin Robinson <mrobinson@igalia.com>
Co-authored-by: Oriol Brufau <obrufau@igalia.com>

components/script/dom/cssstyledeclaration.rs

@@ -45,6 +45,9 @@ pub(crate) struct CSSStyleDeclaration {
 #[derive(JSTraceable, MallocSizeOf)]
 #[cfg_attr(crown, crown::unrooted_must_root_lint::must_root)]
 pub(crate) enum CSSStyleOwner {
+    /// Used when calling `getComputedStyle()` with an invalid pseudo-element selector.
+    /// See <https://drafts.csswg.org/cssom/#dom-window-getcomputedstyle>
+    Null,
     Element(Dom<Element>),
     CSSRule(
         Dom<CSSRule>,
@@ -66,6 +69,9 @@ impl CSSStyleOwner {
         // This is somewhat complex but the complexity is encapsulated.
         let mut changed = true;
         match *self {
+            CSSStyleOwner::Null => unreachable!(
+                "CSSStyleDeclaration should always be read-only when CSSStyleOwner is Null"
+            ),
             CSSStyleOwner::Element(ref el) => {
                 let document = el.owner_document();
                 let shared_lock = document.style_shared_lock();
@@ -135,6 +141,9 @@ impl CSSStyleOwner {
         F: FnOnce(&PropertyDeclarationBlock) -> R,
     {
         match *self {
+            CSSStyleOwner::Null => {
+                unreachable!("Should never call with_block for CSStyleOwner::Null")
+            },
             CSSStyleOwner::Element(ref el) => match *el.style_attribute().borrow() {
                 Some(ref pdb) => {
                     let document = el.owner_document();
@@ -155,6 +164,9 @@ impl CSSStyleOwner {
 
     fn window(&self) -> DomRoot<Window> {
         match *self {
+            CSSStyleOwner::Null => {
+                unreachable!("Should never try to access window of CSStyleOwner::Null")
+            },
             CSSStyleOwner::Element(ref el) => el.owner_window(),
             CSSStyleOwner::CSSRule(ref rule, _) => DomRoot::from_ref(rule.global().as_window()),
         }
@@ -162,6 +174,9 @@ impl CSSStyleOwner {
 
     fn base_url(&self) -> ServoUrl {
         match *self {
+            CSSStyleOwner::Null => {
+                unreachable!("Should never try to access base URL of CSStyleOwner::Null")
+            },
             CSSStyleOwner::Element(ref el) => el.owner_document().base_url(),
             CSSStyleOwner::CSSRule(ref rule, _) => ServoUrl::from(
                 rule.parent_stylesheet()
@@ -221,6 +236,13 @@ impl CSSStyleDeclaration {
         pseudo: Option<PseudoElement>,
         modification_access: CSSModificationAccess,
     ) -> CSSStyleDeclaration {
+        // If creating a CSSStyleDeclaration with CSSSStyleOwner::Null, this should always
+        // be in read-only mode.
+        assert!(
+            !matches!(owner, CSSStyleOwner::Null) ||
+                modification_access == CSSModificationAccess::Readonly
+        );
+
         CSSStyleDeclaration {
             reflector_: Reflector::new(),
             owner,
@@ -262,10 +284,15 @@ impl CSSStyleDeclaration {
                 node.owner_window()
                     .resolved_style_query(addr, self.pseudo, property, can_gc)
             },
+            CSSStyleOwner::Null => DOMString::new(),
         }
     }
 
     fn get_property_value(&self, id: PropertyId, can_gc: CanGc) -> DOMString {
+        if matches!(self.owner, CSSStyleOwner::Null) {
+            return DOMString::new();
+        }
+
         if self.readonly {
             // Readonly style declarations are used for getComputedStyle.
             return self.get_computed_style(id, can_gc);
@@ -388,6 +415,10 @@ pub(crate) static ENABLED_LONGHAND_PROPERTIES: LazyLock<Vec<LonghandId>> = LazyL
 impl CSSStyleDeclarationMethods<crate::DomTypeHolder> for CSSStyleDeclaration {
     // https://dev.w3.org/csswg/cssom/#dom-cssstyledeclaration-length
     fn Length(&self) -> u32 {
+        if matches!(self.owner, CSSStyleOwner::Null) {
+            return 0;
+        }
+
         if self.readonly {
             // Readonly style declarations are used for getComputedStyle.
             // TODO: include custom properties whose computed value is not the guaranteed-invalid value.
@@ -489,6 +520,9 @@ impl CSSStyleDeclarationMethods<crate::DomTypeHolder> for CSSStyleDeclaration {
 
     // https://dev.w3.org/csswg/cssom/#the-cssstyledeclaration-interface
     fn IndexedGetter(&self, index: u32) -> Option<DOMString> {
+        if matches!(self.owner, CSSStyleOwner::Null) {
+            return None;
+        }
         if self.readonly {
             // Readonly style declarations are used for getComputedStyle.
             // TODO: include custom properties whose computed value is not the guaranteed-invalid value.

components/script/dom/window.rs

@@ -1241,7 +1241,13 @@ impl WindowMethods<crate::DomTypeHolder> for Window {
         element: &Element,
         pseudo: Option<DOMString>,
     ) -> DomRoot<CSSStyleDeclaration> {
-        // Steps 1-4.
+        // Step 2: Let obj be elt.
+        // We don't store CSSStyleOwner directly because it stores a `Dom` which must be
+        // rooted. This avoids the rooting the value temporarily.
+        let mut is_null = false;
+
+        // Step 3: If pseudoElt is provided, is not the empty string, and starts with a colon, then:
+        // Step 3.1: Parse pseudoElt as a <pseudo-element-selector>, and let type be the result.
         let pseudo = pseudo.map(|mut s| {
             s.make_ascii_lowercase();
             s
@@ -1253,13 +1259,38 @@ impl WindowMethods<crate::DomTypeHolder> for Window {
             Some(ref pseudo) if pseudo == ":after" || pseudo == "::after" => {
                 Some(PseudoElement::After)
             },
+            Some(ref pseudo) if pseudo == "::selection" => Some(PseudoElement::Selection),
+            Some(ref pseudo) if pseudo.starts_with(':') => {
+                // Step 3.2: If type is failure, or is a ::slotted() or ::part()
+                // pseudo-element, let obj be null.
+                is_null = true;
+                None
+            },
             _ => None,
         };
 
-        // Step 5.
+        // Step 4. Let decls be an empty list of CSS declarations.
+        // Step 5: If obj is not null, and elt is connected, part of the flat tree, and
+        // its shadow-including root has a browsing context which either doesn’t have a
+        // browsing context container, or whose browsing context container is being
+        // rendered, set decls to a list of all longhand properties that are supported CSS
+        // properties, in lexicographical order, with the value being the resolved value
+        // computed for obj using the style rules associated with doc.  Additionally,
+        // append to decls all the custom properties whose computed value for obj is not
+        // the guaranteed-invalid value.
+        //
+        // Note: The specification says to generate the list of declarations beforehand, yet
+        // also says the list should be alive. This is why we do not do step 4 and 5 here.
+        // See: https://github.com/w3c/csswg-drafts/issues/6144
+        //
+        // Step 6:  Return a live CSSStyleProperties object with the following properties:
         CSSStyleDeclaration::new(
             self,
-            CSSStyleOwner::Element(Dom::from_ref(element)),
+            if is_null {
+                CSSStyleOwner::Null
+            } else {
+                CSSStyleOwner::Element(Dom::from_ref(element))
+            },
             pseudo,
             CSSModificationAccess::Readonly,
             CanGc::note(),