DevTools: always use 16bit strings for inspector protocol.

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

 // Copyright (c) 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/inspector_protocol/String16.h"
 #include "platform/inspector_protocol/Values.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 208 matching lines @@
 
     // Test basic string escapes
     root = parseJSON("\" \\\"\\\\\\/\\b\\f\\n\\r\\t\\v\"");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeString, root->type());
     EXPECT_TRUE(root->asString(&strVal));
     EXPECT_EQ(" \"\\/\b\f\n\r\t\v", strVal);
 
     // Test hex and unicode escapes including the null character.
     root = parseJSON("\"\\x41\\x00\\u1234\"");
-    ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeString, root->type());
-    EXPECT_TRUE(root->asString(&strVal));
-    UChar tmp1[] = {0x41, 0, 0x1234};
-    EXPECT_EQ(String16(tmp1, 3), strVal);
+    EXPECT_FALSE(root.get());
 
     // Test invalid strings
     root = parseJSON("\"no closing quote");
     EXPECT_FALSE(root.get());
     root = parseJSON("\"\\z invalid escape char\"");
     EXPECT_FALSE(root.get());
-    root = parseJSON("\"\\xAQ invalid hex code\"");
-    EXPECT_FALSE(root.get());
-    root = parseJSON("not enough hex chars\\x1\"");
-    EXPECT_FALSE(root.get());
     root = parseJSON("\"not enough escape chars\\u123\"");
     EXPECT_FALSE(root.get());
     root = parseJSON("\"extra backslash at end of input\\\"");
     EXPECT_FALSE(root.get());
 
     // Basic array
     root = parseJSON("[true, false, null]");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeArray, root->type());
     list = ListValue::cast(root.get());
@@ skipping 53 matching lines @@
     root = parseJSON("[,true,]");
     EXPECT_FALSE(root.get());
     root = parseJSON("[true,,false]");
     EXPECT_FALSE(root.get());
 
     // Test objects
     root = parseJSON("{}");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeObject, root->type());
 
-    root = parseJSON("{\"number\":9.87654321, \"null\":null , \"\\x53\" : \"str\" }");
+    root = parseJSON("{\"number\":9.87654321, \"null\":null , \"S\" : \"str\" }");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeObject, root->type());
     protocol::DictionaryValue* objectVal = DictionaryValue::cast(root.get());
     ASSERT_TRUE(objectVal);
     doubleVal = 0.0;
     EXPECT_TRUE(objectVal->getNumber("number", &doubleVal));
     EXPECT_DOUBLE_EQ(9.87654321, doubleVal);
     protocol::Value* nullVal = objectVal->get("null");
     ASSERT_TRUE(nullVal);
     EXPECT_EQ(Value::TypeNull, nullVal->type());
     EXPECT_TRUE(objectVal->getString("S", &strVal));
     EXPECT_EQ("str", strVal);
 
     // Test newline equivalence.
     root2 = parseJSON(
         "{\n"
         "  \"number\":9.87654321,\n"
         "  \"null\":null,\n"
-        "  \"\\x53\":\"str\"\n"
+        "  \"S\":\"str\"\n"
         "}\n");
     ASSERT_TRUE(root2.get());
     EXPECT_EQ(root->toJSONString(), root2->toJSONString());
 
     root2 = parseJSON(
         "{\r\n"
         "  \"number\":9.87654321,\r\n"
         "  \"null\":null,\r\n"
-        "  \"\\x53\":\"str\"\r\n"
+        "  \"S\":\"str\"\r\n"
         "}\r\n");
     ASSERT_TRUE(root2.get());
     EXPECT_EQ(root->toJSONString(), root2->toJSONString());
 
     // Test nesting
     root = parseJSON("{\"inner\":{\"array\":[true]},\"false\":false,\"d\":{}}");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeObject, root->type());
     objectVal = DictionaryValue::cast(root.get());
     ASSERT_TRUE(objectVal);
