DevTools: generate string16-based handlers for v8_inspector.

third_party/WebKit/Source/platform/inspector_protocol/Parser.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "platform/inspector_protocol/Parser.h"
 
-#include "platform/Decimal.h"
+#include "platform/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
-#include "wtf/text/StringBuilder.h"
-#include "wtf/text/UTF8.h"
 
 namespace blink {
 namespace protocol {
 
 namespace {
 
 const int stackLimit = 1000;
 
 enum Token {
     ObjectBegin,
@@ skipping 271 matching lines @@
         return c - '0';
     if ('A' <= c && c <= 'F')
         return c - 'A' + 10;
     if ('a' <= c && c <= 'f')
         return c - 'a' + 10;
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 template<typename CharType>
-bool decodeUTF8(const CharType* start, const CharType* end, const CharType** utf8charEnd, StringBuilder* output)
+bool decodeUTF8(const CharType* start, const CharType* end, const CharType** utf8charEnd, String16Builder* output)
 {
     UChar utf16[4] = {0};
     char utf8[6] = {0};
     size_t utf8count = 0;
 
     while (start < end) {
         if (start + 1 >= end || *start != '\\' || *(start + 1) != 'x')
             return false;
         start += 2;
 
         // Accumulate one more utf8 character and try converting to utf16.
         if (start + 1 >= end)
             return false;
         utf8[utf8count++] = (hexToInt(*start) << 4) + hexToInt(*(start + 1));
         start += 2;
 
         const char* utf8start = utf8;
         UChar* utf16start = utf16;
-        WTF::Unicode::ConversionResult conversionResult = WTF::Unicode::convertUTF8ToUTF16(&utf8start, utf8start + utf8count, &utf16start, utf16start + WTF_ARRAY_LENGTH(utf16), nullptr, true);
+        String16::ConversionResult conversionResult = String16::convertUTF8ToUTF16(&utf8start, utf8start + utf8count, &utf16start, utf16start + 4, nullptr, true);
 
-        if (conversionResult == WTF::Unicode::sourceIllegal)
+        if (conversionResult == String16::sourceIllegal)
             return false;
 
-        if (conversionResult == WTF::Unicode::conversionOK) {
+        if (conversionResult == String16::conversionOK) {
             // Not all utf8 characters were consumed - failed parsing.
             if (utf8start != utf8 + utf8count)
                 return false;
 
             size_t utf16length = utf16start - utf16;
             output->append(utf16, utf16length);
             *utf8charEnd = start;
             return true;
         }
 
         // Keep accumulating utf8 characters up to buffer length (6 should be enough).
-        if (utf8count >= WTF_ARRAY_LENGTH(utf8))
+        if (utf8count >= 6)
             return false;
     }
 
     return false;
 }
 
 template<typename CharType>
-bool decodeString(const CharType* start, const CharType* end, StringBuilder* output)
+bool decodeString(const CharType* start, const CharType* end, String16Builder* output)
 {
     while (start < end) {
         UChar c = *start++;
         if ('\\' != c) {
             output->append(c);
             continue;
         }
         c = *start++;
 
         if (c == 'x') {
@@ skipping 35 matching lines @@
             break;
         default:
             return false;
         }
         output->append(c);
     }
     return true;
 }
 
 template<typename CharType>
-bool decodeString(const CharType* start, const CharType* end, String* output)
+bool decodeString(const CharType* start, const CharType* end, String16* output)
 {
     if (start == end) {
         *output = "";
         return true;
     }
     if (start > end)
         return false;
-    StringBuilder buffer;
+    String16Builder buffer;
     buffer.reserveCapacity(end - start);
     if (!decodeString(start, end, &buffer))
         return false;
     *output = buffer.toString();
     // Validate constructed utf16 string.
-    if (output->utf8(StrictUTF8Conversion).isNull())
+    if (!output->validateUTF8())
         return false;
     return true;
 }
 
 template<typename CharType>
 PassOwnPtr<Value> buildValue(const CharType* start, const CharType* end, const CharType** valueTokenEnd, int depth)
 {
     if (depth > stackLimit)
         return nullptr;
 
     OwnPtr<Value> result;
     const CharType* tokenStart;
     const CharType* tokenEnd;
     Token token = parseToken(start, end, &tokenStart, &tokenEnd);
     switch (token) {
     case InvalidToken:
         return nullptr;
     case NullToken:
         result = Value::null();
         break;
     case BoolTrue:
         result = FundamentalValue::create(true);
         break;
     case BoolFalse:
         result = FundamentalValue::create(false);
         break;
     case Number: {
         bool ok;
-        double value = charactersToDouble(tokenStart, tokenEnd - tokenStart, &ok);
-        if (Decimal::fromDouble(value).isInfinity())
-            ok = false;
+        double value = String16::charactersToDouble(tokenStart, tokenEnd - tokenStart, &ok);
         if (!ok)
             return nullptr;
         result = FundamentalValue::create(value);
         break;
     }
     case StringLiteral: {
-        String value;
+        String16 value;
         bool ok = decodeString(tokenStart + 1, tokenEnd - 1, &value);
         if (!ok)
             return nullptr;
         result = StringValue::create(value);
         break;
     }
     case ArrayBegin: {
         OwnPtr<ListValue> array = ListValue::create();
         start = tokenEnd;
         token = parseToken(start, end, &tokenStart, &tokenEnd);
@@ skipping 21 matching lines @@
         result = array.release();
         break;
     }
     case ObjectBegin: {
         OwnPtr<DictionaryValue> object = DictionaryValue::create();
         start = tokenEnd;
         token = parseToken(start, end, &tokenStart, &tokenEnd);
         while (token != ObjectEnd) {
             if (token != StringLiteral)
                 return nullptr;
-            String key;
+            String16 key;
             if (!decodeString(tokenStart + 1, tokenEnd - 1, &key))
                 return nullptr;
             start = tokenEnd;
 
             token = parseToken(start, end, &tokenStart, &tokenEnd);
             if (token != ObjectPairSeparator)
                 return nullptr;
             start = tokenEnd;
 
             OwnPtr<Value> value = buildValue(start, end, &tokenEnd, depth + 1);
@@ skipping 36 matching lines @@
     const CharType* end = start + length;
     const CharType *tokenEnd;
     OwnPtr<Value> value = buildValue(start, end, &tokenEnd, 0);
     if (!value || tokenEnd != end)
         return nullptr;
     return value.release();
 }
 
 } // anonymous namespace
 
-PassOwnPtr<Value> parseJSON(const String& json)
+PassOwnPtr<Value> parseJSON(const String16& json)
 {
     if (json.isEmpty())
         return nullptr;
     if (json.is8Bit())
         return parseJSONInternal(json.characters8(), json.length());
     return parseJSONInternal(json.characters16(), json.length());
 }
 
 } // namespace protocol
 } // namespace blink