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

Timestamp:

Jan 17, 2014, 9:44:49 AM (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 and the backing string is 8-bit.

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

@@ -35 +35 @@
 PassRefPtr<OpaqueJSString> OpaqueJSString::create(const String& string)
 {
-    if (!string.isNull())
-        return adoptRef(new OpaqueJSString(string));
-    return 0;
+    if (string.isNull())
+        return nullptr;
+
+    return adoptRef(new OpaqueJSString(string));
+}
+
+OpaqueJSString::~OpaqueJSString()
+{
+    // m_characters is put in a local here to avoid an extra atomic load.
+    const UChar* characters = m_characters;
+    if (!characters)
+        return;
+
+    if (!m_string.is8Bit() && m_string.characters() == characters)
+        return;
+
+    fastFree(const_cast<void*>(static_cast<const void*>(characters)));
 }
 
@@ -62 +76 @@
     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.
+    const UChar* characters = m_characters;
+    if (characters)
+        return characters;
+
+    if (m_string.isNull())
+        return nullptr;
+
+    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;
+}