@@ skipping 86 matching lines @@
     notEvil.append("[]]");
     root = parseJSON(notEvil.toString());
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeArray, root->type());
     list = ListValue::cast(root.get());
     ASSERT_TRUE(list);
     EXPECT_EQ(5001U, list->size());
 
     // Test utf8 encoded input
     root = parseJSON("\"\\xe7\\xbd\\x91\\xe9\\xa1\\xb5\"");
-    ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeString, root->type());
-    EXPECT_TRUE(root->asString(&strVal));
-    UChar tmp4[] = {0x7f51, 0x9875};
-    EXPECT_EQ(String16(tmp4, 2), strVal);
-
-    root = parseJSON("{\"path\": \"/tmp/\\xc3\\xa0\\xc3\\xa8\\xc3\\xb2.png\"}");
-    ASSERT_TRUE(root.get());
-    EXPECT_EQ(Value::TypeObject, root->type());
-    objectVal = DictionaryValue::cast(root.get());
-    ASSERT_TRUE(objectVal);
-    EXPECT_TRUE(objectVal->getString("path", &strVal));
-    UChar tmp5[] = {0x2f, 0x74, 0x6d, 0x70, 0x2f, 0xe0, 0xe8, 0xf2, 0x2e, 0x70, 0x6e, 0x67};
-    EXPECT_EQ(String16(tmp5, 12), strVal);
-
-    // Test invalid utf8 encoded input
-    root = parseJSON("\"345\\xb0\\xa1\\xb0\\xa2\"");
-    ASSERT_FALSE(root.get());
-    root = parseJSON("\"123\\xc0\\x81\"");
-    ASSERT_FALSE(root.get());
-    root = parseJSON("\"abc\\xc0\\xae\"");
     ASSERT_FALSE(root.get());
 
     // Test utf16 encoded strings.
     root = parseJSON("\"\\u20ac3,14\"");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeString, root->type());
     EXPECT_TRUE(root->asString(&strVal));
     UChar tmp2[] = {0x20ac, 0x33, 0x2c, 0x31, 0x34};
     EXPECT_EQ(String16(tmp2, 5), strVal);
 
     root = parseJSON("\"\\ud83d\\udca9\\ud83d\\udc6c\"");
     ASSERT_TRUE(root.get());
     EXPECT_EQ(Value::TypeString, root->type());
     EXPECT_TRUE(root->asString(&strVal));
     UChar tmp3[] = {0xd83d, 0xdca9, 0xd83d, 0xdc6c};
     EXPECT_EQ(String16(tmp3, 4), strVal);
 
-    // Test invalid utf16 strings.
-    const char* const cases[] = {
-        "\"\\u123\"", // Invalid scalar.
-        "\"\\ud83d\"", // Invalid scalar.
-        "\"\\u$%@!\"", // Invalid scalar.
-        "\"\\uzz89\"", // Invalid scalar.
-        "\"\\ud83d\\udca\"", // Invalid lower surrogate.
-        "\"\\ud83d\\ud83d\"", // Invalid lower surrogate.
-        "\"\\ud83foo\"", // No lower surrogate.
-        "\"\\ud83\\foo\"" // No lower surrogate.
-    };
-    for (size_t i = 0; i < 8; ++i) {
-        root = parseJSON(cases[i]);
-        EXPECT_FALSE(root.get()) << cases[i];
-    }
-
     // Test literal root objects.
     root = parseJSON("null");
     EXPECT_EQ(Value::TypeNull, root->type());
 
     root = parseJSON("true");
     ASSERT_TRUE(root.get());
     EXPECT_TRUE(root->asBoolean(&boolValue));
     EXPECT_TRUE(boolValue);
 
     root = parseJSON("10");
@@ skipping 24 matching lines @@
     };
 
     for (size_t i = 0; i < 11; ++i) {
         OwnPtr<protocol::Value> result = parseJSON(invalidJson[i]);
         EXPECT_FALSE(result.get());
     }
 }
 
 } // namespace protocol
 } // namespace blink