Implement USVString.

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

@@ -717,6 +717,32 @@ def getJSToNativeConversionInfo(type, descriptorProvider, failureCode=None,
 
         return handleOptional(conversionCode, CGGeneric(declType), default)
 
+    if type.isUSVString():
+        assert not isEnforceRange and not isClamp
+
+        conversionCode = (
+            "match FromJSValConvertible::from_jsval(cx, ${val}, ()) {\n"
+            "    Ok(strval) => strval,\n"
+            "    Err(_) => { %s },\n"
+            "}" % exceptionCode)
+
+        if defaultValue is None:
+            default = None
+        elif isinstance(defaultValue, IDLNullValue):
+            assert type.nullable()
+            default = "None"
+        else:
+            assert defaultValue.type.tag() in (IDLType.Tags.domstring, IDLType.Tags.usvstring)
+            default = 'USVString("%s".to_owned())' % defaultValue.value
+            if type.nullable():
+                default = "Some(%s)" % default
+
+        declType = "USVString"
+        if type.nullable():
+            declType = "Option<%s>" % declType
+
+        return handleOptional(conversionCode, CGGeneric(declType), default)
+
     if type.isByteString():
         assert not isEnforceRange and not isClamp
 
@@ -1086,6 +1112,11 @@ def getRetvalDeclarationForType(returnType, descriptorProvider):
         if returnType.nullable():
             result = CGWrapper(result, pre="Option<", post=">")
         return result
+    if returnType.isUSVString():
+        result = CGGeneric("USVString")
+        if returnType.nullable():
+            result = CGWrapper(result, pre="Option<", post=">")
+        return result
     if returnType.isByteString():
         result = CGGeneric("ByteString")
         if returnType.nullable():
@@ -4647,6 +4678,7 @@ class CGBindingRoot(CGThing):
             'dom::bindings::proxyhandler::{fill_property_descriptor, get_expando_object}',
             'dom::bindings::proxyhandler::{get_property_descriptor}',
             'dom::bindings::str::ByteString',
+            'dom::bindings::str::USVString',
             'libc',
             'util::str::DOMString',
             'std::borrow::ToOwned',

components/script/dom/bindings/conversions.rs

@@ -19,6 +19,7 @@
 //! | float                   | `f32`                            |
 //! | double                  | `f64`                            |
 //! | DOMString               | `DOMString`                      |
+//! | USVString               | `USVString`                      |
 //! | ByteString              | `ByteString`                     |
 //! | object                  | `*mut JSObject`                  |
 //! | interface types         | `JSRef<T>`      | `Temporary<T>` |
@@ -31,7 +32,7 @@
 
 use dom::bindings::codegen::PrototypeList;
 use dom::bindings::js::{JSRef, Root, Unrooted};
-use dom::bindings::str::ByteString;
+use dom::bindings::str::{ByteString, USVString};
 use dom::bindings::utils::{Reflectable, Reflector, DOMClass};
 use util::str::DOMString;
 
@@ -339,6 +340,31 @@ impl FromJSValConvertible for DOMString {
     }
 }
 
+impl ToJSValConvertible for USVString {
+    fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
+        self.0.to_jsval(cx)
+    }
+}
+
+impl FromJSValConvertible for USVString {
+    type Config = ();
+    fn from_jsval(cx: *mut JSContext, value: JSVal, _: ())
+                  -> Result<USVString, ()> {
+        let jsstr = unsafe { JS_ValueToString(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);
+                let char_vec = slice::from_raw_parts(chars, length as usize);
+                Ok(USVString(String::from_utf16_lossy(char_vec)))
+            }
+        }
+    }
+}
+
 impl ToJSValConvertible for ByteString {
     fn to_jsval(&self, cx: *mut JSContext) -> JSVal {
         unsafe {

components/script/dom/bindings/str.rs

@@ -157,3 +157,7 @@ impl FromStr for ByteString {
         Ok(ByteString::new(s.to_owned().into_bytes()))
     }
 }
+
+/// A string that is constructed from a UCS-2 buffer by replacing invalid code
+/// points with the replacement character.
+pub struct USVString(pub String);

components/script/dom/testbinding.rs

@@ -14,7 +14,7 @@ use dom::bindings::codegen::UnionTypes::HTMLElementOrLong;
 use dom::bindings::codegen::UnionTypes::HTMLElementOrLong::eLong;
 use dom::bindings::global::GlobalField;
 use dom::bindings::js::{JSRef, Temporary};
-use dom::bindings::str::ByteString;
+use dom::bindings::str::{ByteString, USVString};
 use dom::bindings::utils::{Reflector, Reflectable};
 use dom::blob::Blob;
 use util::str::DOMString;
@@ -55,6 +55,8 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn SetDoubleAttribute(self, _: f64) {}
     fn StringAttribute(self) -> DOMString { "".to_owned() }
     fn SetStringAttribute(self, _: DOMString) {}
+    fn UsvstringAttribute(self) -> USVString { USVString("".to_owned()) }
+    fn SetUsvstringAttribute(self, _: USVString) {}
     fn ByteStringAttribute(self) -> ByteString { ByteString::new(vec!()) }
     fn SetByteStringAttribute(self, _: ByteString) {}
     fn EnumAttribute(self) -> TestEnum { _empty }
@@ -98,6 +100,8 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn SetByteStringAttributeNullable(self, _: Option<ByteString>) {}
     fn GetStringAttributeNullable(self) -> Option<DOMString> { Some("".to_owned()) }
     fn SetStringAttributeNullable(self, _: Option<DOMString>) {}
+    fn GetUsvstringAttributeNullable(self) -> Option<USVString> { Some(USVString("".to_owned())) }
+    fn SetUsvstringAttributeNullable(self, _: Option<USVString>) {}
     fn SetBinaryRenamedAttribute(self, _: DOMString) {}
     fn BinaryRenamedAttribute(self) -> DOMString { "".to_owned() }
     fn GetEnumAttributeNullable(self) -> Option<TestEnum> { Some(_empty) }
@@ -124,6 +128,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn ReceiveFloat(self) -> f32 { 0. }
     fn ReceiveDouble(self) -> f64 { 0. }
     fn ReceiveString(self) -> DOMString { "".to_owned() }
+    fn ReceiveUsvstring(self) -> USVString { USVString("".to_owned()) }
     fn ReceiveByteString(self) -> ByteString { ByteString::new(vec!()) }
     fn ReceiveEnum(self) -> TestEnum { _empty }
     fn ReceiveInterface(self) -> Temporary<Blob> {
@@ -146,6 +151,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn ReceiveNullableFloat(self) -> Option<f32> { Some(0.) }
     fn ReceiveNullableDouble(self) -> Option<f64> { Some(0.) }
     fn ReceiveNullableString(self) -> Option<DOMString> { Some("".to_owned()) }
+    fn ReceiveNullableUsvstring(self) -> Option<USVString> { Some(USVString("".to_owned())) }
     fn ReceiveNullableByteString(self) -> Option<ByteString> { Some(ByteString::new(vec!())) }
     fn ReceiveNullableEnum(self) -> Option<TestEnum> { Some(_empty) }
     fn ReceiveNullableInterface(self) -> Option<Temporary<Blob>> {
@@ -167,6 +173,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn PassFloat(self, _: f32) {}
     fn PassDouble(self, _: f64) {}
     fn PassString(self, _: DOMString) {}
+    fn PassUsvstring(self, _: USVString) {}
     fn PassByteString(self, _: ByteString) {}
     fn PassEnum(self, _: TestEnum) {}
     fn PassInterface(self, _: JSRef<Blob>) {}
@@ -189,6 +196,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn PassNullableFloat(self, _: Option<f32>) {}
     fn PassNullableDouble(self, _: Option<f64>) {}
     fn PassNullableString(self, _: Option<DOMString>) {}
+    fn PassNullableUsvstring(self, _: Option<USVString>) {}
     fn PassNullableByteString(self, _: Option<ByteString>) {}
     // fn PassNullableEnum(self, _: Option<TestEnum>) {}
     fn PassNullableInterface(self, _: Option<JSRef<Blob>>) {}
@@ -209,6 +217,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn PassOptionalFloat(self, _: Option<f32>) {}
     fn PassOptionalDouble(self, _: Option<f64>) {}
     fn PassOptionalString(self, _: Option<DOMString>) {}
+    fn PassOptionalUsvstring(self, _: Option<USVString>) {}
     fn PassOptionalByteString(self, _: Option<ByteString>) {}
     fn PassOptionalEnum(self, _: Option<TestEnum>) {}
     fn PassOptionalInterface(self, _: Option<JSRef<Blob>>) {}
@@ -230,6 +239,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn PassOptionalNullableFloat(self, _: Option<Option<f32>>) {}
     fn PassOptionalNullableDouble(self, _: Option<Option<f64>>) {}
     fn PassOptionalNullableString(self, _: Option<Option<DOMString>>) {}
+    fn PassOptionalNullableUsvstring(self, _: Option<Option<USVString>>) {}
     fn PassOptionalNullableByteString(self, _: Option<Option<ByteString>>) {}
     // fn PassOptionalNullableEnum(self, _: Option<Option<TestEnum>>) {}
     fn PassOptionalNullableInterface(self, _: Option<Option<JSRef<Blob>>>) {}
@@ -248,6 +258,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn PassOptionalLongLongWithDefault(self, _: i64) {}
     fn PassOptionalUnsignedLongLongWithDefault(self, _: u64) {}
     fn PassOptionalStringWithDefault(self, _: DOMString) {}
+    fn PassOptionalUsvstringWithDefault(self, _: USVString) {}
     fn PassOptionalEnumWithDefault(self, _: TestEnum) {}
 
     fn PassOptionalNullableBooleanWithDefault(self, _: Option<bool>) {}
@@ -262,6 +273,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     // fn PassOptionalNullableFloatWithDefault(self, _: Option<f32>) {}
     // fn PassOptionalNullableDoubleWithDefault(self, _: Option<f64>) {}
     fn PassOptionalNullableStringWithDefault(self, _: Option<DOMString>) {}
+    fn PassOptionalNullableUsvstringWithDefault(self, _: Option<USVString>) {}
     fn PassOptionalNullableByteStringWithDefault(self, _: Option<ByteString>) {}
     // fn PassOptionalNullableEnumWithDefault(self, _: Option<TestEnum>) {}
     fn PassOptionalNullableInterfaceWithDefault(self, _: Option<JSRef<Blob>>) {}
@@ -283,6 +295,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     // fn PassOptionalNullableFloatWithNonNullDefault(self, _: Option<f32>) {}
     // fn PassOptionalNullableDoubleWithNonNullDefault(self, _: Option<f64>) {}
     fn PassOptionalNullableStringWithNonNullDefault(self, _: Option<DOMString>) {}
+    fn PassOptionalNullableUsvstringWithNonNullDefault(self, _: Option<USVString>) {}
     // fn PassOptionalNullableEnumWithNonNullDefault(self, _: Option<TestEnum>) {}
 
     fn PassVariadicBoolean(self, _: Vec<bool>) {}
@@ -297,6 +310,7 @@ impl<'a> TestBindingMethods for JSRef<'a, TestBinding> {
     fn PassVariadicFloat(self, _: Vec<f32>) {}
     fn PassVariadicDouble(self, _: Vec<f64>) {}
     fn PassVariadicString(self, _: Vec<DOMString>) {}
+    fn PassVariadicUsvstring(self, _: Vec<USVString>) {}
     fn PassVariadicByteString(self, _: Vec<ByteString>) {}
     fn PassVariadicEnum(self, _: Vec<TestEnum>) {}
     // fn PassVariadicInterface(self, _: Vec<JSRef<Blob>>) {}

components/script/dom/webidls/TestBinding.webidl

@@ -17,6 +17,7 @@ dictionary TestDictionary {
   float floatValue;
   double doubleValue;
   DOMString stringValue;
+  USVString usvstringValue;
   TestEnum enumValue;
   Blob interfaceValue;
   any anyValue;
@@ -35,6 +36,7 @@ dictionary TestDictionaryDefaults {
   // float floatValue = 7.0;
   // double doubleValue = 7.0;
   DOMString stringValue = "foo";
+  USVString usvstringValue = "foo";
   TestEnum enumValue = "bar";
   any anyValue = null;
 
@@ -50,6 +52,7 @@ dictionary TestDictionaryDefaults {
   // float? nullableFloatValue = 7.0;
   // double? nullableDoubleValue = 7.0;
   DOMString? nullableStringValue = "foo";
+  USVString? nullableUsvstringValue = "foo";
   // TestEnum? nullableEnumValue = "bar";
 };
 
@@ -66,6 +69,7 @@ interface TestBinding {
            attribute float floatAttribute;
            attribute double doubleAttribute;
            attribute DOMString stringAttribute;
+           attribute USVString usvstringAttribute;
            attribute ByteString byteStringAttribute;
            attribute TestEnum enumAttribute;
            attribute Blob interfaceAttribute;
@@ -86,6 +90,7 @@ interface TestBinding {
            attribute float? floatAttributeNullable;
            attribute double? doubleAttributeNullable;
            attribute DOMString? stringAttributeNullable;
+           attribute USVString? usvstringAttributeNullable;
            attribute ByteString? byteStringAttributeNullable;
   readonly attribute TestEnum? enumAttributeNullable;
            attribute Blob? interfaceAttributeNullable;
@@ -107,6 +112,7 @@ interface TestBinding {
   float receiveFloat();
   double receiveDouble();
   DOMString receiveString();
+  USVString receiveUsvstring();
   ByteString receiveByteString();
   TestEnum receiveEnum();
   Blob receiveInterface();
@@ -126,6 +132,7 @@ interface TestBinding {
   float? receiveNullableFloat();
   double? receiveNullableDouble();
   DOMString? receiveNullableString();
+  USVString? receiveNullableUsvstring();
   ByteString? receiveNullableByteString();
   TestEnum? receiveNullableEnum();
   Blob? receiveNullableInterface();
@@ -144,6 +151,7 @@ interface TestBinding {
   void passFloat(float arg);
   void passDouble(double arg);
   void passString(DOMString arg);
+  void passUsvstring(USVString arg);
   void passByteString(ByteString arg);
   void passEnum(TestEnum arg);
   void passInterface(Blob arg);
@@ -166,6 +174,7 @@ interface TestBinding {
   void passNullableFloat(float? arg);
   void passNullableDouble(double? arg);
   void passNullableString(DOMString? arg);
+  void passNullableUsvstring(USVString? arg);
   void passNullableByteString(ByteString? arg);
   // void passNullableEnum(TestEnum? arg);
   void passNullableInterface(Blob? arg);
@@ -186,6 +195,7 @@ interface TestBinding {
   void passOptionalFloat(optional float arg);
   void passOptionalDouble(optional double arg);
   void passOptionalString(optional DOMString arg);
+  void passOptionalUsvstring(optional USVString arg);
   void passOptionalByteString(optional ByteString arg);
   void passOptionalEnum(optional TestEnum arg);
   void passOptionalInterface(optional Blob arg);
@@ -207,6 +217,7 @@ interface TestBinding {
   void passOptionalNullableFloat(optional float? arg);
   void passOptionalNullableDouble(optional double? arg);
   void passOptionalNullableString(optional DOMString? arg);
+  void passOptionalNullableUsvstring(optional USVString? arg);
   void passOptionalNullableByteString(optional ByteString? arg);
   // void passOptionalNullableEnum(optional TestEnum? arg);
   void passOptionalNullableInterface(optional Blob? arg);
@@ -225,6 +236,7 @@ interface TestBinding {
   void passOptionalLongLongWithDefault(optional long long arg = -12);
   void passOptionalUnsignedLongLongWithDefault(optional unsigned long long arg = 17);
   void passOptionalStringWithDefault(optional DOMString arg = "x");
+  void passOptionalUsvstringWithDefault(optional USVString arg = "x");
   void passOptionalEnumWithDefault(optional TestEnum arg = "foo");
   // void passOptionalUnionWithDefault(optional (HTMLElement or long) arg = 9);
   // void passOptionalUnion2WithDefault(optional(Event or DOMString)? data = "foo");
@@ -239,6 +251,7 @@ interface TestBinding {
   void passOptionalNullableLongLongWithDefault(optional long long? arg = null);
   void passOptionalNullableUnsignedLongLongWithDefault(optional unsigned long long? arg = null);
   void passOptionalNullableStringWithDefault(optional DOMString? arg = null);
+  void passOptionalNullableUsvstringWithDefault(optional USVString? arg = null);
   void passOptionalNullableByteStringWithDefault(optional ByteString? arg = null);
   // void passOptionalNullableEnumWithDefault(optional TestEnum? arg = null);
   void passOptionalNullableInterfaceWithDefault(optional Blob? arg = null);
@@ -260,6 +273,7 @@ interface TestBinding {
   // void passOptionalNullableFloatWithNonNullDefault(optional float? arg = 0.0);
   // void passOptionalNullableDoubleWithNonNullDefault(optional double? arg = 0.0);
   void passOptionalNullableStringWithNonNullDefault(optional DOMString? arg = "x");
+  void passOptionalNullableUsvstringWithNonNullDefault(optional USVString? arg = "x");
   // void passOptionalNullableEnumWithNonNullDefault(optional TestEnum? arg = "foo");
   // void passOptionalNullableUnionWithNonNullDefault(optional (HTMLElement or long)? arg = 7);
   // void passOptionalNullableUnion2WithNonNullDefault(optional (Event or DOMString)? data = "foo");
@@ -276,6 +290,7 @@ interface TestBinding {
   void passVariadicFloat(float... args);
   void passVariadicDouble(double... args);
   void passVariadicString(DOMString... args);
+  void passVariadicUsvstring(USVString... args);
   void passVariadicByteString(ByteString... args);
   void passVariadicEnum(TestEnum... args);
   // void passVariadicInterface(Blob... args);