1 files changed, 10 insertions, 91 deletions

diff --git a/components/script/dom/bindings/conversions.rs b/components/script/dom/bindings/conversions.rs
index 0df5a82c3b0..0ea59e6ee83 100644
--- a/components/script/dom/bindings/conversions.rs
+++ b/components/script/dom/bindings/conversions.rs
@@ -37,60 +37,17 @@ use std::ffi;
 pub(crate) use js::conversions::{
     ConversionBehavior, ConversionResult, FromJSValConvertible, ToJSValConvertible,
 };
-use js::error::throw_type_error;
 use js::glue::GetProxyReservedSlot;
 use js::jsapi::{Heap, IsWindowProxy, JS_IsExceptionPending, JSContext, JSObject};
 use js::jsval::UndefinedValue;
 use js::rust::wrappers::{IsArrayObject, JS_GetProperty, JS_HasProperty};
 use js::rust::{HandleObject, HandleValue, MutableHandleValue};
-use num_traits::Float;
 pub(crate) use script_bindings::conversions::*;
 
 use crate::dom::bindings::error::{Error, Fallible};
-use crate::dom::bindings::num::Finite;
 use crate::dom::bindings::reflector::DomObject;
 use crate::dom::bindings::root::DomRoot;
 use crate::dom::bindings::trace::{JSTraceable, RootedTraceableBox};
-use crate::dom::bindings::utils::DOMClass;
-use crate::dom::filelist::FileList;
-use crate::dom::htmlcollection::HTMLCollection;
-use crate::dom::htmlformcontrolscollection::HTMLFormControlsCollection;
-use crate::dom::htmloptionscollection::HTMLOptionsCollection;
-use crate::dom::nodelist::NodeList;
-
-impl<T: Float + ToJSValConvertible> ToJSValConvertible for Finite<T> {
-    #[inline]
-    unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
-        let value = **self;
-        value.to_jsval(cx, rval);
-    }
-}
-
-impl<T: Float + FromJSValConvertible<Config = ()>> FromJSValConvertible for Finite<T> {
-    type Config = ();
-
-    unsafe fn from_jsval(
-        cx: *mut JSContext,
-        value: HandleValue,
-        option: (),
-    ) -> Result<ConversionResult<Finite<T>>, ()> {
-        let result = match FromJSValConvertible::from_jsval(cx, value, option)? {
-            ConversionResult::Success(v) => v,
-            ConversionResult::Failure(error) => {
-                // FIXME(emilio): Why throwing instead of propagating the error?
-                throw_type_error(cx, &error);
-                return Err(());
-            },
-        };
-        match Finite::new(result) {
-            Some(v) => Ok(ConversionResult::Success(v)),
-            None => {
-                throw_type_error(cx, "this argument is not a finite floating-point value");
-                Err(())
-            },
-        }
-    }
-}
 
 impl<T: ToJSValConvertible + JSTraceable> ToJSValConvertible for RootedTraceableBox<T> {
     #[inline]
@@ -123,35 +80,6 @@ where
 
 pub(crate) use script_bindings::conversions::is_dom_proxy;
 
-/// Get a `*const libc::c_void` for the given DOM object, unless it is a DOM
-/// wrapper, and checking if the object is of the correct type.
-///
-/// Returns Err(()) if `obj` is a wrapper or if the object is not an object
-/// for a DOM object of the given type (as defined by the proto_id and proto_depth).
-#[inline]
-unsafe fn private_from_proto_check_static(
-    obj: *mut JSObject,
-    proto_check: fn(&'static DOMClass) -> bool,
-) -> Result<*const libc::c_void, ()> {
-    let dom_class = get_dom_class(obj).map_err(|_| ())?;
-    if proto_check(dom_class) {
-        trace!("good prototype");
-        Ok(private_from_object(obj))
-    } else {
-        trace!("bad prototype");
-        Err(())
-    }
-}
-
-/// Get a `*const T` for a DOM object accessible from a `JSObject`, where the DOM object
-/// is guaranteed not to be a wrapper.
-pub(crate) fn native_from_object_static<T>(obj: *mut JSObject) -> Result<*const T, ()>
-where
-    T: DomObject + IDLInterface,
-{
-    unsafe { private_from_proto_check_static(obj, T::derives).map(|ptr| ptr as *const T) }
-}
-
 /// Get a `DomRoot<T>` for the given DOM object, unwrapping any wrapper
 /// around it first, and checking if the object is of the correct type.
 ///
@@ -162,19 +90,7 @@ pub(crate) fn root_from_object_static<T>(obj: *mut JSObject) -> Result<DomRoot<T
 where
     T: DomObject + IDLInterface,
 {
-    native_from_object_static(obj).map(|ptr| unsafe { DomRoot::from_ref(&*ptr) })
-}
-
-/// Get a `*const T` for a DOM object accessible from a `HandleValue`.
-/// Caller is responsible for throwing a JS exception if needed in case of error.
-pub(crate) fn native_from_handlevalue<T>(v: HandleValue, cx: *mut JSContext) -> Result<*const T, ()>
-where
-    T: DomObject + IDLInterface,
-{
-    if !v.get().is_object() {
-        return Err(());
-    }
-    unsafe { native_from_object(v.get().to_object(), cx) }
+    unsafe { native_from_object_static(obj).map(|ptr| DomRoot::from_ref(&*ptr)) }
 }
 
 /// Get a `DomRoot<T>` for a DOM object accessible from a `HandleObject`.
@@ -191,7 +107,10 @@ where
 /// Returns whether `value` is an array-like object (Array, FileList,
 /// HTMLCollection, HTMLFormControlsCollection, HTMLOptionsCollection,
 /// NodeList).
-pub(crate) unsafe fn is_array_like(cx: *mut JSContext, value: HandleValue) -> bool {
+pub(crate) unsafe fn is_array_like<D: crate::DomTypes>(
+    cx: *mut JSContext,
+    value: HandleValue,
+) -> bool {
     let mut is_array = false;
     assert!(IsArrayObject(cx, value, &mut is_array));
     if is_array {
@@ -203,19 +122,19 @@ pub(crate) unsafe fn is_array_like(cx: *mut JSContext, value: HandleValue) -> bo
         _ => return false,
     };
 
-    if root_from_object::<FileList>(object, cx).is_ok() {
+    if root_from_object::<D::FileList>(object, cx).is_ok() {
         return true;
     }
-    if root_from_object::<HTMLCollection>(object, cx).is_ok() {
+    if root_from_object::<D::HTMLCollection>(object, cx).is_ok() {
         return true;
     }
-    if root_from_object::<HTMLFormControlsCollection>(object, cx).is_ok() {
+    if root_from_object::<D::HTMLFormControlsCollection>(object, cx).is_ok() {
         return true;
     }
-    if root_from_object::<HTMLOptionsCollection>(object, cx).is_ok() {
+    if root_from_object::<D::HTMLOptionsCollection>(object, cx).is_ok() {
         return true;
     }
-    if root_from_object::<NodeList>(object, cx).is_ok() {
+    if root_from_object::<D::NodeList>(object, cx).is_ok() {
         return true;
     }