Use throw_type_error and throw_range_error from js.

components/script/dom/bindings/error.rs

@@ -8,15 +8,12 @@ use dom::bindings::codegen::PrototypeList::proto_id_to_name;
 use dom::bindings::conversions::ToJSValConvertible;
 use dom::bindings::global::GlobalRef;
 use dom::domexception::{DOMErrorName, DOMException};
+use js::error::{throw_range_error, throw_type_error};
 use js::jsapi::JSAutoCompartment;
 use js::jsapi::{JSContext, JSObject, RootedValue};
-use js::jsapi::{JSErrorFormatString, JSExnType, JS_ReportErrorNumber};
 use js::jsapi::{JS_IsExceptionPending, JS_ReportPendingException, JS_SetPendingException};
 use js::jsapi::{JS_RestoreFrameChain, JS_SaveFrameChain};
 use js::jsval::UndefinedValue;
-use libc;
-use std::ffi::CString;
-use std::{mem, ptr};
 use util::mem::HeapSizeOf;
 
 /// DOM exceptions that can be thrown by a native DOM method.
@@ -80,8 +77,7 @@ pub type Fallible<T> = Result<T, Error>;
 pub type ErrorResult = Fallible<()>;
 
 /// Set a pending exception for the given `result` on `cx`.
-pub fn throw_dom_exception(cx: *mut JSContext, global: GlobalRef,
-                           result: Error) {
+pub unsafe fn throw_dom_exception(cx: *mut JSContext, global: GlobalRef, result: Error) {
     let code = match result {
         Error::IndexSize => DOMErrorName::IndexSizeError,
         Error::NotFound => DOMErrorName::NotFoundError,
@@ -104,28 +100,26 @@ pub fn throw_dom_exception(cx: *mut JSContext, global: GlobalRef,
         Error::QuotaExceeded => DOMErrorName::QuotaExceededError,
         Error::TypeMismatch => DOMErrorName::TypeMismatchError,
         Error::Type(message) => {
-            assert!(unsafe { !JS_IsExceptionPending(cx) });
+            assert!(!JS_IsExceptionPending(cx));
             throw_type_error(cx, &message);
             return;
         },
         Error::Range(message) => {
-            assert!(unsafe { !JS_IsExceptionPending(cx) });
+            assert!(!JS_IsExceptionPending(cx));
             throw_range_error(cx, &message);
             return;
         },
         Error::JSFailed => {
-            assert!(unsafe { JS_IsExceptionPending(cx) });
+            assert!(JS_IsExceptionPending(cx));
             return;
         }
     };
 
-    assert!(unsafe { !JS_IsExceptionPending(cx) });
+    assert!(!JS_IsExceptionPending(cx));
     let exception = DOMException::new(global, code);
     let mut thrown = RootedValue::new(cx, UndefinedValue());
     exception.to_jsval(cx, thrown.handle_mut());
-    unsafe {
-        JS_SetPendingException(cx, thrown.handle());
-    }
+    JS_SetPendingException(cx, thrown.handle());
 }
 
 /// Report a pending exception, thereby clearing it.
@@ -146,76 +140,17 @@ pub fn report_pending_exception(cx: *mut JSContext, obj: *mut JSObject) {
 
 /// Throw an exception to signal that a `JSVal` can not be converted to any of
 /// the types in an IDL union type.
-pub fn throw_not_in_union(cx: *mut JSContext, names: &'static str) {
-    assert!(unsafe { !JS_IsExceptionPending(cx) });
+pub unsafe fn throw_not_in_union(cx: *mut JSContext, names: &'static str) {
+    assert!(!JS_IsExceptionPending(cx));
     let error = format!("argument could not be converted to any of: {}", names);
     throw_type_error(cx, &error);
 }
 
 /// Throw an exception to signal that a `JSObject` can not be converted to a
 /// given DOM type.
-pub fn throw_invalid_this(cx: *mut JSContext, proto_id: u16) {
-    debug_assert!(unsafe { !JS_IsExceptionPending(cx) });
+pub unsafe fn throw_invalid_this(cx: *mut JSContext, proto_id: u16) {
+    debug_assert!(!JS_IsExceptionPending(cx));
     let error = format!("\"this\" object does not implement interface {}.",
                         proto_id_to_name(proto_id));
     throw_type_error(cx, &error);
 }
-
-/// Format string used to throw javascript errors.
-static ERROR_FORMAT_STRING_STRING: [libc::c_char; 4] = [
-    '{' as libc::c_char,
-    '0' as libc::c_char,
-    '}' as libc::c_char,
-    0 as libc::c_char,
-];
-
-/// Format string struct used to throw `TypeError`s.
-static mut TYPE_ERROR_FORMAT_STRING: JSErrorFormatString = JSErrorFormatString {
-    format: &ERROR_FORMAT_STRING_STRING as *const libc::c_char,
-    argCount: 1,
-    exnType: JSExnType::JSEXN_TYPEERR as i16,
-};
-
-/// Format string struct used to throw `RangeError`s.
-static mut RANGE_ERROR_FORMAT_STRING: JSErrorFormatString = JSErrorFormatString {
-    format: &ERROR_FORMAT_STRING_STRING as *const libc::c_char,
-    argCount: 1,
-    exnType: JSExnType::JSEXN_RANGEERR as i16,
-};
-
-/// Callback used to throw javascript errors.
-/// See throw_js_error for info about error_number.
-unsafe extern fn get_error_message(_user_ref: *mut libc::c_void,
-                                   error_number: libc::c_uint)
-    -> *const JSErrorFormatString
-{
-    let num: JSExnType = mem::transmute(error_number);
-    match num {
-      JSExnType::JSEXN_TYPEERR => &TYPE_ERROR_FORMAT_STRING as *const JSErrorFormatString,
-      JSExnType::JSEXN_RANGEERR => &RANGE_ERROR_FORMAT_STRING as *const JSErrorFormatString,
-      _ => panic!("Bad js error number given to get_error_message: {}", error_number)
-    }
-}
-
-/// Helper fn to throw a javascript error with the given message and number.
-/// Reuse the jsapi error codes to distinguish the error_number
-/// passed back to the get_error_message callback.
-/// c_uint is u32, so this cast is safe, as is casting to/from i32 from there.
-fn throw_js_error(cx: *mut JSContext, error: &str, error_number: u32) {
-    let error = CString::new(error).unwrap();
-    unsafe {
-        JS_ReportErrorNumber(cx,
-            Some(get_error_message),
-            ptr::null_mut(), error_number, error.as_ptr());
-    }
-}
-
-/// Throw a `TypeError` with the given message.
-pub fn throw_type_error(cx: *mut JSContext, error: &str) {
-    throw_js_error(cx, error, JSExnType::JSEXN_TYPEERR as u32);
-}
-
-/// Throw a `RangeError` with the given message.
-pub fn throw_range_error(cx: *mut JSContext, error: &str) {
-    throw_js_error(cx, error, JSExnType::JSEXN_RANGEERR as u32);
-}