mirror of
https://github.com/servo/servo.git
synced 2025-08-07 14:35:33 +01:00
Upgrade to SM 39
This commit is contained in:
Michael Wu
parent
a256f39796
commit
675267b782
205 changed files with 6546 additions and 5340 deletions
|
|
@ -24,17 +24,17 @@
|
|||
//! | USVString | `USVString` |
|
||||
//! | ByteString | `ByteString` |
|
||||
//! | object | `*mut JSObject` |
|
||||
//! | interface types | `JSRef<T>` | `Temporary<T>` |
|
||||
//! | interface types | `&T` | `Root<T>` |
|
||||
//! | dictionary types | `&T` | *unsupported* |
|
||||
//! | enumeration types | `T` |
|
||||
//! | callback function types | `T` |
|
||||
//! | callback function types | `Rc<T>` |
|
||||
//! | nullable types | `Option<T>` |
|
||||
//! | sequences | `Vec<T>` |
|
||||
//! | union types | `T` |
|
||||
|
||||
use dom::bindings::codegen::PrototypeList;
|
||||
use dom::bindings::error::throw_type_error;
|
||||
use dom::bindings::js::{JSRef, Root, Unrooted};
|
||||
use dom::bindings::js::Root;
|
||||
use dom::bindings::num::Finite;
|
||||
use dom::bindings::str::{ByteString, USVString};
|
||||
use dom::bindings::utils::{Reflectable, Reflector, DOMClass};
|
||||
|
|
@ -43,14 +43,15 @@ use util::str::DOMString;
|
|||
use js;
|
||||
use js::glue::{RUST_JSID_TO_STRING, RUST_JSID_IS_STRING};
|
||||
use js::glue::RUST_JS_NumberValue;
|
||||
use js::jsapi::{JSBool, JSContext, JSObject, JSString, jsid};
|
||||
use js::jsapi::{JS_ValueToUint64, JS_ValueToInt64};
|
||||
use js::jsapi::{JS_ValueToECMAUint32, JS_ValueToECMAInt32};
|
||||
use js::jsapi::{JS_ValueToUint16, JS_ValueToNumber, JS_ValueToBoolean};
|
||||
use js::jsapi::{JS_ValueToString, JS_GetStringCharsAndLength};
|
||||
use js::rust::{ToUint64, ToInt64};
|
||||
use js::rust::{ToUint32, ToInt32};
|
||||
use js::rust::{ToUint16, ToNumber, ToBoolean, ToString};
|
||||
use js::jsapi::{JSContext, JSObject, JSString};
|
||||
use js::jsapi::{JS_StringHasLatin1Chars, JS_GetLatin1StringCharsAndLength, JS_GetTwoByteStringCharsAndLength};
|
||||
use js::jsapi::{JS_NewUCStringCopyN, JS_NewStringCopyN};
|
||||
use js::jsapi::{JS_WrapValue};
|
||||
use js::jsapi::{JSClass, JS_GetClass};
|
||||
use js::jsapi::{HandleId, HandleValue, HandleObject, MutableHandleValue};
|
||||
use js::jsval::JSVal;
|
||||
use js::jsval::{UndefinedValue, NullValue, BooleanValue, Int32Value, UInt32Value};
|
||||
use js::jsval::{StringValue, ObjectValue, ObjectOrNullValue};
|
||||
|
|
@ -60,6 +61,9 @@ use num::Float;
|
|||
use std::borrow::ToOwned;
|
||||
use std::default;
|
||||
use std::slice;
|
||||
use std::ptr;
|
||||
use std::rc::Rc;
|
||||
use core::nonzero::NonZero;
|
||||
|
||||
/// A trait to retrieve the constants necessary to check if a `JSObject`
|
||||
/// implements a given interface.
|
||||
|
|
@ -74,7 +78,7 @@ pub trait IDLInterface {
|
|||
/// A trait to convert Rust types to `JSVal`s.
|
||||
pub trait ToJSValConvertible {
|
||||
/// Convert `self` to a `JSVal`. JSAPI failure causes a task failure.
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal;
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue);
|
||||
}
|
||||
|
||||
/// A trait to convert `JSVal`s to Rust types.
|
||||
|
|
@ -85,206 +89,201 @@ pub trait FromJSValConvertible {
|
|||
/// Optional configuration of type `T` can be passed as the `option`
|
||||
/// argument.
|
||||
/// If it returns `Err(())`, a JSAPI exception is pending.
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, option: Self::Config) -> Result<Self, ()>;
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, option: Self::Config) -> Result<Self, ()>;
|
||||
}
|
||||
|
||||
|
||||
impl ToJSValConvertible for () {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
UndefinedValue()
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(UndefinedValue());
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for JSVal {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
let mut value = *self;
|
||||
if unsafe { JS_WrapValue(cx, &mut value) } == 0 {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(*self);
|
||||
if unsafe { JS_WrapValue(cx, rval) } == 0 {
|
||||
panic!("JS_WrapValue failed.");
|
||||
}
|
||||
value
|
||||
}
|
||||
}
|
||||
|
||||
unsafe fn convert_from_jsval<T: default::Default>(
|
||||
cx: *mut JSContext, value: JSVal,
|
||||
convert_fn: unsafe extern "C" fn(*mut JSContext, JSVal, *mut T) -> JSBool) -> Result<T, ()> {
|
||||
let mut ret = default::Default::default();
|
||||
if convert_fn(cx, value, &mut ret) == 0 {
|
||||
Err(())
|
||||
} else {
|
||||
Ok(ret)
|
||||
impl ToJSValConvertible for HandleValue {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(self.get());
|
||||
if unsafe { JS_WrapValue(cx, rval) } == 0 {
|
||||
panic!("JS_WrapValue failed.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl ToJSValConvertible for bool {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
BooleanValue(*self)
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(BooleanValue(*self));
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for bool {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<bool, ()> {
|
||||
let result = unsafe { convert_from_jsval(cx, val, JS_ValueToBoolean) };
|
||||
result.map(|b| b != 0)
|
||||
fn from_jsval(_cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<bool, ()> {
|
||||
Ok(ToBoolean(val))
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for i8 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
Int32Value(*self as i32)
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(Int32Value(*self as i32));
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for i8 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<i8, ()> {
|
||||
let result = unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) };
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<i8, ()> {
|
||||
let result = ToInt32(cx, val);
|
||||
result.map(|v| v as i8)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for u8 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
Int32Value(*self as i32)
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(Int32Value(*self as i32));
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for u8 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<u8, ()> {
|
||||
let result = unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) };
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<u8, ()> {
|
||||
let result = ToInt32(cx, val);
|
||||
result.map(|v| v as u8)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for i16 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
Int32Value(*self as i32)
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(Int32Value(*self as i32));
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for i16 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<i16, ()> {
|
||||
let result = unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) };
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<i16, ()> {
|
||||
let result = ToInt32(cx, val);
|
||||
result.map(|v| v as i16)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for u16 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
Int32Value(*self as i32)
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(Int32Value(*self as i32));
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for u16 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<u16, ()> {
|
||||
unsafe { convert_from_jsval(cx, val, JS_ValueToUint16) }
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<u16, ()> {
|
||||
ToUint16(cx, val)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for i32 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
Int32Value(*self)
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(Int32Value(*self));
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for i32 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<i32, ()> {
|
||||
unsafe { convert_from_jsval(cx, val, JS_ValueToECMAInt32) }
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<i32, ()> {
|
||||
ToInt32(cx, val)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for u32 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
UInt32Value(*self)
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(UInt32Value(*self));
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for u32 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<u32, ()> {
|
||||
unsafe { convert_from_jsval(cx, val, JS_ValueToECMAUint32) }
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<u32, ()> {
|
||||
ToUint32(cx, val)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for i64 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
unsafe {
|
||||
RUST_JS_NumberValue(*self as f64)
|
||||
rval.set(RUST_JS_NumberValue(*self as f64));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for i64 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<i64, ()> {
|
||||
unsafe { convert_from_jsval(cx, val, JS_ValueToInt64) }
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<i64, ()> {
|
||||
ToInt64(cx, val)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for u64 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
unsafe {
|
||||
RUST_JS_NumberValue(*self as f64)
|
||||
rval.set(RUST_JS_NumberValue(*self as f64));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for u64 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<u64, ()> {
|
||||
unsafe { convert_from_jsval(cx, val, JS_ValueToUint64) }
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<u64, ()> {
|
||||
ToUint64(cx, val)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for f32 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
unsafe {
|
||||
RUST_JS_NumberValue(*self as f64)
|
||||
rval.set(RUST_JS_NumberValue(*self as f64));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for f32 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<f32, ()> {
|
||||
let result = unsafe { convert_from_jsval(cx, val, JS_ValueToNumber) };
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<f32, ()> {
|
||||
let result = ToNumber(cx, val);
|
||||
result.map(|f| f as f32)
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for f64 {
|
||||
fn to_jsval(&self, _cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, _cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
unsafe {
|
||||
RUST_JS_NumberValue(*self)
|
||||
rval.set(RUST_JS_NumberValue(*self));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for f64 {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, val: JSVal, _option: ()) -> Result<f64, ()> {
|
||||
unsafe { convert_from_jsval(cx, val, JS_ValueToNumber) }
|
||||
fn from_jsval(cx: *mut JSContext, val: HandleValue, _option: ()) -> Result<f64, ()> {
|
||||
ToNumber(cx, val)
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Float + ToJSValConvertible> ToJSValConvertible for Finite<T> {
|
||||
#[inline]
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
let value = **self;
|
||||
value.to_jsval(cx)
|
||||
value.to_jsval(cx, rval);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: Float + FromJSValConvertible<Config=()>> FromJSValConvertible for Finite<T> {
|
||||
type Config = ();
|
||||
|
||||
fn from_jsval(cx: *mut JSContext, value: JSVal, option: ()) -> Result<Finite<T>, ()> {
|
||||
fn from_jsval(cx: *mut JSContext, value: HandleValue, option: ()) -> Result<Finite<T>, ()> {
|
||||
let result = try!(FromJSValConvertible::from_jsval(cx, value, option));
|
||||
match Finite::new(result) {
|
||||
Some(v) => Ok(v),
|
||||
|
|
@ -297,21 +296,22 @@ impl<T: Float + FromJSValConvertible<Config=()>> FromJSValConvertible for Finite
|
|||
}
|
||||
|
||||
impl ToJSValConvertible for str {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
unsafe {
|
||||
let string_utf16: Vec<u16> = self.utf16_units().collect();
|
||||
let jsstr = JS_NewUCStringCopyN(cx, string_utf16.as_ptr(), string_utf16.len() as libc::size_t);
|
||||
let jsstr = JS_NewUCStringCopyN(cx, string_utf16.as_ptr() as *const i16,
|
||||
string_utf16.len() as libc::size_t);
|
||||
if jsstr.is_null() {
|
||||
panic!("JS_NewUCStringCopyN failed");
|
||||
}
|
||||
StringValue(&*jsstr)
|
||||
rval.set(StringValue(&*jsstr));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for DOMString {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
(**self).to_jsval(cx)
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
(**self).to_jsval(cx, rval);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -333,18 +333,36 @@ impl default::Default for StringificationBehavior {
|
|||
/// Convert the given `JSString` to a `DOMString`. Fails if the string does not
|
||||
/// contain valid UTF-16.
|
||||
pub fn jsstring_to_str(cx: *mut JSContext, s: *mut JSString) -> DOMString {
|
||||
unsafe {
|
||||
let mut length = 0;
|
||||
let chars = JS_GetStringCharsAndLength(cx, s, &mut length);
|
||||
let mut length = 0;
|
||||
let latin1 = unsafe { JS_StringHasLatin1Chars(s) != 0 };
|
||||
if latin1 {
|
||||
let chars = unsafe {
|
||||
JS_GetLatin1StringCharsAndLength(cx, ptr::null(), s, &mut length)
|
||||
};
|
||||
assert!(!chars.is_null());
|
||||
let char_vec = slice::from_raw_parts(chars, length as usize);
|
||||
|
||||
let mut buf = String::with_capacity(length as usize);
|
||||
for i in 0..(length as isize) {
|
||||
unsafe {
|
||||
buf.push(*chars.offset(i) as char);
|
||||
}
|
||||
}
|
||||
buf
|
||||
} else {
|
||||
let chars = unsafe {
|
||||
JS_GetTwoByteStringCharsAndLength(cx, ptr::null(), s, &mut length)
|
||||
};
|
||||
assert!(!chars.is_null());
|
||||
let char_vec = unsafe {
|
||||
slice::from_raw_parts(chars as *const u16, length as usize)
|
||||
};
|
||||
String::from_utf16(char_vec).unwrap()
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert the given `jsid` to a `DOMString`. Fails if the `jsid` is not a
|
||||
/// string, or if the string does not contain valid UTF-16.
|
||||
pub fn jsid_to_str(cx: *mut JSContext, id: jsid) -> DOMString {
|
||||
pub fn jsid_to_str(cx: *mut JSContext, id: HandleId) -> DOMString {
|
||||
unsafe {
|
||||
assert!(RUST_JSID_IS_STRING(id) != 0);
|
||||
jsstring_to_str(cx, RUST_JSID_TO_STRING(id))
|
||||
|
|
@ -353,15 +371,16 @@ pub fn jsid_to_str(cx: *mut JSContext, id: jsid) -> DOMString {
|
|||
|
||||
impl FromJSValConvertible for DOMString {
|
||||
type Config = StringificationBehavior;
|
||||
fn from_jsval(cx: *mut JSContext, value: JSVal,
|
||||
fn from_jsval(cx: *mut JSContext, value: HandleValue,
|
||||
null_behavior: StringificationBehavior)
|
||||
-> Result<DOMString, ()> {
|
||||
if null_behavior == StringificationBehavior::Empty && value.is_null() {
|
||||
if null_behavior == StringificationBehavior::Empty &&
|
||||
value.get().is_null() {
|
||||
Ok("".to_owned())
|
||||
} else {
|
||||
let jsstr = unsafe { JS_ValueToString(cx, value) };
|
||||
let jsstr = ToString(cx, value);
|
||||
if jsstr.is_null() {
|
||||
debug!("JS_ValueToString failed");
|
||||
debug!("ToString failed");
|
||||
Err(())
|
||||
} else {
|
||||
Ok(jsstring_to_str(cx, jsstr))
|
||||
|
|
@ -371,56 +390,75 @@ impl FromJSValConvertible for DOMString {
|
|||
}
|
||||
|
||||
impl ToJSValConvertible for USVString {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
self.0.to_jsval(cx)
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
self.0.to_jsval(cx, rval);
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for USVString {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, value: JSVal, _: ())
|
||||
fn from_jsval(cx: *mut JSContext, value: HandleValue, _: ())
|
||||
-> Result<USVString, ()> {
|
||||
let jsstr = unsafe { JS_ValueToString(cx, value) };
|
||||
let jsstr = ToString(cx, value);
|
||||
if jsstr.is_null() {
|
||||
debug!("JS_ValueToString failed");
|
||||
Err(())
|
||||
} else {
|
||||
unsafe {
|
||||
let mut length = 0;
|
||||
let chars = JS_GetStringCharsAndLength(cx, jsstr, &mut length);
|
||||
assert!(!chars.is_null());
|
||||
let char_vec = slice::from_raw_parts(chars, length as usize);
|
||||
Ok(USVString(String::from_utf16_lossy(char_vec)))
|
||||
}
|
||||
debug!("ToString failed");
|
||||
return Err(());
|
||||
}
|
||||
let latin1 = unsafe { JS_StringHasLatin1Chars(jsstr) != 0 };
|
||||
if latin1 {
|
||||
return Ok(USVString(jsstring_to_str(cx, jsstr)));
|
||||
}
|
||||
unsafe {
|
||||
let mut length = 0;
|
||||
let chars = JS_GetTwoByteStringCharsAndLength(cx, ptr::null(), jsstr, &mut length);
|
||||
assert!(!chars.is_null());
|
||||
let char_vec = slice::from_raw_parts(chars as *const u16, length as usize);
|
||||
Ok(USVString(String::from_utf16_lossy(char_vec)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ToJSValConvertible for ByteString {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
unsafe {
|
||||
let jsstr = JS_NewStringCopyN(cx, self.as_ptr() as *const libc::c_char,
|
||||
self.len() as libc::size_t);
|
||||
if jsstr.is_null() {
|
||||
panic!("JS_NewStringCopyN failed");
|
||||
}
|
||||
StringValue(&*jsstr)
|
||||
rval.set(StringValue(&*jsstr));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FromJSValConvertible for ByteString {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, value: JSVal, _option: ()) -> Result<ByteString, ()> {
|
||||
unsafe {
|
||||
let string = JS_ValueToString(cx, value);
|
||||
if string.is_null() {
|
||||
debug!("JS_ValueToString failed");
|
||||
return Err(());
|
||||
}
|
||||
fn from_jsval(cx: *mut JSContext, value: HandleValue, _option: ()) -> Result<ByteString, ()> {
|
||||
let string = ToString(cx, value);
|
||||
if string.is_null() {
|
||||
debug!("ToString failed");
|
||||
return Err(());
|
||||
}
|
||||
|
||||
let latin1 = unsafe { JS_StringHasLatin1Chars(string) != 0 };
|
||||
if latin1 {
|
||||
let mut length = 0;
|
||||
let chars = JS_GetStringCharsAndLength(cx, string, &mut length);
|
||||
let chars = unsafe {
|
||||
JS_GetLatin1StringCharsAndLength(cx, ptr::null(),
|
||||
string, &mut length)
|
||||
};
|
||||
assert!(!chars.is_null());
|
||||
|
||||
let char_vec = unsafe {
|
||||
Vec::from_raw_buf(chars as *mut u8, length as usize)
|
||||
};
|
||||
|
||||
return Ok(ByteString::new(char_vec));
|
||||
}
|
||||
|
||||
unsafe {
|
||||
let mut length = 0;
|
||||
let chars = JS_GetTwoByteStringCharsAndLength(cx, ptr::null(), string, &mut length);
|
||||
let char_vec = slice::from_raw_parts(chars, length as usize);
|
||||
|
||||
if char_vec.iter().any(|&c| c > 0xFF) {
|
||||
|
|
@ -434,14 +472,13 @@ impl FromJSValConvertible for ByteString {
|
|||
}
|
||||
|
||||
impl ToJSValConvertible for Reflector {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
let obj = self.get_jsobject();
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
let obj = self.get_jsobject().get();
|
||||
assert!(!obj.is_null());
|
||||
let mut value = ObjectValue(unsafe { &*obj });
|
||||
if unsafe { JS_WrapValue(cx, &mut value) } == 0 {
|
||||
rval.set(ObjectValue(unsafe { &*obj }));
|
||||
if unsafe { JS_WrapValue(cx, rval) } == 0 {
|
||||
panic!("JS_WrapValue failed.");
|
||||
}
|
||||
value
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -454,11 +491,10 @@ pub fn is_dom_class(clasp: *const JSClass) -> bool {
|
|||
|
||||
/// Returns whether `obj` is a DOM object implemented as a proxy.
|
||||
pub fn is_dom_proxy(obj: *mut JSObject) -> bool {
|
||||
use js::glue::{js_IsObjectProxyClass, js_IsFunctionProxyClass, IsProxyHandlerFamily};
|
||||
|
||||
use js::glue::IsProxyHandlerFamily;
|
||||
unsafe {
|
||||
(js_IsObjectProxyClass(obj) || js_IsFunctionProxyClass(obj)) &&
|
||||
IsProxyHandlerFamily(obj)
|
||||
let clasp = JS_GetClass(obj);
|
||||
((*clasp).flags & js::JSCLASS_IS_PROXY) != 0 && IsProxyHandlerFamily(obj) != 0
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -467,29 +503,24 @@ pub fn is_dom_proxy(obj: *mut JSObject) -> bool {
|
|||
// We use slot 0 for holding the raw object. This is safe for both
|
||||
// globals and non-globals.
|
||||
pub const DOM_OBJECT_SLOT: u32 = 0;
|
||||
const DOM_PROXY_OBJECT_SLOT: u32 = js::JSSLOT_PROXY_PRIVATE;
|
||||
|
||||
/// Returns the index of the slot wherein a pointer to the reflected DOM object
|
||||
/// is stored.
|
||||
///
|
||||
/// Fails if `obj` is not a DOM object.
|
||||
pub unsafe fn dom_object_slot(obj: *mut JSObject) -> u32 {
|
||||
let clasp = JS_GetClass(obj);
|
||||
if is_dom_class(&*clasp) {
|
||||
DOM_OBJECT_SLOT
|
||||
} else {
|
||||
assert!(is_dom_proxy(obj));
|
||||
DOM_PROXY_OBJECT_SLOT
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the DOM object from the given reflector.
|
||||
pub unsafe fn native_from_reflector<T>(obj: *mut JSObject) -> *const T {
|
||||
use js::jsapi::JS_GetReservedSlot;
|
||||
use js::glue::GetProxyPrivate;
|
||||
|
||||
let slot = dom_object_slot(obj);
|
||||
let value = JS_GetReservedSlot(obj, slot);
|
||||
value.to_private() as *const T
|
||||
let clasp = JS_GetClass(obj);
|
||||
let value = if is_dom_class(clasp) {
|
||||
JS_GetReservedSlot(obj, DOM_OBJECT_SLOT)
|
||||
} else {
|
||||
assert!(is_dom_proxy(obj));
|
||||
GetProxyPrivate(obj)
|
||||
};
|
||||
if value.is_undefined() {
|
||||
ptr::null()
|
||||
} else {
|
||||
value.to_private() as *const T
|
||||
}
|
||||
}
|
||||
|
||||
/// Get the `DOMClass` from `obj`, or `Err(())` if `obj` is not a DOM object.
|
||||
|
|
@ -518,17 +549,16 @@ unsafe fn get_dom_class(obj: *mut JSObject) -> Result<DOMClass, ()> {
|
|||
/// Returns Err(()) if `obj` is an opaque security wrapper or if the object is
|
||||
/// not a reflector for a DOM object of the given type (as defined by the
|
||||
/// proto_id and proto_depth).
|
||||
pub fn native_from_reflector_jsmanaged<T>(mut obj: *mut JSObject) -> Result<Unrooted<T>, ()>
|
||||
pub fn native_from_reflector_jsmanaged<T>(mut obj: *mut JSObject) -> Result<Root<T>, ()>
|
||||
where T: Reflectable + IDLInterface
|
||||
{
|
||||
use js::glue::{IsWrapper, UnwrapObject};
|
||||
use std::ptr;
|
||||
|
||||
unsafe {
|
||||
let dom_class = try!(get_dom_class(obj).or_else(|_| {
|
||||
if IsWrapper(obj) == 1 {
|
||||
debug!("found wrapper");
|
||||
obj = UnwrapObject(obj, /* stopAtOuter = */ 0, ptr::null_mut());
|
||||
obj = UnwrapObject(obj, /* stopAtOuter = */ 0);
|
||||
if obj.is_null() {
|
||||
debug!("unwrapping security wrapper failed");
|
||||
Err(())
|
||||
|
|
@ -547,7 +577,9 @@ pub fn native_from_reflector_jsmanaged<T>(mut obj: *mut JSObject) -> Result<Unro
|
|||
let proto_depth = <T as IDLInterface>::get_prototype_depth();
|
||||
if dom_class.interface_chain[proto_depth] == proto_id {
|
||||
debug!("good prototype");
|
||||
Ok(Unrooted::from_raw(native_from_reflector(obj)))
|
||||
let native = native_from_reflector(obj);
|
||||
assert!(!native.is_null());
|
||||
Ok(Root::new(NonZero::new(native)))
|
||||
} else {
|
||||
debug!("bad prototype");
|
||||
Err(())
|
||||
|
|
@ -555,37 +587,54 @@ pub fn native_from_reflector_jsmanaged<T>(mut obj: *mut JSObject) -> Result<Unro
|
|||
}
|
||||
}
|
||||
|
||||
/// Get a Rooted<T> for a DOM object accessible from a HandleValue
|
||||
pub fn native_from_handlevalue<T>(v: HandleValue) -> Result<Root<T>, ()>
|
||||
where T: Reflectable + IDLInterface
|
||||
{
|
||||
native_from_reflector_jsmanaged(v.get().to_object())
|
||||
}
|
||||
|
||||
/// Get a Rooted<T> for a DOM object accessible from a HandleObject
|
||||
pub fn native_from_handleobject<T>(obj: HandleObject) -> Result<Root<T>, ()>
|
||||
where T: Reflectable + IDLInterface
|
||||
{
|
||||
native_from_reflector_jsmanaged(obj.get())
|
||||
}
|
||||
|
||||
impl<T: Reflectable> ToJSValConvertible for Root<T> {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
self.r().reflector().to_jsval(cx)
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
self.r().reflector().to_jsval(cx, rval);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: Reflectable> ToJSValConvertible for JSRef<'a, T> {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
self.reflector().to_jsval(cx)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, T: Reflectable> ToJSValConvertible for Unrooted<T> {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
self.reflector().to_jsval(cx)
|
||||
impl<'a, T: Reflectable> ToJSValConvertible for &'a T {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
self.reflector().to_jsval(cx, rval);
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: ToJSValConvertible> ToJSValConvertible for Option<T> {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
match self {
|
||||
&Some(ref value) => value.to_jsval(cx),
|
||||
&None => NullValue(),
|
||||
&Some(ref value) => value.to_jsval(cx, rval),
|
||||
&None => rval.set(NullValue()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T: ToJSValConvertible> ToJSValConvertible for Option<Rc<T>> {
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
match self {
|
||||
&Some(ref value) => (**value).to_jsval(cx, rval),
|
||||
&None => rval.set(NullValue()),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<X: default::Default, T: FromJSValConvertible<Config=X>> FromJSValConvertible for Option<T> {
|
||||
type Config = ();
|
||||
fn from_jsval(cx: *mut JSContext, value: JSVal, _: ()) -> Result<Option<T>, ()> {
|
||||
if value.is_null_or_undefined() {
|
||||
fn from_jsval(cx: *mut JSContext, value: HandleValue, _: ()) -> Result<Option<T>, ()> {
|
||||
if value.get().is_null_or_undefined() {
|
||||
Ok(None)
|
||||
} else {
|
||||
let option: X = default::Default::default();
|
||||
|
|
@ -596,11 +645,10 @@ impl<X: default::Default, T: FromJSValConvertible<Config=X>> FromJSValConvertibl
|
|||
}
|
||||
|
||||
impl ToJSValConvertible for *mut JSObject {
|
||||
fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
|
||||
let mut wrapped = ObjectOrNullValue(*self);
|
||||
fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
|
||||
rval.set(ObjectOrNullValue(*self));
|
||||
unsafe {
|
||||
assert!(JS_WrapValue(cx, &mut wrapped) != 0);
|
||||
assert!(JS_WrapValue(cx, rval) != 0);
|
||||
}
|
||||
wrapped
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue