Move DOMString back to script

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

components/script/dom/bindings/codegen/CodegenRust.py

@@ -2087,16 +2087,15 @@ def UnionTypes(descriptors, dictionaries, callbacks, config):
         'dom::bindings::conversions::FromJSValConvertible',
         'dom::bindings::conversions::ToJSValConvertible',
         'dom::bindings::conversions::ConversionBehavior',
-        'dom::bindings::conversions::root_from_handlevalue',
         'dom::bindings::conversions::StringificationBehavior',
+        'dom::bindings::conversions::root_from_handlevalue',
         'dom::bindings::error::throw_not_in_union',
         'dom::bindings::js::Root',
-        'dom::bindings::str::USVString',
+        'dom::bindings::str::{DOMString, USVString}',
         'dom::types::*',
         'js::jsapi::JSContext',
         'js::jsapi::{HandleValue, MutableHandleValue}',
         'js::jsval::JSVal',
-        'util::str::DOMString',
     ]
 
     # Now find all the things we'll need as arguments and return values because
@@ -5598,14 +5597,12 @@ class CGBindingRoot(CGThing):
             'dom::bindings::proxyhandler::{ensure_expando_object, fill_property_descriptor}',
             'dom::bindings::proxyhandler::{get_expando_object, get_property_descriptor}',
             'dom::bindings::num::Finite',
-            'dom::bindings::str::ByteString',
-            'dom::bindings::str::USVString',
+            'dom::bindings::str::{ByteString, DOMString, USVString}',
             'dom::bindings::trace::RootedVec',
             'dom::bindings::weakref::{DOM_WEAK_SLOT, WeakBox, WeakReferenceable}',
             'mem::heap_size_of_raw_self_and_children',
             'libc',
             'util::prefs',
-            'util::str::DOMString',
             'std::borrow::ToOwned',
             'std::cmp',
             'std::mem',

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 = ();

components/script/dom/bindings/str.rs

@@ -6,11 +6,14 @@
 
 use std::ascii::AsciiExt;
 use std::borrow::ToOwned;
+use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::mem;
 use std::ops;
+use std::ops::{Deref, DerefMut};
 use std::str;
-use std::str::FromStr;
+use std::str::{Bytes, FromStr};
+use string_cache::Atom;
 
 /// Encapsulates the IDL `ByteString` type.
 #[derive(JSTraceable, Clone, Eq, PartialEq, HeapSizeOf)]
@@ -114,3 +117,119 @@ pub fn is_token(s: &[u8]) -> bool {
         }
     })
 }
+
+/// A DOMString.
+#[derive(Clone, Debug, Eq, Hash, HeapSizeOf, Ord, PartialEq, PartialOrd)]
+pub struct DOMString(String);
+
+impl !Send for DOMString {}
+
+impl DOMString {
+    /// Creates a new `DOMString`.
+    pub fn new() -> DOMString {
+        DOMString(String::new())
+    }
+
+    /// Creates a new `DOMString` from a `String`.
+    pub fn from_string(s: String) -> DOMString {
+        DOMString(s)
+    }
+
+    /// Appends a given string slice onto the end of this String.
+    pub fn push_str(&mut self, string: &str) {
+        self.0.push_str(string)
+    }
+
+    /// Truncates this `DOMString`, removing all contents.
+    pub fn clear(&mut self) {
+        self.0.clear()
+    }
+
+    /// An iterator over the bytes of this `DOMString`.
+    pub fn bytes(&self) -> Bytes {
+        self.0.bytes()
+    }
+}
+
+impl Default for DOMString {
+    fn default() -> Self {
+        DOMString(String::new())
+    }
+}
+
+impl Deref for DOMString {
+    type Target = str;
+
+    #[inline]
+    fn deref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl DerefMut for DOMString {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut str {
+        &mut self.0
+    }
+}
+
+impl AsRef<str> for DOMString {
+    fn as_ref(&self) -> &str {
+        &self.0
+    }
+}
+
+impl fmt::Display for DOMString {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&**self, f)
+    }
+}
+
+impl PartialEq<str> for DOMString {
+    fn eq(&self, other: &str) -> bool {
+        &**self == other
+    }
+}
+
+impl<'a> PartialEq<&'a str> for DOMString {
+    fn eq(&self, other: &&'a str) -> bool {
+        &**self == *other
+    }
+}
+
+impl From<String> for DOMString {
+    fn from(contents: String) -> DOMString {
+        DOMString(contents)
+    }
+}
+
+impl<'a> From<&'a str> for DOMString {
+    fn from(contents: &str) -> DOMString {
+        DOMString::from(String::from(contents))
+    }
+}
+
+impl From<DOMString> for Atom {
+    fn from(contents: DOMString) -> Atom {
+        Atom::from(contents.0)
+    }
+}
+
+impl From<DOMString> for String {
+    fn from(contents: DOMString) -> String {
+        contents.0
+    }
+}
+
+impl Into<Vec<u8>> for DOMString {
+    fn into(self) -> Vec<u8> {
+        self.0.into()
+    }
+}
+
+impl Extend<char> for DOMString {
+    fn extend<I>(&mut self, iterable: I) where I: IntoIterator<Item=char> {
+        self.0.extend(iterable)
+    }
+}

