Bindings: Add ScalarValueString support

Source/bindings/v8/V8Binding.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 49 matching lines @@
 #include "wtf/ArrayBufferContents.h"
 #include "wtf/MainThread.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Threading.h"
 #include "wtf/text/AtomicString.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuffer.h"
 #include "wtf/text/StringHash.h"
 #include "wtf/text/WTFString.h"
+#include "wtf/unicode/CharacterNames.h"
+#include "wtf/unicode/Unicode.h"
 
 namespace WebCore {
 
 v8::Handle<v8::Value> throwError(V8ErrorType errorType, const String& message, v8::Isolate* isolate)
 {
     return V8ThrowException::throwError(errorType, message, isolate);
 }
 
 v8::Handle<v8::Value> throwError(v8::Handle<v8::Value> exception, v8::Isolate* isolate)
 {
@@ skipping 412 matching lines @@
     return numberObject->NumberValue();
 }
 
 String toByteString(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
 {
     // Handle null default value.
     if (value.IsEmpty())
         return String();
 
     // From the Web IDL spec: http://heycam.github.io/webidl/#es-ByteString
+    if (value.IsEmpty())
+        return String();
 
     // 1. Let x be ToString(v)
     TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::String>, stringObject, value->ToString(), exceptionState, String());
     String x = toCoreString(stringObject);
 
     // 2. If the value of any element of x is greater than 255, then throw a TypeError.
     if (!x.containsOnlyLatin1()) {
         exceptionState.throwTypeError("Value is not a valid ByteString.");
         return String();
     }
 
     // 3. Return an IDL ByteString value whose length is the length of x, and where the
     // value of each element is the value of the corresponding element of x.
     // Blink: A ByteString is simply a String with a range constrained per the above, so
     // this is the identity operation.
     return x;
 }
 
+static bool hasUnmatchedSurrogates(const String& string)
+{
+    // By definition, 8-bit strings are confined to the Latin-1 code page and
+    // have no surrogates, matched or otherwise.
+    if (string.is8Bit())
+        return false;
+
+    const UChar* characters = string.characters16();
+    const unsigned length = string.length();
+
+    for (unsigned i = 0; i < length; ++i) {
+        UChar c = characters[i];
+        if (U16_IS_SINGLE(c))
+            continue;
+        if (U16_IS_TRAIL(c))
+            return true;
+        ASSERT(U16_IS_LEAD(c));
+        if (i == length - 1)
+            return true;
+        UChar d = characters[i + 1];
+        if (!U16_IS_TRAIL(d))
+            return true;
+        ++i;
+    }
+    return false;
+}
+
+static String convertDOMStringToSequenceOfUnicodeCharacters(const String& string)

[Nils Barth (inactive), 2014/06/18 03:25:26]

I admire your adherence to spec, but you're right, it's really long.
haraken: any opinions?
obtainUnicode would match the spec anchor;
utf16ToUnicode or domStringToUnicode are brief but a bit cryptic;
resolveSurrogates seems clear enough.
WDYT?

[haraken, 2014/06/18 04:57:33]

I don't have a strong opinion here, since this method is just used internally in
V8Binding.cpp.

[jsbell, 2014/06/18 17:25:19]

I'll go back to 'replaceUnmatchedSurrogates' and add a comment that they're
replaced by the replacement character (U+FFFD)

+{
+    // This roughly implements http://heycam.github.io/webidl/#dfn-obtain-unicode
+    // but the output is still a sequence of 16-bit code units, effectively

[Nils Barth (inactive), 2014/06/18 03:25:26]

Is this still true, now that you're using StringBuilder?

[jsbell, 2014/06/18 17:25:19]

Yes. Blink strings are 16-bit internally, this just guarantees that it's valid
UTF-16.

The point of the ScalarValueString type in the spec is that the binding layer -
both spec and impl - enforces that it's a valid Unicode string, so that the rest
of the spec/impl can simply refer to characters (i.e. scalar values); in the
impl those characters may still be stored as multiple code units.

[Excuse me while I track down the person that first roped me into encoding
issues, and slap them with a trout.]

[Nils Barth (inactive), 2014/06/20 00:57:54]

Thanks for explanation!

On 2014/06/18 17:25:19, jsbell wrote:
(You could swap with Kouhei: he's been roped into SVG ;)

+    // re-encoding to UTF-16 after performing the replacements.
+
+    // The concepts of surrogate pairs are explained at:
+    // http://www.unicode.org/versions/Unicode6.2.0/ch03.pdf#G2630
+
+    // Blink-specific optimization to avoid making an unnecessary copy.
+    if (!hasUnmatchedSurrogates(string))
+        return string;
+    ASSERT(!string.is8Bit());
+
+    // 1. Let S be the DOMString value.
+    const UChar* s = string.characters16();
+
+    // 2. Let n be the length of S.
+    const unsigned n = string.length();
+
+    // 3. Initialize i to 0.
+    unsigned i = 0;
+
+    // 4. Initialize U to be an empty sequence of Unicode characters.
+    StringBuilder u;
+    u.reserveCapacity(n);
+
+    // 5. While i < n:
+    while (i < n) {
+        // 1. Let c be the code unit in S at index i.
+        UChar c = s[i];
+        // 2. Depending on the value of c:
+        if (U16_IS_SINGLE(c)) {
+            // c < 0xD800 or c > 0xDFFF
+            // Append to U the Unicode character with code point c.
+            u.append(c);
+        } else if (U16_IS_TRAIL(c)) {
+            // 0xDC00 <= c <= 0xDFFF
+            // Append to U a U+FFFD REPLACEMENT CHARACTER.
+            u.append(WTF::Unicode::replacementCharacter);
+        } else {
+            // 0xD800 <= c <= 0xDBFF
+            ASSERT(U16_IS_LEAD(c));
+            if (i == n - 1) {
+                // 1. If i = n−1, then append to U a U+FFFD REPLACEMENT CHARACTER.
+                u.append(WTF::Unicode::replacementCharacter);
+            } else {
+                // 2. Otherwise, i < n−1:
+                ASSERT(i < n - 1);
+                // ....1. Let d be the code unit in S at index i+1.
+                UChar d = s[i + 1];
+                if (U16_IS_TRAIL(d)) {
+                    // 2. If 0xDC00 <= d <= 0xDFFF, then:
+                    // ..1. Let a be c & 0x3FF.
+                    unsigned a = c & 0x3FF;
+                    // ..2. Let b be d & 0x3FF.
+                    unsigned b = d & 0x3FF;
+                    // ..3. Append to U the Unicode character with code point 2^16+2^10*a+b.
+                    u.append(static_cast<UChar32>((1 << 16) + (a << 10) + b));

[jsbell, 2014/06/17 21:39:50]

Since this is using StringBuilder, it's now "per spec" rather than just
re-appending the UTF-16 code units. I can change it back.

[tkent, 2014/06/17 23:38:54]

U16_GET_SUPPLEMENTARY(c, d) ?

[Nils Barth (inactive), 2014/06/18 03:25:26]

+1!

[jsbell, 2014/06/18 17:25:19]

Will do!

+                    // Blink: This is equivalent to u.append(c); u.append(d);
+                    ++i;
+                } else {
+                    // 3. Otherwise, d < 0xDC00 or d > 0xDFFF. Append to U a U+FFFD REPLACEMENT CHARACTER.
+                    u.append(WTF::Unicode::replacementCharacter);
+                }
+            }
+        }
+        // 3. Set i to i+1.
+        ++i;
+    }
+
+    // 6. Return U.
+    ASSERT(u.length() == string.length());
+    return u.toString();
+}
+
+String toScalarValueString(v8::Handle<v8::Value> value, ExceptionState& exceptionState)
+{
+    // From the Encoding standard (with a TODO to move to Web IDL):
+    // http://encoding.spec.whatwg.org/#type-scalarvaluestring
+    if (value.IsEmpty())
+        return String();
+    TONATIVE_DEFAULT_EXCEPTIONSTATE(v8::Local<v8::String>, stringObject, value->ToString(), exceptionState, String());
+
+    // ScalarValueString is identical to DOMString except that "convert a
+    // DOMString to a sequence of Unicode characters" is used subsequently
+    // when converting to an IDL value
+    String x = toCoreString(stringObject);
+    return convertDOMStringToSequenceOfUnicodeCharacters(x);
+}
+
 PassRefPtrWillBeRawPtr<XPathNSResolver> toXPathNSResolver(v8::Handle<v8::Value> value, v8::Isolate* isolate)
 {
     RefPtrWillBeRawPtr<XPathNSResolver> resolver = nullptr;
     if (V8XPathNSResolver::hasInstance(value, isolate))
         resolver = V8XPathNSResolver::toNative(v8::Handle<v8::Object>::Cast(value));
     else if (value->IsObject())
         resolver = V8CustomXPathNSResolver::create(value->ToObject(), isolate);
     return resolver;
 }
 
@@ skipping 280 matching lines @@
 PassRefPtr<TraceEvent::ConvertableToTraceFormat> devToolsTraceEventData(ExecutionContext* context, v8::Handle<v8::Function> function, v8::Isolate* isolate)
 {
     int scriptId = 0;
     String resourceName;
     int lineNumber = 1;
     GetDevToolsFunctionInfo(function, isolate, scriptId, resourceName, lineNumber);
     return InspectorFunctionCallEvent::data(context, scriptId, resourceName, lineNumber);
 }
 
 } // namespace WebCore