Changeset 165703 in webkit for trunk/Source/JavaScriptCore/runtime/JSStringBuilder.h

Timestamp:

Mar 16, 2014, 10:35:53 AM (11 years ago)

Author:

Darin Adler

Message:

Remove all uses of deprecatedCharacters from JavaScriptCore
​https://bugs.webkit.org/show_bug.cgi?id=130304

Reviewed by Anders Carlsson.

Source/JavaScriptCore:

• API/JSValueRef.cpp:

(JSValueMakeFromJSONString): Use characters16 in the 16-bit code path.

• API/OpaqueJSString.cpp:

(OpaqueJSString::~OpaqueJSString): Use characters 16 in the 16-bit code path.
(OpaqueJSString::identifier): Get rid of custom Identifier constructor, and
juse use the standard one that takes a String.
(OpaqueJSString::characters): Use getCharactersWithUpconvert instead of a
hand-written alternative.

• bindings/ScriptValue.cpp:

(Deprecated::jsToInspectorValue): Create InspectorString from String directly
instead of involving a character pointer. Use the String from Identifier
directly instead of making a new String.

• inspector/ContentSearchUtilities.cpp:

(Inspector::ContentSearchUtilities::createSearchRegexSource): Use StringBuilder
instead of building a String a character at a time. This is still a very slow
way to do this. Also use strchr to search for a character instead of building
a String every time just to use find on it.

• inspector/InspectorValues.cpp:

(Inspector::doubleQuoteString): Remove unnecessary trip through a
character pointer. This is still a really slow way to do this.
(Inspector::InspectorValue::parseJSON): Use StringView::upconvertedCharacters
instead of String::deprecatedCharacters. Still slow to always upconvert.

• runtime/DateConstructor.cpp: Removed unneeded include.
• runtime/DatePrototype.cpp: Ditto.

• runtime/Identifier.h: Removed deprecatedCharacters function.

• runtime/JSGlobalObjectFunctions.cpp:

(JSC::encode): Added a type cast to avoid ambiguity with the two character-
appending functions from JSStringBuilder. Removed unneeded code duplicating
what JSStringBuilder already does in its character append function.
(JSC::decode): Deleted code that creates a JSStringBuilder that is never used.
(JSC::parseIntOverflow): Changed lengths to unsigned. Made only the overload that
is used outside this file have external linkage. Added a new overload that takes
a StringView.
(JSC::parseInt): Use StringView::substring to call parseIntOverflow.
(JSC::globalFuncEscape): Use JSBuilder::append in a more efficient way for a
single character.

• runtime/JSGlobalObjectFunctions.h: Removed unused overloads of parseIntOverflow.

• runtime/JSStringBuilder.h: Marked this "lightly deprecated".

(JSC::JSStringBuilder::append): Overloaded for better speed with 8-bit characters.
Made one overload private. Fixed a performance bug where we would reserve capacity
in the 8-bit buffer but then append to the 16-bit buffer.

• runtime/ObjectPrototype.cpp: Removed unneeded include.

• runtime/StringPrototype.cpp:

(JSC::stringProtoFuncFontsize): Use StringView::getCharactersWithUpconvert.
(JSC::stringProtoFuncLink): Ditto.

Source/WTF:

• wtf/dtoa.h:

(WTF::parseDouble): Added an overload that takes a StringView.

File:

• trunk/Source/JavaScriptCore/runtime/JSStringBuilder.h (modified) (3 diffs)

trunk/Source/JavaScriptCore/runtime/JSStringBuilder.h

@@ -33 +33 @@
 namespace JSC {
 
+// FIXME: Should move the last few callers over from this to WTF::StringBuilder.
 class JSStringBuilder {
 public:
@@ -41 +42 @@
     }
 
-    void append(const UChar u)
+    void append(LChar character)
     {
         if (m_is8Bit) {
-            if (u < 0xff) {
-                LChar c = u;
-                m_okay &= buffer8.tryAppend(&c, 1);
+            m_okay &= buffer8.tryAppend(&character, 1);
+            return;
+        }
+        UChar upconvertedCharacter = character;
+        m_okay &= buffer16.tryAppend(&upconvertedCharacter, 1);
+    }
+
+    void append(UChar character)
+    {
+        if (m_is8Bit) {
+            if (character < 0x100) {
+                LChar narrowedCharacter = character;
+                m_okay &= buffer8.tryAppend(&narrowedCharacter, 1);
                 return;
             }
             upConvert();
         }
-        m_okay &= buffer16.tryAppend(&u, 1);
+        m_okay &= buffer16.tryAppend(&character, 1);
     }
 
     void append(const char* str)
     {
-        append(str, strlen(str));
-    }
-
-    void append(const char* str, size_t len)
-    {
-        if (m_is8Bit) {
-            m_okay &= buffer8.tryAppend(reinterpret_cast<const LChar*>(str), len);
-            return;
-        }
-        m_okay &= buffer8.tryReserveCapacity(buffer16.size() + len);
-        for (size_t i = 0; i < len; i++) {
-            UChar u = static_cast<unsigned char>(str[i]);
-            m_okay &= buffer16.tryAppend(&u, 1);
-        }
-    }
-
-    void append(const LChar* str, size_t len)
-    {
-        if (m_is8Bit) {
-            m_okay &= buffer8.tryAppend(str, len);
-            return;
-        }
-        m_okay &= buffer8.tryReserveCapacity(buffer16.size() + len);
-        for (size_t i = 0; i < len; i++) {
-            UChar u = str[i];
-            m_okay &= buffer16.tryAppend(&u, 1);
-        }
-    }
-    
-    void append(const UChar* str, size_t len)
-    {
-        if (m_is8Bit)
-            upConvert(); // FIXME: We could check character by character its size.
-        m_okay &= buffer16.tryAppend(str, len);
-    }
-
-    void append(const String& str)
-    {
-        unsigned length = str.length();
-
-        if (!length)
-            return;
-
-        if (m_is8Bit) {
-            if (str.is8Bit()) {
-                m_okay &= buffer8.tryAppend(str.characters8(), length);
-                return;
-            }
-            upConvert();
-        }
-        m_okay &= buffer16.tryAppend(str.deprecatedCharacters(), length);
-    }
-
-    void upConvert()
-    {
-        ASSERT(m_is8Bit);
-        size_t len = buffer8.size();
-
-        for (size_t i = 0; i < len; i++)
-            buffer16.append(buffer8[i]);
-
-        buffer8.clear();
-        m_is8Bit = false;
+        append(reinterpret_cast<const LChar*>(str), strlen(str));
     }
 
@@ -137 +86 @@
     }
 
-protected:
+private:
+    void append(const LChar* characters, size_t length)
+    {
+        if (m_is8Bit) {
+            m_okay &= buffer8.tryAppend(characters, length);
+            return;
+        }
+        // FIXME: There must be a more efficient way of doing this.
+        m_okay &= buffer16.tryReserveCapacity(buffer16.size() + length);
+        for (size_t i = 0; i < length; i++) {
+            UChar upconvertedCharacter = characters[i];
+            m_okay &= buffer16.tryAppend(&upconvertedCharacter, 1);
+        }
+    }
+
+    void upConvert()
+    {
+        ASSERT(m_is8Bit);
+        size_t len = buffer8.size();
+
+        for (size_t i = 0; i < len; i++)
+            buffer16.append(buffer8[i]);
+
+        buffer8.clear();
+        m_is8Bit = false;
+    }
+
     Vector<LChar, 64, UnsafeVectorOverflow> buffer8;
     Vector<UChar, 64, UnsafeVectorOverflow> buffer16;