diff options
Diffstat (limited to 'components/script/dom/bindings/interface.rs')
| -rw-r--r-- | components/script/dom/bindings/interface.rs | 177 |
1 files changed, 155 insertions, 22 deletions
diff --git a/components/script/dom/bindings/interface.rs b/components/script/dom/bindings/interface.rs index cf4b7cc7924..838afc7b166 100644 --- a/components/script/dom/bindings/interface.rs +++ b/components/script/dom/bindings/interface.rs @@ -4,17 +4,109 @@ //! Machinery to initialise interface prototype objects and interface objects. +use dom::bindings::codegen::PrototypeList; +use dom::bindings::conversions::get_dom_class; use dom::bindings::utils::{ConstantSpec, NonNullJSNative, define_constants}; -use js::jsapi::{HandleObject, JSClass, JSContext, JSFunctionSpec}; -use js::jsapi::{JSObject, JSPropertySpec, JS_DefineProperty1, JS_DefineProperty2}; -use js::jsapi::{JS_GetFunctionObject, JS_InternString, JS_LinkConstructorAndPrototype}; -use js::jsapi::{JS_NewFunction, JS_NewObject, JS_NewObjectWithUniqueType}; -use js::jsapi::{MutableHandleObject, RootedObject, RootedString}; +use js::glue::UncheckedUnwrapObject; +use js::jsapi::{Class, ClassExtension, ClassSpec, HandleObject, HandleValue, JSClass}; +use js::jsapi::{JSContext, JSFunctionSpec, JSObject, JSPropertySpec, JSString}; +use js::jsapi::{JS_DefineProperty1, JS_DefineProperty2, JS_DefineProperty4}; +use js::jsapi::{JS_GetFunctionObject, JS_GetPrototype, JS_InternString}; +use js::jsapi::{JS_LinkConstructorAndPrototype, JS_NewFunction, JS_NewObject}; +use js::jsapi::{JS_NewObjectWithUniqueType, MutableHandleObject, MutableHandleValue}; +use js::jsapi::{ObjectOps, RootedObject, RootedString, Value}; use js::rust::{define_methods, define_properties}; use js::{JSFUN_CONSTRUCTOR, JSPROP_PERMANENT, JSPROP_READONLY}; use libc; use std::ptr; +/// A constructor class hook. +pub type ConstructorClassHook = + unsafe extern "C" fn(cx: *mut JSContext, argc: u32, vp: *mut Value) -> bool; + +/// A has_instance class hook. +pub type HasInstanceClassHook = + unsafe extern "C" fn(cx: *mut JSContext, + obj: HandleObject, + vp: MutableHandleValue, + bp: *mut bool) + -> bool; + +/// A fun_to_string class hook. +pub type FunToStringHook = + unsafe extern "C" fn(cx: *mut JSContext, + obj: HandleObject, + indent: u32) + -> *mut JSString; + +/// The class of a non-callback interface object. +#[derive(Copy, Clone)] +pub struct NonCallbackInterfaceObjectClass { + /// The SpiderMonkey Class structure. + pub class: Class, +} +unsafe impl Sync for NonCallbackInterfaceObjectClass {} + +impl NonCallbackInterfaceObjectClass { + /// Create a new `NonCallbackInterfaceObjectClass` structure. + pub const fn new( + constructor: ConstructorClassHook, + has_instance: HasInstanceClassHook, + fun_to_string: FunToStringHook) + -> NonCallbackInterfaceObjectClass { + NonCallbackInterfaceObjectClass { + class: Class { + name: b"Function\0" as *const _ as *const libc::c_char, + flags: 0, + addProperty: None, + delProperty: None, + getProperty: None, + setProperty: None, + enumerate: None, + resolve: None, + convert: None, + finalize: None, + call: Some(constructor), + hasInstance: Some(has_instance), + construct: Some(constructor), + trace: None, + spec: ClassSpec { + createConstructor: None, + createPrototype: None, + constructorFunctions: ptr::null(), + constructorProperties: ptr::null(), + prototypeFunctions: ptr::null(), + prototypeProperties: ptr::null(), + finishInit: None, + flags: 0, + }, + ext: ClassExtension { + outerObject: None, + innerObject: None, + isWrappedNative: false, + weakmapKeyDelegateOp: None, + objectMovedOp: None, + }, + ops: ObjectOps { + lookupProperty: None, + defineProperty: None, + hasProperty: None, + getProperty: None, + setProperty: None, + getOwnPropertyDescriptor: None, + deleteProperty: None, + watch: None, + unwatch: None, + getElements: None, + enumerate: None, + thisObject: None, + funToString: Some(fun_to_string), + } + }, + } + } +} + /// Create and define the interface object of a callback interface. pub unsafe fn create_callback_interface_object( cx: *mut JSContext, @@ -45,31 +137,26 @@ pub unsafe fn create_interface_prototype_object( pub unsafe fn create_noncallback_interface_object( cx: *mut JSContext, receiver: HandleObject, - constructor_native: NonNullJSNative, + proto: HandleObject, + class: &'static NonCallbackInterfaceObjectClass, static_methods: Option<&'static [JSFunctionSpec]>, static_properties: Option<&'static [JSPropertySpec]>, constants: &'static [ConstantSpec], interface_prototype_object: HandleObject, name: &'static [u8], length: u32) { - assert!(!interface_prototype_object.ptr.is_null()); - - let interface_object = - RootedObject::new(cx, create_constructor(cx, constructor_native, length, name)); - assert!(!interface_object.ptr.is_null()); - - if let Some(static_methods) = static_methods { - define_methods(cx, interface_object.handle(), static_methods).unwrap(); - } - - if let Some(static_properties) = static_properties { - define_properties(cx, interface_object.handle(), static_properties).unwrap(); - } - - define_constants(cx, interface_object.handle(), constants); - + let mut interface_object = RootedObject::new(cx, ptr::null_mut()); + create_object(cx, + proto, + &*(class as *const _ as *const JSClass), + static_methods, + static_properties, + constants, + interface_object.handle_mut()); assert!(JS_LinkConstructorAndPrototype(cx, interface_object.handle(), interface_prototype_object)); + define_name(cx, interface_object.handle(), name); + define_length(cx, interface_object.handle(), length); define_on_global_object(cx, receiver, name, interface_object.handle()); } @@ -99,6 +186,43 @@ pub unsafe fn create_named_constructors( } } +/// Return whether a value is an instance of a given prototype. +/// http://heycam.github.io/webidl/#es-interface-hasinstance +pub unsafe fn has_instance( + cx: *mut JSContext, + prototype: HandleObject, + value: HandleValue, + id: PrototypeList::ID, + index: usize) + -> Result<bool, ()> { + if !value.is_object() { + // Step 1. + return Ok(false); + } + let mut value = RootedObject::new(cx, value.to_object()); + + // Steps 2-3 only concern callback interface objects. + + if let Ok(dom_class) = get_dom_class(UncheckedUnwrapObject(value.ptr, /* stopAtOuter = */ 0)) { + if dom_class.interface_chain[index] == id { + // Step 4. + return Ok(true); + } + } + + while JS_GetPrototype(cx, value.handle(), value.handle_mut()) { + if value.ptr.is_null() { + // Step 5.2. + return Ok(false); + } else if value.ptr as *const _ == prototype.ptr { + // Step 5.3. + return Ok(true); + } + } + // JS_GetPrototype threw an exception. + Err(()) +} + unsafe fn create_constructor( cx: *mut JSContext, constructor_native: NonNullJSNative, @@ -152,6 +276,15 @@ unsafe fn define_name(cx: *mut JSContext, obj: HandleObject, name: &'static [u8] None, None)); } +unsafe fn define_length(cx: *mut JSContext, obj: HandleObject, length: u32) { + assert!(JS_DefineProperty4(cx, + obj, + b"length\0".as_ptr() as *const libc::c_char, + length, + JSPROP_READONLY, + None, None)); +} + unsafe fn define_on_global_object( cx: *mut JSContext, receiver: HandleObject, |