Struct TrustedTypePolicy 

#[repr(C)]
pub struct TrustedTypePolicy {
    reflector_: Reflector,
    name: String,
    create_html: Option<Rc<CreateHTMLCallback<DomTypeHolder>>>,
    create_script: Option<Rc<CreateScriptCallback<DomTypeHolder>>>,
    create_script_url: Option<Rc<CreateScriptURLCallback<DomTypeHolder>>>,
}

Fields

reflector_: Reflector

name: String

create_html: Option<Rc<CreateHTMLCallback<DomTypeHolder>>>

create_script: Option<Rc<CreateScriptCallback<DomTypeHolder>>>

create_script_url: Option<Rc<CreateScriptURLCallback<DomTypeHolder>>>

Implementations

impl TrustedTypePolicy

fn __assert_parent_type(&self)

impl TrustedTypePolicy

fn new_inherited( name: String, options: &TrustedTypePolicyOptions<DomTypeHolder>, ) -> Self

pub(crate) fn new( name: String, options: &TrustedTypePolicyOptions<DomTypeHolder>, global: &GlobalScope, can_gc: CanGc, ) -> DomRoot<Self>

fn check_callback_if_missing( throw_if_missing: bool, ) -> Fallible<Option<DOMString>>

https://w3c.github.io/trusted-types/dist/spec/#get-trusted-type-policy-value-algorithm

pub(crate) fn get_trusted_type_policy_value( &self, expected_type: TrustedType, input: DOMString, arguments: Vec<HandleValue<'_>>, throw_if_missing: bool, can_gc: CanGc, ) -> Fallible<Option<DOMString>>

https://w3c.github.io/trusted-types/dist/spec/#get-trusted-type-policy-value-algorithm

fn create_trusted_type<R, TrustedTypeCallback>( &self, expected_type: TrustedType, input: DOMString, arguments: Vec<HandleValue<'_>>, trusted_type_creation_callback: TrustedTypeCallback, can_gc: CanGc, ) -> Fallible<DomRoot<R>>

where R: DomObject, TrustedTypeCallback: FnOnce(DOMString) -> DomRoot<R>,

This does not take all arguments as specified. That’s because the return type of the trusted type function and object are not the same. 2 of the 3 string callbacks return a DOMString, while the other one returns an USVString. Additionally, all three callbacks have a unique type signature in WebIDL.

To circumvent these type problems, rather than implementing the full functionality here, part of the algorithm is implemented on the caller side. There, we only call the callback and create the object. The rest of the machinery is ensuring the right values pass through to the relevant callbacks.

https://w3c.github.io/trusted-types/dist/spec/#create-a-trusted-type-algorithm

Trait Implementations

impl DomObject for TrustedTypePolicy

fn reflector(&self) -> &Reflector

Returns the receiver’s reflector.

impl DomObjectWrap<DomTypeHolder> for TrustedTypePolicy

const WRAP: unsafe fn(SafeJSContext, &GlobalScope, Option<HandleObject<'_>>, Box<Self>, CanGc) -> Root<Dom<Self>> = {script_bindings::codegen::GenericBindings::TrustedTypePolicyBinding::Wrap::<dom::bindings::codegen::DomTypeHolder::DomTypeHolder> as for<'a, 'b> unsafe fn(script_bindings::script_runtime::JSContext, &'a dom::globalscope::GlobalScope, std::option::Option<js::rust::Handle<'b, *mut js::jsapi::JSObject>>, std::boxed::Box<dom::trustedtypepolicy::TrustedTypePolicy>, script_bindings::script_runtime::CanGc) -> script_bindings::root::Root<script_bindings::root::Dom<dom::trustedtypepolicy::TrustedTypePolicy>>}

Function pointer to the general wrap function type

impl HasParent for TrustedTypePolicy

fn as_parent(&self) -> &Reflector

This is used in a type assertion to ensure that the source and webidls agree as to what the parent type is

type Parent = Reflector

impl IDLInterface for TrustedTypePolicy

fn derives(class: &'static DOMClass) -> bool

Returns whether the given DOM class derives that interface.

impl MallocSizeOf for TrustedTypePolicy

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl MutDomObject for TrustedTypePolicy

unsafe fn init_reflector(&self, obj: *mut JSObject)

Initializes the Reflector

impl PartialEq for TrustedTypePolicy

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToJSValConvertible for TrustedTypePolicy

unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue<'_>)

Convert self to a JSVal. JSAPI failure causes a panic.

impl Traceable for TrustedTypePolicy

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

impl TrustedTypePolicyMethods<DomTypeHolder> for TrustedTypePolicy

fn Name(&self) -> DOMString

https://www.w3.org/TR/trusted-types/#dom-trustedtypepolicy-name

fn CreateHTML( &self, _cx: JSContext, input: DOMString, arguments: Vec<HandleValue<'_>>, can_gc: CanGc, ) -> Fallible<DomRoot<TrustedHTML>>

https://www.w3.org/TR/trusted-types/#dom-trustedtypepolicy-createhtml

fn CreateScript( &self, _cx: JSContext, input: DOMString, arguments: Vec<HandleValue<'_>>, can_gc: CanGc, ) -> Fallible<DomRoot<TrustedScript>>

https://www.w3.org/TR/trusted-types/#dom-trustedtypepolicy-createscript

fn CreateScriptURL( &self, _cx: JSContext, input: DOMString, arguments: Vec<HandleValue<'_>>, can_gc: CanGc, ) -> Fallible<DomRoot<TrustedScriptURL>>

https://www.w3.org/TR/trusted-types/#dom-trustedtypepolicy-createscripturl

impl Eq for TrustedTypePolicy