components/script/dom/bindings/trace.rs

@@ -37,6 +37,7 @@ use devtools_traits::WorkerId;
 use dom::bindings::js::{JS, Root};
 use dom::bindings::refcounted::Trusted;
 use dom::bindings::reflector::{Reflectable, Reflector};
+use dom::bindings::str::DOMString;
 use dom::bindings::utils::WindowProxyHandler;
 use dom::worker::SharedRt;
 use encoding::types::EncodingRef;
@@ -89,7 +90,7 @@ use style::selector_impl::PseudoElement;
 use style::values::specified::Length;
 use url::Origin as UrlOrigin;
 use url::Url;
-use util::str::{DOMString, LengthOrPercentageOrAuto};
+use util::str::LengthOrPercentageOrAuto;
 use uuid::Uuid;
 use webrender_traits::WebGLError;
 

components/script/dom/bindings/utils.rs

@@ -7,9 +7,11 @@
 use dom::bindings::codegen::InterfaceObjectMap;
 use dom::bindings::codegen::PrototypeList;
 use dom::bindings::codegen::PrototypeList::{MAX_PROTO_CHAIN_LENGTH, PROTO_OR_IFACE_LENGTH};
-use dom::bindings::conversions::{DOM_OBJECT_SLOT, is_dom_class, private_from_proto_check};
+use dom::bindings::conversions::{DOM_OBJECT_SLOT, is_dom_class};
+use dom::bindings::conversions::{jsstring_to_str, private_from_proto_check};
 use dom::bindings::error::throw_invalid_this;
 use dom::bindings::inheritance::TopTypeId;
+use dom::bindings::str::DOMString;
 use dom::bindings::trace::trace_object;
 use dom::browsingcontext;
 use heapsize::HeapSizeOf;
@@ -37,9 +39,7 @@ use std::ffi::CString;
 use std::os::raw::c_void;
 use std::ptr;
 use std::slice;
-use util::non_geckolib::jsstring_to_str;
 use util::prefs;
-use util::str::DOMString;
 
 /// Proxy handler for a WindowProxy.
 pub struct WindowProxyHandler(pub *const libc::c_void);

components/script/dom/bindings/xmlname.rs

@@ -5,8 +5,8 @@
 //! Functions for validating and extracting qualified XML names.
 
 use dom::bindings::error::{Error, ErrorResult, Fallible};
+use dom::bindings::str::DOMString;
 use string_cache::{Atom, Namespace};
-use util::str::DOMString;
 
 /// Validate a qualified name. See https://dom.spec.whatwg.org/#validate for details.
 pub fn validate_qualified_name(qualified_name: &str) -> ErrorResult {