Changeset 162185 in webkit for trunk/Source/JavaScriptCore/API/OpaqueJSString.cpp

Timestamp:

Jan 16, 2014, 10:50:26 PM (11 years ago)

Author:

[email protected]

Message:

Get rid of OpaqueJSString::deprecatedCharacters()
​https://bugs.webkit.org/show_bug.cgi?id=127161

Reviewed by Sam Weinig.

Handle OpaqueJSString::m_string being either 8-bit or 16-bit and add extra
code paths for the 8-bit cases.

Unfortunately, JSStringGetCharactersPtr is still expected to return a 16-bit character pointer.
Handle this by storing a separate 16-bit string and initializing it on demand when JSStringGetCharactersPtr
is called. This has the nice side effect of making JSStringGetCharactersPtr thread-safe when it wasn't before.
(In theory, someone could have a JSStringRef backed by an 8-bit string and call JSStringGetCharactersPtr on it
causing an unsafe upconversion to a 16-bit string).

• API/JSStringRef.cpp:

(JSStringGetCharactersPtr):
Call OpaqueJSString::characters.

(JSStringGetUTF8CString):
Add a code path that handles 8-bit strings.

(JSStringIsEqual):
Call OpaqueJSString::equal.

• API/JSStringRefCF.cpp:

(JSStringCreateWithCFString):
Reformat the code to use an early return instead of putting most of the code inside the body of an if statement.

(JSStringCopyCFString):
Create an 8-bit CFStringRef if possible.

• API/OpaqueJSString.cpp:

(OpaqueJSString::create):
Use nullptr.

(OpaqueJSString::~OpaqueJSString):
Free m_characters.

(OpaqueJSString::characters):
Do the up-conversion and store the result in m_characters.

(OpaqueJSString::equal):
New helper function.

• API/OpaqueJSString.h:

(OpaqueJSString::is8Bit):
New function that returns whether a string is 8-bit or not.

(OpaqueJSString::characters8):
(OpaqueJSString::characters16):
Add getters.

File:

• trunk/Source/JavaScriptCore/API/OpaqueJSString.cpp (modified) (2 diffs)

trunk/Source/JavaScriptCore/API/OpaqueJSString.cpp

@@ -37 +37 @@
     if (!string.isNull())
         return adoptRef(new OpaqueJSString(string));
-    return 0;
+    return nullptr;
+}
+
+OpaqueJSString::~OpaqueJSString()
+{
+    if (UChar* characters = m_characters) {
+        // m_characters is put in a local here to avoid an extra atomic load.
+        fastFree(static_cast<void*>(characters));
+    }
 }
 
@@ -62 +70 @@
     return Identifier(vm, m_string.characters16(), m_string.length());
 }
+
+const UChar* OpaqueJSString::characters()
+{
+    if (!this)
+        return nullptr;
+
+    // m_characters is put in a local here to avoid an extra atomic load.
+    UChar* characters = m_characters;
+    if (characters)
+        return characters;
+
+    unsigned length = m_string.length();
+    UChar* newCharacters = static_cast<UChar*>(fastMalloc(length * sizeof(UChar)));
+
+    if (m_string.is8Bit()) {
+        for (size_t i = 0; i < length; ++i)
+            newCharacters[i] = m_string.characters8()[i];
+    } else
+        memcpy(newCharacters, m_string.characters16(), length * sizeof(UChar));
+
+    if (!m_characters.compare_exchange_strong(characters, newCharacters)) {
+        fastFree(newCharacters);
+        return characters;
+    }
+
+    return newCharacters;
+}
+
+bool OpaqueJSString::equal(const OpaqueJSString* a, const OpaqueJSString* b)
+{
+    if (a == b)
+        return true;
+
+    if (!a || !b)
+        return false;
+
+    return a->m_string == b->m_string;
+}
+
+