Move DOMString back to script

This entirely removes the 'non-geckolib' feature of the util crate.

components/script/dom/bindings/conversions.rs

@@ -36,27 +36,26 @@ use dom::bindings::inheritance::Castable;
 use dom::bindings::js::Root;
 use dom::bindings::num::Finite;
 use dom::bindings::reflector::{Reflectable, Reflector};
-use dom::bindings::str::{ByteString, USVString};
+use dom::bindings::str::{ByteString, DOMString, USVString};
 use dom::bindings::utils::DOMClass;
 use js;
 pub use js::conversions::{FromJSValConvertible, ToJSValConvertible, ConversionBehavior};
+use js::conversions::latin1_to_string;
 use js::error::throw_type_error;
 use js::glue::{GetProxyPrivate, IsWrapper};
 use js::glue::{RUST_JSID_IS_STRING, RUST_JSID_TO_STRING, UnwrapObject};
-use js::jsapi::{HandleId, HandleObject, HandleValue, JS_GetClass};
-use js::jsapi::{JSClass, JSContext, JSObject, MutableHandleValue};
-use js::jsapi::{JS_GetLatin1StringCharsAndLength, JS_GetReservedSlot};
-use js::jsapi::{JS_GetObjectAsArrayBufferView, JS_GetArrayBufferViewType};
-use js::jsapi::{JS_GetTwoByteStringCharsAndLength, JS_IsArrayObject, JS_NewStringCopyN};
-use js::jsapi::{JS_StringHasLatin1Chars, JS_WrapValue};
-use js::jsapi::{Type};
+use js::jsapi::{HandleId, HandleObject, HandleValue, JSClass, JSContext};
+use js::jsapi::{JSObject, JSString, JS_GetArrayBufferViewType, JS_GetClass};
+use js::jsapi::{JS_GetLatin1StringCharsAndLength, JS_GetObjectAsArrayBufferView};
+use js::jsapi::{JS_GetReservedSlot, JS_GetTwoByteStringCharsAndLength};
+use js::jsapi::{JS_IsArrayObject, JS_NewStringCopyN, JS_StringHasLatin1Chars};
+use js::jsapi::{JS_WrapValue, MutableHandleValue, Type};
 use js::jsval::{ObjectValue, StringValue};
 use js::rust::ToString;
 use libc;
 use num_traits::Float;
-use std::{ptr, mem, slice};
-pub use util::non_geckolib::{StringificationBehavior, jsstring_to_str};
-use util::str::DOMString;
+use std::{char, mem, ptr, slice};
+use util::opts;
 
 /// A trait to check whether a given `JSObject` implements an IDL interface.
 pub trait IDLInterface {
@@ -125,6 +124,82 @@ impl ToJSValConvertible for USVString {
     }
 }
 
+/// Behavior for stringification of `JSVal`s.
+#[derive(PartialEq, Clone)]
+pub enum StringificationBehavior {
+    /// Convert `null` to the string `"null"`.
+    Default,
+    /// Convert `null` to the empty string.
+    Empty,
+}
+
+// https://heycam.github.io/webidl/#es-DOMString
+impl ToJSValConvertible for DOMString {
+    unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue) {
+        (**self).to_jsval(cx, rval);
+    }
+}
+
+// https://heycam.github.io/webidl/#es-DOMString
+impl FromJSValConvertible for DOMString {
+    type Config = StringificationBehavior;
+    unsafe fn from_jsval(cx: *mut JSContext,
+                         value: HandleValue,
+                         null_behavior: StringificationBehavior)
+                         -> Result<DOMString, ()> {
+        if null_behavior == StringificationBehavior::Empty &&
+           value.get().is_null() {
+            Ok(DOMString::new())
+        } else {
+            let jsstr = ToString(cx, value);
+            if jsstr.is_null() {
+                debug!("ToString failed");
+                Err(())
+            } else {
+                Ok(jsstring_to_str(cx, jsstr))
+            }
+        }
+    }
+}
+
+/// Convert the given `JSString` to a `DOMString`. Fails if the string does not
+/// contain valid UTF-16.
+pub unsafe fn jsstring_to_str(cx: *mut JSContext, s: *mut JSString) -> DOMString {
+    let latin1 = JS_StringHasLatin1Chars(s);
+    DOMString::from_string(if latin1 {
+        latin1_to_string(cx, s)
+    } else {
+        let mut length = 0;
+        let chars = JS_GetTwoByteStringCharsAndLength(cx, ptr::null(), s, &mut length);
+        assert!(!chars.is_null());
+        let potentially_ill_formed_utf16 = slice::from_raw_parts(chars, length as usize);
+        let mut s = String::with_capacity(length as usize);
+        for item in char::decode_utf16(potentially_ill_formed_utf16.iter().cloned()) {
+            match item {
+                Ok(c) => s.push(c),
+                Err(_) => {
+                    // FIXME: Add more info like document URL in the message?
+                    macro_rules! message {
+                        () => {
+                            "Found an unpaired surrogate in a DOM string. \
+                             If you see this in real web content, \
+                             please comment on https://github.com/servo/servo/issues/6564"
+                        }
+                    }
+                    if opts::get().replace_surrogates {
+                        error!(message!());
+                        s.push('\u{FFFD}');
+                    } else {
+                        panic!(concat!(message!(), " Use `-Z replace-surrogates` \
+                            on the command line to make this non-fatal."));
+                    }
+                }
+            }
+        }
+        s
+    })
+}
+
 // http://heycam.github.io/webidl/#es-USVString
 impl FromJSValConvertible for USVString {
     type Config = ();