Implement trusted types for setAttribute

Callers now call `set_attribute` directly, to avoid the
trusted types machinery, as well as skip validation. That's
not required by spec as well.

This implements part of the DOM integration from
whatwg/dom#1268

Part of servo#36258

Signed-off-by: Tim van der Lippe <[email protected]>

Author: TimvdLippe

components/script/devtools.rs

@@ -11,11 +11,13 @@ use devtools_traits::{
     AttrModification, AutoMargins, ComputedNodeLayout, CssDatabaseProperty, EvaluateJSReply,
     NodeInfo, NodeStyle, RuleModification, TimelineMarker, TimelineMarkerType,
 };
+use html5ever::LocalName;
 use ipc_channel::ipc::IpcSender;
 use js::conversions::jsstr_to_string;
 use js::jsval::UndefinedValue;
 use js::rust::ToString;
 use servo_config::pref;
+use style::attr::AttrValue;
 use uuid::Uuid;
 
 use crate::document_collection::DocumentCollection;
@@ -435,9 +437,9 @@ pub(crate) fn handle_modify_attribute(
     for modification in modifications {
         match modification.new_value {
             Some(string) => {
-                let _ = elem.SetAttribute(
-                    DOMString::from(modification.attribute_name),
-                    DOMString::from(string),
+                elem.set_attribute(
+                    &LocalName::from(modification.attribute_name),
+                    AttrValue::String(string),
                     can_gc,
                 );
             },

components/script/dom/element.rs

@@ -87,7 +87,9 @@ use crate::dom::bindings::codegen::Bindings::WindowBinding::{
 };
 use crate::dom::bindings::codegen::UnionTypes::{
     BooleanOrScrollIntoViewOptions, NodeOrString, TrustedHTMLOrNullIsEmptyString,
-    TrustedHTMLOrString, TrustedScriptURLOrUSVString,
+    TrustedHTMLOrString,
+    TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString as TrustedTypeOrString,
+    TrustedScriptURLOrUSVString,
 };
 use crate::dom::bindings::conversions::DerivedFrom;
 use crate::dom::bindings::domname::{
@@ -161,6 +163,7 @@ use crate::dom::servoparser::ServoParser;
 use crate::dom::shadowroot::{IsUserAgentWidget, ShadowRoot};
 use crate::dom::text::Text;
 use crate::dom::trustedhtml::TrustedHTML;
+use crate::dom::trustedtypepolicyfactory::TrustedTypePolicyFactory;
 use crate::dom::validation::Validatable;
 use crate::dom::validitystate::ValidationFlags;
 use crate::dom::virtualmethods::{VirtualMethods, vtable_for};
@@ -752,7 +755,7 @@ impl Element {
 
     // https://html.spec.whatwg.org/multipage/#translation-mode
     pub(crate) fn is_translate_enabled(&self) -> bool {
-        let name = &html5ever::local_name!("translate");
+        let name = &local_name!("translate");
         if self.has_attribute(name) {
             match_ignore_ascii_case! { &*self.get_string_attribute(name),
                 "yes" | "" => return true,
@@ -3250,17 +3253,39 @@ impl ElementMethods<crate::DomTypeHolder> for Element {
     }
 
     /// <https://dom.spec.whatwg.org/#dom-element-setattribute>
-    fn SetAttribute(&self, name: DOMString, value: DOMString, can_gc: CanGc) -> ErrorResult {
-        // Step 1. If qualifiedName is not a valid attribute local name,
-        //      then throw an "InvalidCharacterError" DOMException.
+    fn SetAttribute(
+        &self,
+        name: DOMString,
+        value: TrustedTypeOrString,
+        can_gc: CanGc,
+    ) -> ErrorResult {
+        // Step 1. If qualifiedName does not match the Name production in XML,
+        // then throw an "InvalidCharacterError" DOMException.
         if !is_valid_attribute_local_name(&name) {
             return Err(Error::InvalidCharacter);
         }
 
-        // Step 2.
+        // Step 2. If this is in the HTML namespace and its node document is an HTML document,
+        // then set qualifiedName to qualifiedName in ASCII lowercase.
         let name = self.parsed_name(name);
 
-        // Step 3-5.
+        // Step 3. Let verifiedValue be the result of calling get
+        // Trusted Types-compliant attribute value with qualifiedName, null,
+        // this, and value. [TRUSTED-TYPES]
+        let value = TrustedTypePolicyFactory::get_trusted_types_compliant_attribute_value(
+            self.namespace(),
+            self.local_name(),
+            &name,
+            None,
+            value,
+            &self.owner_global(),
+            can_gc,
+        )?;
+
+        // Step 4. Let attribute be the first attribute in this’s attribute list whose qualified name is qualifiedName, and null otherwise.
+        // Step 5. If attribute is null, create an attribute whose local name is qualifiedName, value is verifiedValue, and node document
+        // is this’s node document, then append this attribute to this, and then return.
+        // Step 6. Change attribute to verifiedValue.
         let value = self.parse_attribute(&ns!(), &name, value);
         self.set_first_matching_attribute(
             name.clone(),
@@ -3279,20 +3304,29 @@ impl ElementMethods<crate::DomTypeHolder> for Element {
         &self,
         namespace: Option<DOMString>,
         qualified_name: DOMString,
-        value: DOMString,
+        value: TrustedTypeOrString,
         can_gc: CanGc,
     ) -> ErrorResult {
-        // Step 1. Let (namespace, prefix, localName) be the result of validating and
-        //      extracting namespace and qualifiedName given "element".
-        let context = domname::Context::Element;
+        // Step 1. Let namespace, prefix, and localName be the result of passing namespace and qualifiedName to validate and extract.
         let (namespace, prefix, local_name) =
-            domname::validate_and_extract(namespace, &qualified_name, context)?;
-        let qualified_name = LocalName::from(qualified_name);
+            domname::validate_and_extract(namespace, &qualified_name, domname::Context::Element)?;
+        // Step 2. Let verifiedValue be the result of calling get
+        // Trusted Types-compliant attribute value with localName, namespace, element, and value. [TRUSTED-TYPES]
+        let value = TrustedTypePolicyFactory::get_trusted_types_compliant_attribute_value(
+            self.namespace(),
+            self.local_name(),
+            &local_name,
+            Some(&namespace),
+            value,
+            &self.owner_global(),
+            can_gc,
+        )?;
+        // Step 3. Set an attribute value for this using localName, verifiedValue, and also prefix and namespace.
         let value = self.parse_attribute(&namespace, &local_name, value);
         self.set_first_matching_attribute(
             local_name.clone(),
             value,
-            qualified_name,
+            LocalName::from(qualified_name),
             namespace.clone(),
             prefix,
             |attr| *attr.local_name() == local_name && *attr.namespace() == namespace,

components/script/dom/htmlaudioelement.rs

@@ -5,8 +5,8 @@
 use dom_struct::dom_struct;
 use html5ever::{LocalName, Prefix, QualName, local_name, ns};
 use js::rust::HandleObject;
+use style::attr::AttrValue;
 
-use crate::dom::bindings::codegen::Bindings::ElementBinding::Element_Binding::ElementMethods;
 use crate::dom::bindings::codegen::Bindings::HTMLAudioElementBinding::HTMLAudioElementMethods;
 use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use crate::dom::bindings::error::Fallible;
@@ -75,15 +75,17 @@ impl HTMLAudioElementMethods<crate::DomTypeHolder> for HTMLAudioElement {
 
         let audio = DomRoot::downcast::<HTMLAudioElement>(element).unwrap();
 
-        audio
-            .upcast::<Element>()
-            .SetAttribute(DOMString::from("preload"), DOMString::from("auto"), can_gc)
-            .expect("should be infallible");
+        audio.upcast::<Element>().set_attribute(
+            &local_name!("preload"),
+            AttrValue::String("auto".to_owned()),
+            can_gc,
+        );
         if let Some(s) = src {
-            audio
-                .upcast::<Element>()
-                .SetAttribute(DOMString::from("src"), s, can_gc)
-                .expect("should be infallible");
+            audio.upcast::<Element>().set_attribute(
+                &local_name!("src"),
+                AttrValue::String(s.into()),
+                can_gc,
+            );
         }
 
         Ok(audio)

components/script/dom/trustedhtml.rs

@@ -17,7 +17,7 @@ use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::str::DOMString;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::trustedtypepolicy::TrustedType;
-use crate::dom::trustedtypepolicyfactory::TrustedTypePolicyFactory;
+use crate::dom::trustedtypepolicyfactory::{DEFAULT_SCRIPT_SINK_GROUP, TrustedTypePolicyFactory};
 use crate::script_runtime::CanGc;
 
 #[dom_struct]
@@ -53,14 +53,18 @@ impl TrustedHTML {
                     global,
                     value,
                     sink,
-                    "'script'",
+                    DEFAULT_SCRIPT_SINK_GROUP,
                     can_gc,
                 )
             },
 
             TrustedHTMLOrString::TrustedHTML(trusted_html) => Ok(trusted_html.data.clone()),
         }
     }
+
+    pub(crate) fn data(&self) -> DOMString {
+        self.data.clone()
+    }
 }
 
 impl fmt::Display for TrustedHTML {

components/script/dom/trustedscript.rs

@@ -16,7 +16,7 @@ use crate::dom::bindings::str::DOMString;
 use crate::dom::csp::CspReporting;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::trustedtypepolicy::TrustedType;
-use crate::dom::trustedtypepolicyfactory::TrustedTypePolicyFactory;
+use crate::dom::trustedtypepolicyfactory::{DEFAULT_SCRIPT_SINK_GROUP, TrustedTypePolicyFactory};
 use crate::script_runtime::{CanGc, JSContext};
 
 #[dom_struct]
@@ -52,7 +52,7 @@ impl TrustedScript {
                     global,
                     value,
                     sink,
-                    "'script'",
+                    DEFAULT_SCRIPT_SINK_GROUP,
                     can_gc,
                 )
             },

components/script/dom/trustedscripturl.rs

@@ -14,7 +14,7 @@ use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::str::DOMString;
 use crate::dom::globalscope::GlobalScope;
 use crate::dom::trustedtypepolicy::TrustedType;
-use crate::dom::trustedtypepolicyfactory::TrustedTypePolicyFactory;
+use crate::dom::trustedtypepolicyfactory::{DEFAULT_SCRIPT_SINK_GROUP, TrustedTypePolicyFactory};
 use crate::script_runtime::CanGc;
 
 #[dom_struct]
@@ -52,7 +52,7 @@ impl TrustedScriptURL {
                     global,
                     value.as_ref().into(),
                     &sink,
-                    "'script'",
+                    DEFAULT_SCRIPT_SINK_GROUP,
                     can_gc,
                 )
             },
@@ -61,6 +61,10 @@ impl TrustedScriptURL {
             },
         }
     }
+
+    pub(crate) fn data(&self) -> DOMString {
+        self.data.clone()
+    }
 }
 
 impl fmt::Display for TrustedScriptURL {

components/script/dom/trustedtypepolicy.rs

@@ -6,13 +6,14 @@ use std::rc::Rc;
 
 use dom_struct::dom_struct;
 use js::rust::HandleValue;
-use strum_macros::IntoStaticStr;
+use strum_macros::AsRefStr;
 
 use crate::dom::bindings::callback::ExceptionHandling;
 use crate::dom::bindings::codegen::Bindings::TrustedTypePolicyBinding::TrustedTypePolicyMethods;
 use crate::dom::bindings::codegen::Bindings::TrustedTypePolicyFactoryBinding::{
     CreateHTMLCallback, CreateScriptCallback, CreateScriptURLCallback, TrustedTypePolicyOptions,
 };
+use crate::dom::bindings::codegen::UnionTypes::TrustedHTMLOrTrustedScriptOrTrustedScriptURLOrString as TrustedTypeOrString;
 use crate::dom::bindings::error::Error::Type;
 use crate::dom::bindings::error::Fallible;
 use crate::dom::bindings::reflector::{DomGlobal, DomObject, Reflector, reflect_dom_object};
@@ -38,13 +39,29 @@ pub struct TrustedTypePolicy {
     create_script_url: Option<Rc<CreateScriptURLCallback>>,
 }
 
-#[derive(Clone, IntoStaticStr)]
+#[derive(AsRefStr, Clone)]
 pub(crate) enum TrustedType {
     TrustedHTML,
     TrustedScript,
     TrustedScriptURL,
 }
 
+impl TrustedType {
+    pub(crate) fn matches_idl_trusted_type(&self, idl_trusted_type: &TrustedTypeOrString) -> bool {
+        match self {
+            TrustedType::TrustedHTML => {
+                matches!(idl_trusted_type, TrustedTypeOrString::TrustedHTML(_))
+            },
+            TrustedType::TrustedScript => {
+                matches!(idl_trusted_type, TrustedTypeOrString::TrustedScript(_))
+            },
+            TrustedType::TrustedScriptURL => {
+                matches!(idl_trusted_type, TrustedTypeOrString::TrustedScriptURL(_))
+            },
+        }
+    }
+}
+
 impl TrustedTypePolicy {
     fn new_inherited(name: String, options: &TrustedTypePolicyOptions) -> Self {
         Self {