mirror of
https://github.com/servo/servo.git
synced 2025-06-14 19:34:29 +00:00
6b75078503
This should make it somewhat easier to experiment with alternative representations in the future. To reduce churn, this commit leaves the String field public, though. Also, this will allow us to use the default String type to represent the IDL USVString type, which explicitly forbids unpaired surrogates, ans as such is a better match to the Rust String type.
740 lines
27 KiB
Rust
740 lines
27 KiB
Rust
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
//! Various utilities to glue JavaScript and the DOM implementation together.
|
|
|
|
use dom::bindings::codegen::PrototypeList;
|
|
use dom::bindings::codegen::PrototypeList::MAX_PROTO_CHAIN_LENGTH;
|
|
use dom::bindings::conversions::native_from_handleobject;
|
|
use dom::bindings::conversions::private_from_proto_check;
|
|
use dom::bindings::conversions::{is_dom_class, jsstring_to_str, DOM_OBJECT_SLOT};
|
|
use dom::bindings::error::{throw_invalid_this, throw_type_error};
|
|
use dom::bindings::inheritance::TopTypeId;
|
|
use dom::bindings::js::Root;
|
|
use dom::bindings::trace::trace_object;
|
|
use dom::browsercontext;
|
|
use dom::window;
|
|
use js;
|
|
use js::glue::{CallJitGetterOp, CallJitMethodOp, CallJitSetterOp, IsWrapper};
|
|
use js::glue::{GetCrossCompartmentWrapper, WrapperNew};
|
|
use js::glue::{RUST_FUNCTION_VALUE_TO_JITINFO, RUST_JSID_IS_INT};
|
|
use js::glue::{RUST_JSID_TO_INT, UnwrapObject};
|
|
use js::jsapi::JSAutoCompartment;
|
|
use js::jsapi::JS_DeletePropertyById1;
|
|
use js::jsapi::JS_GetFunctionObject;
|
|
use js::jsapi::JS_IsExceptionPending;
|
|
use js::jsapi::JS_NewObjectWithUniqueType;
|
|
use js::jsapi::JS_ObjectToOuterObject;
|
|
use js::jsapi::{CallArgs, GetGlobalForObjectCrossCompartment, JSJitInfo};
|
|
use js::jsapi::{CompartmentOptions, OnNewGlobalHookOption};
|
|
use js::jsapi::{DOMCallbacks, JSWrapObjectCallbacks};
|
|
use js::jsapi::{HandleId, HandleObject, HandleValue, MutableHandleValue};
|
|
use js::jsapi::{Heap, MutableHandleObject, ObjectOpResult, RootedObject, RootedValue};
|
|
use js::jsapi::{JSClass, JSContext, JSObject, JSTracer};
|
|
use js::jsapi::{JSFunctionSpec, JSPropertySpec};
|
|
use js::jsapi::{JSTraceOp, JS_AlreadyHasOwnProperty, JS_NewFunction};
|
|
use js::jsapi::{JSVersion, JS_FireOnNewGlobalObject};
|
|
use js::jsapi::{JS_DefineProperty, JS_DefineProperty1, JS_ForwardGetPropertyTo};
|
|
use js::jsapi::{JS_GetClass, JS_LinkConstructorAndPrototype};
|
|
use js::jsapi::{JS_GetProperty, JS_HasProperty, JS_SetProperty};
|
|
use js::jsapi::{JS_GetPrototype, JS_HasPropertyById};
|
|
use js::jsapi::{JS_GetReservedSlot, JS_SetReservedSlot};
|
|
use js::jsapi::{JS_InitStandardClasses, JS_NewGlobalObject};
|
|
use js::jsval::{BooleanValue, DoubleValue, Int32Value, JSVal, NullValue};
|
|
use js::jsval::{PrivateValue, UInt32Value, UndefinedValue};
|
|
use js::rust::{GCMethods, ToString, define_methods, define_properties};
|
|
use js::{JSFUN_CONSTRUCTOR, JSPROP_ENUMERATE, JS_CALLEE};
|
|
use js::{JSPROP_PERMANENT, JSPROP_READONLY};
|
|
use libc::{self, c_uint};
|
|
use std::default::Default;
|
|
use std::ffi::CString;
|
|
use std::ptr;
|
|
use util::mem::HeapSizeOf;
|
|
|
|
/// Proxy handler for a WindowProxy.
|
|
#[allow(raw_pointer_derive)]
|
|
pub struct WindowProxyHandler(pub *const libc::c_void);
|
|
|
|
impl HeapSizeOf for WindowProxyHandler {
|
|
fn heap_size_of_children(&self) -> usize {
|
|
//FIXME(#6907) this is a pointer to memory allocated by `new` in NewProxyHandler in rust-mozjs.
|
|
0
|
|
}
|
|
}
|
|
|
|
#[allow(raw_pointer_derive)]
|
|
#[derive(JSTraceable, HeapSizeOf)]
|
|
/// Static data associated with a global object.
|
|
pub struct GlobalStaticData {
|
|
/// The WindowProxy proxy handler for this global.
|
|
pub windowproxy_handler: WindowProxyHandler,
|
|
}
|
|
|
|
impl GlobalStaticData {
|
|
/// Creates a new GlobalStaticData.
|
|
pub fn new() -> GlobalStaticData {
|
|
GlobalStaticData {
|
|
windowproxy_handler: browsercontext::new_window_proxy_handler(),
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: This is baked into the Ion JIT as 0 in codegen for LGetDOMProperty and
|
|
// LSetDOMProperty. Those constants need to be changed accordingly if this value
|
|
// changes.
|
|
const DOM_PROTO_INSTANCE_CLASS_SLOT: u32 = 0;
|
|
|
|
/// The index of the slot that contains a reference to the ProtoOrIfaceArray.
|
|
// All DOM globals must have a slot at DOM_PROTOTYPE_SLOT.
|
|
pub const DOM_PROTOTYPE_SLOT: u32 = js::JSCLASS_GLOBAL_SLOT_COUNT;
|
|
|
|
/// The flag set on the `JSClass`es for DOM global objects.
|
|
// NOTE: This is baked into the Ion JIT as 0 in codegen for LGetDOMProperty and
|
|
// LSetDOMProperty. Those constants need to be changed accordingly if this value
|
|
// changes.
|
|
pub const JSCLASS_DOM_GLOBAL: u32 = js::JSCLASS_USERBIT1;
|
|
|
|
/// Representation of an IDL constant value.
|
|
#[derive(Clone)]
|
|
pub enum ConstantVal {
|
|
/// `long` constant.
|
|
IntVal(i32),
|
|
/// `unsigned long` constant.
|
|
UintVal(u32),
|
|
/// `double` constant.
|
|
DoubleVal(f64),
|
|
/// `boolean` constant.
|
|
BoolVal(bool),
|
|
/// `null` constant.
|
|
NullVal,
|
|
}
|
|
|
|
/// Representation of an IDL constant.
|
|
#[derive(Clone)]
|
|
pub struct ConstantSpec {
|
|
/// name of the constant.
|
|
pub name: &'static [u8],
|
|
/// value of the constant.
|
|
pub value: ConstantVal
|
|
}
|
|
|
|
impl ConstantSpec {
|
|
/// Returns a `JSVal` that represents the value of this `ConstantSpec`.
|
|
pub fn get_value(&self) -> JSVal {
|
|
match self.value {
|
|
ConstantVal::NullVal => NullValue(),
|
|
ConstantVal::IntVal(i) => Int32Value(i),
|
|
ConstantVal::UintVal(u) => UInt32Value(u),
|
|
ConstantVal::DoubleVal(d) => DoubleValue(d),
|
|
ConstantVal::BoolVal(b) => BooleanValue(b),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Helper structure for cross-origin wrappers for DOM binding objects.
|
|
pub struct NativePropertyHooks {
|
|
/// The property arrays for this interface.
|
|
pub native_properties: &'static NativeProperties,
|
|
|
|
/// The NativePropertyHooks instance for the parent interface, if any.
|
|
pub proto_hooks: Option<&'static NativePropertyHooks>,
|
|
}
|
|
|
|
/// The struct that holds inheritance information for DOM object reflectors.
|
|
#[allow(raw_pointer_derive)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct DOMClass {
|
|
/// A list of interfaces that this object implements, in order of decreasing
|
|
/// derivedness.
|
|
pub interface_chain: [PrototypeList::ID; MAX_PROTO_CHAIN_LENGTH],
|
|
|
|
/// The type ID of that interface.
|
|
pub type_id: TopTypeId,
|
|
|
|
/// The NativePropertyHooks for the interface associated with this class.
|
|
pub native_hooks: &'static NativePropertyHooks,
|
|
|
|
/// The HeapSizeOf function wrapper for that interface.
|
|
pub heap_size_of: unsafe fn(*const libc::c_void) -> usize,
|
|
}
|
|
unsafe impl Sync for DOMClass {}
|
|
|
|
/// The JSClass used for DOM object reflectors.
|
|
#[derive(Copy)]
|
|
pub struct DOMJSClass {
|
|
/// The actual JSClass.
|
|
pub base: js::jsapi::Class,
|
|
/// Associated data for DOM object reflectors.
|
|
pub dom_class: DOMClass
|
|
}
|
|
impl Clone for DOMJSClass {
|
|
fn clone(&self) -> DOMJSClass { *self }
|
|
}
|
|
unsafe impl Sync for DOMJSClass {}
|
|
|
|
/// Returns the ProtoOrIfaceArray for the given global object.
|
|
/// Fails if `global` is not a DOM global object.
|
|
pub fn get_proto_or_iface_array(global: *mut JSObject) -> *mut ProtoOrIfaceArray {
|
|
unsafe {
|
|
assert!(((*JS_GetClass(global)).flags & JSCLASS_DOM_GLOBAL) != 0);
|
|
JS_GetReservedSlot(global, DOM_PROTOTYPE_SLOT).to_private() as *mut ProtoOrIfaceArray
|
|
}
|
|
}
|
|
|
|
/// Contains references to lists of methods, attributes, and constants for a
|
|
/// given interface.
|
|
pub struct NativeProperties {
|
|
/// Instance methods for the interface.
|
|
pub methods: Option<&'static [JSFunctionSpec]>,
|
|
/// Instance attributes for the interface.
|
|
pub attrs: Option<&'static [JSPropertySpec]>,
|
|
/// Constants for the interface.
|
|
pub consts: Option<&'static [ConstantSpec]>,
|
|
/// Static methods for the interface.
|
|
pub static_methods: Option<&'static [JSFunctionSpec]>,
|
|
/// Static attributes for the interface.
|
|
pub static_attrs: Option<&'static [JSPropertySpec]>,
|
|
}
|
|
unsafe impl Sync for NativeProperties {}
|
|
|
|
/// A JSNative that cannot be null.
|
|
pub type NonNullJSNative =
|
|
unsafe extern "C" fn (arg1: *mut JSContext, arg2: c_uint, arg3: *mut JSVal) -> bool;
|
|
|
|
/// Creates the *interface prototype object* (if a `proto_class` is given)
|
|
/// and the *interface object* (if a `constructor` is given).
|
|
/// Fails on JSAPI failure.
|
|
pub fn do_create_interface_objects(cx: *mut JSContext,
|
|
receiver: HandleObject,
|
|
proto_proto: HandleObject,
|
|
proto_class: Option<&'static JSClass>,
|
|
constructor: Option<(NonNullJSNative, &'static str, u32)>,
|
|
named_constructors: &[(NonNullJSNative, &'static str, u32)],
|
|
dom_class: Option<&'static DOMClass>,
|
|
members: &'static NativeProperties,
|
|
rval: MutableHandleObject) {
|
|
assert!(rval.get().is_null());
|
|
if let Some(proto_class) = proto_class {
|
|
create_interface_prototype_object(cx, proto_proto,
|
|
proto_class, members, rval);
|
|
|
|
if !rval.get().is_null() {
|
|
let dom_class_ptr = match dom_class {
|
|
Some(dom_class) => dom_class as *const DOMClass as *const libc::c_void,
|
|
None => ptr::null() as *const libc::c_void,
|
|
};
|
|
|
|
unsafe {
|
|
JS_SetReservedSlot(rval.get(), DOM_PROTO_INSTANCE_CLASS_SLOT,
|
|
PrivateValue(dom_class_ptr));
|
|
}
|
|
}
|
|
}
|
|
|
|
if let Some((native, name, nargs)) = constructor {
|
|
let s = CString::new(name).unwrap();
|
|
create_interface_object(cx, receiver,
|
|
native, nargs, rval.handle(),
|
|
members, s.as_ptr())
|
|
}
|
|
|
|
for ctor in named_constructors {
|
|
let (cnative, cname, cnargs) = *ctor;
|
|
|
|
let cs = CString::new(cname).unwrap();
|
|
let constructor = RootedObject::new(cx, create_constructor(cx, cnative, cnargs, cs.as_ptr()));
|
|
assert!(!constructor.ptr.is_null());
|
|
unsafe {
|
|
assert!(JS_DefineProperty1(cx, constructor.handle(), b"prototype\0".as_ptr() as *const libc::c_char,
|
|
rval.handle(),
|
|
JSPROP_PERMANENT | JSPROP_READONLY,
|
|
None, None));
|
|
}
|
|
define_constructor(cx, receiver, cs.as_ptr(), constructor.handle());
|
|
}
|
|
|
|
}
|
|
|
|
fn create_constructor(cx: *mut JSContext,
|
|
constructor_native: NonNullJSNative,
|
|
ctor_nargs: u32,
|
|
name: *const libc::c_char) -> *mut JSObject {
|
|
unsafe {
|
|
let fun = JS_NewFunction(cx, Some(constructor_native), ctor_nargs,
|
|
JSFUN_CONSTRUCTOR, name);
|
|
assert!(!fun.is_null());
|
|
|
|
let constructor = JS_GetFunctionObject(fun);
|
|
assert!(!constructor.is_null());
|
|
|
|
constructor
|
|
}
|
|
}
|
|
|
|
fn define_constructor(cx: *mut JSContext,
|
|
receiver: HandleObject,
|
|
name: *const libc::c_char,
|
|
constructor: HandleObject) {
|
|
unsafe {
|
|
let mut already_defined = false;
|
|
assert!(JS_AlreadyHasOwnProperty(cx, receiver, name, &mut already_defined));
|
|
|
|
if !already_defined {
|
|
assert!(JS_DefineProperty1(cx, receiver, name,
|
|
constructor,
|
|
0, None, None));
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/// Creates the *interface object*.
|
|
/// Fails on JSAPI failure.
|
|
fn create_interface_object(cx: *mut JSContext,
|
|
receiver: HandleObject,
|
|
constructor_native: NonNullJSNative,
|
|
ctor_nargs: u32, proto: HandleObject,
|
|
members: &'static NativeProperties,
|
|
name: *const libc::c_char) {
|
|
unsafe {
|
|
let constructor = RootedObject::new(cx, create_constructor(cx, constructor_native, ctor_nargs, name));
|
|
assert!(!constructor.ptr.is_null());
|
|
|
|
if let Some(static_methods) = members.static_methods {
|
|
define_methods(cx, constructor.handle(), static_methods).unwrap();
|
|
}
|
|
|
|
if let Some(static_properties) = members.static_attrs {
|
|
define_properties(cx, constructor.handle(), static_properties).unwrap();
|
|
}
|
|
|
|
if let Some(constants) = members.consts {
|
|
define_constants(cx, constructor.handle(), constants);
|
|
}
|
|
|
|
if !proto.get().is_null() {
|
|
assert!(JS_LinkConstructorAndPrototype(cx, constructor.handle(), proto));
|
|
}
|
|
|
|
define_constructor(cx, receiver, name, constructor.handle());
|
|
}
|
|
}
|
|
|
|
/// Defines constants on `obj`.
|
|
/// Fails on JSAPI failure.
|
|
fn define_constants(cx: *mut JSContext, obj: HandleObject,
|
|
constants: &'static [ConstantSpec]) {
|
|
for spec in constants {
|
|
let value = RootedValue::new(cx, spec.get_value());
|
|
unsafe {
|
|
assert!(JS_DefineProperty(cx, obj, spec.name.as_ptr() as *const libc::c_char,
|
|
value.handle(),
|
|
JSPROP_ENUMERATE | JSPROP_READONLY |
|
|
JSPROP_PERMANENT, None, None));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Creates the *interface prototype object*.
|
|
/// Fails on JSAPI failure.
|
|
fn create_interface_prototype_object(cx: *mut JSContext, global: HandleObject,
|
|
proto_class: &'static JSClass,
|
|
members: &'static NativeProperties,
|
|
rval: MutableHandleObject) {
|
|
unsafe {
|
|
rval.set(JS_NewObjectWithUniqueType(cx, proto_class, global));
|
|
assert!(!rval.get().is_null());
|
|
|
|
if let Some(methods) = members.methods {
|
|
define_methods(cx, rval.handle(), methods).unwrap();
|
|
}
|
|
|
|
if let Some(properties) = members.attrs {
|
|
define_properties(cx, rval.handle(), properties).unwrap();
|
|
}
|
|
|
|
if let Some(constants) = members.consts {
|
|
define_constants(cx, rval.handle(), constants);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A throwing constructor, for those interfaces that have neither
|
|
/// `NoInterfaceObject` nor `Constructor`.
|
|
pub unsafe extern fn throwing_constructor(cx: *mut JSContext, _argc: c_uint,
|
|
_vp: *mut JSVal) -> bool {
|
|
throw_type_error(cx, "Illegal constructor.");
|
|
false
|
|
}
|
|
|
|
/// An array of *mut JSObject of size PrototypeList::ID::Count
|
|
pub type ProtoOrIfaceArray = [*mut JSObject; PrototypeList::ID::Count as usize];
|
|
|
|
/// Construct and cache the ProtoOrIfaceArray for the given global.
|
|
/// Fails if the argument is not a DOM global.
|
|
pub fn initialize_global(global: *mut JSObject) {
|
|
let proto_array: Box<ProtoOrIfaceArray> =
|
|
box [0 as *mut JSObject; PrototypeList::ID::Count as usize];
|
|
unsafe {
|
|
assert!(((*JS_GetClass(global)).flags & JSCLASS_DOM_GLOBAL) != 0);
|
|
let box_ = Box::into_raw(proto_array);
|
|
JS_SetReservedSlot(global,
|
|
DOM_PROTOTYPE_SLOT,
|
|
PrivateValue(box_ as *const libc::c_void));
|
|
}
|
|
}
|
|
|
|
/// Gets the property `id` on `proxy`'s prototype. If it exists, `*found` is
|
|
/// set to true and `*vp` to the value, otherwise `*found` is set to false.
|
|
///
|
|
/// Returns false on JSAPI failure.
|
|
pub fn get_property_on_prototype(cx: *mut JSContext, proxy: HandleObject,
|
|
id: HandleId, found: *mut bool, vp: MutableHandleValue)
|
|
-> bool {
|
|
unsafe {
|
|
//let proto = GetObjectProto(proxy);
|
|
let mut proto = RootedObject::new(cx, ptr::null_mut());
|
|
if !JS_GetPrototype(cx, proxy, proto.handle_mut()) ||
|
|
proto.ptr.is_null() {
|
|
*found = false;
|
|
return true;
|
|
}
|
|
let mut has_property = false;
|
|
if !JS_HasPropertyById(cx, proto.handle(), id, &mut has_property) {
|
|
return false;
|
|
}
|
|
*found = has_property;
|
|
let no_output = vp.ptr.is_null();
|
|
if !has_property || no_output {
|
|
return true;
|
|
}
|
|
|
|
JS_ForwardGetPropertyTo(cx, proto.handle(), id, proxy, vp)
|
|
}
|
|
}
|
|
|
|
/// Get an array index from the given `jsid`. Returns `None` if the given
|
|
/// `jsid` is not an integer.
|
|
pub fn get_array_index_from_id(_cx: *mut JSContext, id: HandleId) -> Option<u32> {
|
|
unsafe {
|
|
if RUST_JSID_IS_INT(id) {
|
|
return Some(RUST_JSID_TO_INT(id) as u32);
|
|
}
|
|
None
|
|
}
|
|
// if id is length atom, -1, otherwise
|
|
/*return if JSID_IS_ATOM(id) {
|
|
let atom = JSID_TO_ATOM(id);
|
|
//let s = *GetAtomChars(id);
|
|
if s > 'a' && s < 'z' {
|
|
return -1;
|
|
}
|
|
|
|
let i = 0;
|
|
let str = AtomToLinearString(JSID_TO_ATOM(id));
|
|
return if StringIsArray(str, &mut i) != 0 { i } else { -1 }
|
|
} else {
|
|
IdToInt32(cx, id);
|
|
}*/
|
|
}
|
|
|
|
/// Find the index of a string given by `v` in `values`.
|
|
/// Returns `Err(())` on JSAPI failure (there is a pending exception), and
|
|
/// `Ok(None)` if there was no matching string.
|
|
pub fn find_enum_string_index(cx: *mut JSContext,
|
|
v: HandleValue,
|
|
values: &[&'static str])
|
|
-> Result<Option<usize>, ()> {
|
|
let jsstr = unsafe { ToString(cx, v) };
|
|
if jsstr.is_null() {
|
|
return Err(());
|
|
}
|
|
|
|
let search = jsstring_to_str(cx, jsstr);
|
|
Ok(values.iter().position(|value| search == *value))
|
|
}
|
|
|
|
/// Returns wether `obj` is a platform object
|
|
/// https://heycam.github.io/webidl/#dfn-platform-object
|
|
pub fn is_platform_object(obj: *mut JSObject) -> bool {
|
|
unsafe {
|
|
// Fast-path the common case
|
|
let mut clasp = JS_GetClass(obj);
|
|
if is_dom_class(&*clasp) {
|
|
return true;
|
|
}
|
|
// Now for simplicity check for security wrappers before anything else
|
|
if IsWrapper(obj) {
|
|
let unwrapped_obj = UnwrapObject(obj, /* stopAtOuter = */ 0);
|
|
if unwrapped_obj.is_null() {
|
|
return false;
|
|
}
|
|
clasp = js::jsapi::JS_GetClass(obj);
|
|
}
|
|
// TODO also check if JS_IsArrayBufferObject
|
|
is_dom_class(&*clasp)
|
|
}
|
|
}
|
|
|
|
/// Get the property with name `property` from `object`.
|
|
/// Returns `Err(())` on JSAPI failure (there is a pending exception), and
|
|
/// `Ok(false)` if there was no property with the given name.
|
|
pub fn get_dictionary_property(cx: *mut JSContext,
|
|
object: HandleObject,
|
|
property: &str,
|
|
rval: MutableHandleValue)
|
|
-> Result<bool, ()> {
|
|
fn has_property(cx: *mut JSContext, object: HandleObject, property: &CString,
|
|
found: &mut bool) -> bool {
|
|
unsafe {
|
|
JS_HasProperty(cx, object, property.as_ptr(), found)
|
|
}
|
|
}
|
|
fn get_property(cx: *mut JSContext, object: HandleObject, property: &CString,
|
|
value: MutableHandleValue) -> bool {
|
|
unsafe {
|
|
JS_GetProperty(cx, object, property.as_ptr(), value)
|
|
}
|
|
}
|
|
|
|
let property = CString::new(property).unwrap();
|
|
if object.get().is_null() {
|
|
return Ok(false);
|
|
}
|
|
|
|
let mut found = false;
|
|
if !has_property(cx, object, &property, &mut found) {
|
|
return Err(());
|
|
}
|
|
|
|
if !found {
|
|
return Ok(false);
|
|
}
|
|
|
|
if !get_property(cx, object, &property, rval) {
|
|
return Err(());
|
|
}
|
|
|
|
Ok(true)
|
|
}
|
|
|
|
/// Set the property with name `property` from `object`.
|
|
/// Returns `Err(())` on JSAPI failure, or null object,
|
|
/// and Ok(()) otherwise
|
|
pub fn set_dictionary_property(cx: *mut JSContext,
|
|
object: HandleObject,
|
|
property: &str,
|
|
value: HandleValue) -> Result<(), ()> {
|
|
if object.get().is_null() {
|
|
return Err(());
|
|
}
|
|
|
|
let property = CString::new(property).unwrap();
|
|
unsafe {
|
|
if !JS_SetProperty(cx, object, property.as_ptr(), value) {
|
|
return Err(());
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Returns whether `proxy` has a property `id` on its prototype.
|
|
pub fn has_property_on_prototype(cx: *mut JSContext, proxy: HandleObject,
|
|
id: HandleId) -> bool {
|
|
// MOZ_ASSERT(js::IsProxy(proxy) && js::GetProxyHandler(proxy) == handler);
|
|
let mut found = false;
|
|
!get_property_on_prototype(cx, proxy, id, &mut found,
|
|
unsafe { MutableHandleValue::from_marked_location(ptr::null_mut()) }) || found
|
|
}
|
|
|
|
/// Create a DOM global object with the given class.
|
|
pub fn create_dom_global(cx: *mut JSContext, class: *const JSClass,
|
|
private: *const libc::c_void,
|
|
trace: JSTraceOp)
|
|
-> *mut JSObject {
|
|
unsafe {
|
|
let mut options = CompartmentOptions::default();
|
|
options.version_ = JSVersion::JSVERSION_ECMA_5;
|
|
options.traceGlobal_ = trace;
|
|
|
|
let obj =
|
|
RootedObject::new(cx,
|
|
JS_NewGlobalObject(cx, class, ptr::null_mut(),
|
|
OnNewGlobalHookOption::DontFireOnNewGlobalHook, &options));
|
|
if obj.ptr.is_null() {
|
|
return ptr::null_mut();
|
|
}
|
|
let _ac = JSAutoCompartment::new(cx, obj.ptr);
|
|
JS_SetReservedSlot(obj.ptr, DOM_OBJECT_SLOT, PrivateValue(private));
|
|
JS_InitStandardClasses(cx, obj.handle());
|
|
initialize_global(obj.ptr);
|
|
JS_FireOnNewGlobalObject(cx, obj.handle());
|
|
obj.ptr
|
|
}
|
|
}
|
|
|
|
/// Drop the resources held by reserved slots of a global object
|
|
pub unsafe fn finalize_global(obj: *mut JSObject) {
|
|
let protolist = get_proto_or_iface_array(obj);
|
|
let list = (*protolist).as_mut_ptr();
|
|
for idx in 0..(PrototypeList::ID::Count as isize) {
|
|
let entry = list.offset(idx);
|
|
let value = *entry;
|
|
if <*mut JSObject>::needs_post_barrier(value) {
|
|
<*mut JSObject>::relocate(entry);
|
|
}
|
|
}
|
|
let _: Box<ProtoOrIfaceArray> =
|
|
Box::from_raw(protolist);
|
|
}
|
|
|
|
/// Trace the resources held by reserved slots of a global object
|
|
pub unsafe fn trace_global(tracer: *mut JSTracer, obj: *mut JSObject) {
|
|
let array = get_proto_or_iface_array(obj);
|
|
for proto in (*array).iter() {
|
|
if !proto.is_null() {
|
|
trace_object(tracer, "prototype", &*(proto as *const *mut JSObject as *const Heap<*mut JSObject>));
|
|
}
|
|
}
|
|
}
|
|
|
|
unsafe extern fn wrap(cx: *mut JSContext,
|
|
_existing: HandleObject,
|
|
obj: HandleObject)
|
|
-> *mut JSObject {
|
|
// FIXME terrible idea. need security wrappers
|
|
// https://github.com/servo/servo/issues/2382
|
|
WrapperNew(cx, obj, GetCrossCompartmentWrapper(), ptr::null(), false)
|
|
}
|
|
|
|
unsafe extern fn pre_wrap(cx: *mut JSContext, _existing: HandleObject,
|
|
obj: HandleObject, _object_passed_to_wrap: HandleObject)
|
|
-> *mut JSObject {
|
|
let _ac = JSAutoCompartment::new(cx, obj.get());
|
|
JS_ObjectToOuterObject(cx, obj)
|
|
}
|
|
|
|
/// Callback table for use with JS_SetWrapObjectCallbacks
|
|
pub static WRAP_CALLBACKS: JSWrapObjectCallbacks = JSWrapObjectCallbacks {
|
|
wrap: Some(wrap),
|
|
preWrap: Some(pre_wrap),
|
|
};
|
|
|
|
/// Callback to outerize windows.
|
|
pub unsafe extern fn outerize_global(_cx: *mut JSContext, obj: HandleObject) -> *mut JSObject {
|
|
debug!("outerizing");
|
|
let win: Root<window::Window> = native_from_handleobject(obj).unwrap();
|
|
// FIXME(https://github.com/rust-lang/rust/issues/23338)
|
|
let win = win.r();
|
|
let context = win.browsing_context();
|
|
context.as_ref().unwrap().window_proxy()
|
|
}
|
|
|
|
/// Deletes the property `id` from `object`.
|
|
pub unsafe fn delete_property_by_id(cx: *mut JSContext, object: HandleObject,
|
|
id: HandleId, bp: *mut ObjectOpResult) -> bool {
|
|
JS_DeletePropertyById1(cx, object, id, bp)
|
|
}
|
|
|
|
unsafe fn generic_call(cx: *mut JSContext, argc: libc::c_uint, vp: *mut JSVal,
|
|
is_lenient: bool,
|
|
call: unsafe extern fn(*const JSJitInfo, *mut JSContext,
|
|
HandleObject, *mut libc::c_void, u32,
|
|
*mut JSVal)
|
|
-> bool)
|
|
-> bool {
|
|
let args = CallArgs::from_vp(vp, argc);
|
|
let thisobj = args.thisv();
|
|
if !thisobj.get().is_null_or_undefined() && !thisobj.get().is_object() {
|
|
return false;
|
|
}
|
|
let obj = if thisobj.get().is_object() {
|
|
thisobj.get().to_object()
|
|
} else {
|
|
GetGlobalForObjectCrossCompartment(JS_CALLEE(cx, vp).to_object_or_null())
|
|
};
|
|
let obj = RootedObject::new(cx, obj);
|
|
let info = RUST_FUNCTION_VALUE_TO_JITINFO(JS_CALLEE(cx, vp));
|
|
let proto_id = (*info).protoID;
|
|
let depth = (*info).depth;
|
|
let proto_check = |class: &'static DOMClass| {
|
|
class.interface_chain[depth as usize] as u16 == proto_id
|
|
};
|
|
let this = match private_from_proto_check(obj.ptr, proto_check) {
|
|
Ok(val) => val,
|
|
Err(()) => {
|
|
if is_lenient {
|
|
debug_assert!(!JS_IsExceptionPending(cx));
|
|
*vp = UndefinedValue();
|
|
return true;
|
|
} else {
|
|
throw_invalid_this(cx, proto_id);
|
|
return false;
|
|
}
|
|
}
|
|
};
|
|
call(info, cx, obj.handle(), this as *mut libc::c_void, argc, vp)
|
|
}
|
|
|
|
/// Generic method of IDL interface.
|
|
pub unsafe extern fn generic_method(cx: *mut JSContext,
|
|
argc: libc::c_uint, vp: *mut JSVal)
|
|
-> bool {
|
|
generic_call(cx, argc, vp, false, CallJitMethodOp)
|
|
}
|
|
|
|
/// Generic getter of IDL interface.
|
|
pub unsafe extern fn generic_getter(cx: *mut JSContext,
|
|
argc: libc::c_uint, vp: *mut JSVal)
|
|
-> bool {
|
|
generic_call(cx, argc, vp, false, CallJitGetterOp)
|
|
}
|
|
|
|
/// Generic lenient getter of IDL interface.
|
|
pub unsafe extern fn generic_lenient_getter(cx: *mut JSContext,
|
|
argc: libc::c_uint,
|
|
vp: *mut JSVal)
|
|
-> bool {
|
|
generic_call(cx, argc, vp, true, CallJitGetterOp)
|
|
}
|
|
|
|
unsafe extern fn call_setter(info: *const JSJitInfo, cx: *mut JSContext,
|
|
handle: HandleObject, this: *mut libc::c_void,
|
|
argc: u32, vp: *mut JSVal)
|
|
-> bool {
|
|
if !CallJitSetterOp(info, cx, handle, this, argc, vp) {
|
|
return false;
|
|
}
|
|
*vp = UndefinedValue();
|
|
true
|
|
}
|
|
|
|
/// Generic setter of IDL interface.
|
|
pub unsafe extern fn generic_setter(cx: *mut JSContext,
|
|
argc: libc::c_uint, vp: *mut JSVal)
|
|
-> bool {
|
|
generic_call(cx, argc, vp, false, call_setter)
|
|
}
|
|
|
|
/// Generic lenient setter of IDL interface.
|
|
pub unsafe extern fn generic_lenient_setter(cx: *mut JSContext,
|
|
argc: libc::c_uint,
|
|
vp: *mut JSVal)
|
|
-> bool {
|
|
generic_call(cx, argc, vp, true, call_setter)
|
|
}
|
|
|
|
unsafe extern "C" fn instance_class_has_proto_at_depth(clasp: *const js::jsapi::Class,
|
|
proto_id: u32,
|
|
depth: u32) -> bool {
|
|
let domclass: *const DOMJSClass = clasp as *const _;
|
|
let domclass = &*domclass;
|
|
domclass.dom_class.interface_chain[depth as usize] as u32 == proto_id
|
|
}
|
|
|
|
#[allow(missing_docs)] // FIXME
|
|
pub const DOM_CALLBACKS: DOMCallbacks = DOMCallbacks {
|
|
instanceClassMatchesProto: Some(instance_class_has_proto_at_depth),
|
|
};
|