#![allow(non_camel_case_types,non_upper_case_globals,unused_imports,unused_variables,unused_assignments,unused_mut,clippy::approx_constant,clippy::enum_variant_names,clippy::let_unit_value,clippy::needless_return,clippy::too_many_arguments,clippy::unnecessary_cast,clippy::upper_case_acronyms)]
use crate::dom::bindings::import::base::*;
#[derive(JSTraceable, PartialEq)]
#[crown::unrooted_must_root_lint::allow_unrooted_interior]
pub struct Function {
pub parent: CallbackFunction,
}
impl Function {
pub unsafe fn new(aCx: SafeJSContext, aCallback: *mut JSObject) -> Rc<Function> {
let mut ret = Rc::new(Function {
parent: CallbackFunction::new()
});
match Rc::get_mut(&mut ret) {
Some(ref mut callback) => callback.parent.init(aCx, aCallback),
None => unreachable!(),
};
ret
}
pub fn Call_<T: DomObject>(&self, thisObj: &T, arguments: Vec<HandleValue>, aExceptionHandling: ExceptionHandling) -> Fallible<JSVal> {
let s = CallSetup::new(self, aExceptionHandling);
rooted!(in(*s.get_context()) let mut thisObjJS = ptr::null_mut::<JSObject>());
wrap_call_this_object(s.get_context(), thisObj, thisObjJS.handle_mut());
if thisObjJS.is_null() {
return Err(JSFailed);
}
unsafe { self.Call(s.get_context(), thisObjJS.handle(), arguments) }
}
pub fn Call__<>(&self, arguments: Vec<HandleValue>, aExceptionHandling: ExceptionHandling) -> Fallible<JSVal> {
let s = CallSetup::new(self, aExceptionHandling);
rooted!(in(*s.get_context()) let thisObjJS = ptr::null_mut::<JSObject>());
unsafe { self.Call(s.get_context(), thisObjJS.handle(), arguments) }
}
unsafe fn Call<>(&self, cx: SafeJSContext, aThisObj: HandleObject, arguments: Vec<HandleValue>) -> Fallible<JSVal> {
rooted!(in(*cx) let mut rval = UndefinedValue());
rooted_vec!(let mut argv);
argv.extend((0..arguments.len()).map(|_| Heap::default()));
let mut argc = arguments.len();
for idx in 0..arguments.len() {
rooted!(in(*cx) let mut argv_root = UndefinedValue());
(arguments[idx].get()).to_jsval(*cx, argv_root.handle_mut());
{
let arg = &mut argv[idx];
*arg = Heap::default();
arg.set(argv_root.get());
}
}
rooted!(in(*cx) let callable = ObjectValue(self.callback()));
rooted!(in(*cx) let rootedThis = aThisObj.get());
let ok = JS_CallFunctionValue(
*cx, rootedThis.handle(), callable.handle(),
&HandleValueArray {
length_: argc as ::libc::size_t,
elements_: argv.as_ptr() as *const JSVal
}, rval.handle_mut());
maybe_resume_unwind();
if !ok {
return Err(JSFailed);
}
let rvalDecl: HandleValue = rval.handle();
Ok(rvalDecl.get())
}
}
impl CallbackContainer for Function {
unsafe fn new(cx: SafeJSContext, callback: *mut JSObject) -> Rc<Function> {
Function::new(cx, callback)
}
fn callback_holder(&self) -> &CallbackObject {
self.parent.callback_holder()
}
}
impl ToJSValConvertible for Function {
unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
self.callback().to_jsval(cx, rval);
}
}