Remove the pointer from StringImpl

Source/wtf/text/StringImpl.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller ( mueller@kde.org )
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 28 matching lines @@
 #include "wtf/RefCounted.h"
 #include <unistd.h>
 #endif
 
 using namespace std;
 
 namespace WTF {
 
 using namespace Unicode;
 
-COMPILE_ASSERT(sizeof(StringImpl) == 2 * sizeof(int) + 2 * sizeof(void*), StringImpl_should_stay_small);
+COMPILE_ASSERT(sizeof(StringImpl) == 3 * sizeof(int), StringImpl_should_stay_small);
 
 #ifdef STRING_STATS
 
 static Mutex& statsMutex()
 {
     DEFINE_STATIC_LOCAL(Mutex, mutex, ());
     return mutex;
 }
 
 static HashSet<void*>& liveStrings()
@@ skipping 324 matching lines @@
     return create(string, length);
 }
 
 bool StringImpl::containsOnlyWhitespace()
 {
     // FIXME: The definition of whitespace here includes a number of characters
     // that are not whitespace from the point of view of RenderText; I wonder if
     // that's a problem in practice.
     if (is8Bit()) {
         for (unsigned i = 0; i < m_length; ++i) {
-            UChar c = m_data8[i];
+            UChar c = characters8()[i];
             if (!isASCIISpace(c))
                 return false;
         }
 
         return true;
     }
 
     for (unsigned i = 0; i < m_length; ++i) {
-        UChar c = m_data16[i];
+        UChar c = characters16()[i];
         if (!isASCIISpace(c))
             return false;
     }
     return true;
 }
 
 PassRefPtr<StringImpl> StringImpl::substring(unsigned start, unsigned length)
 {
     if (start >= m_length)
         return empty();
     unsigned maxLength = m_length - start;
     if (length >= maxLength) {
         if (!start)
             return this;
         length = maxLength;
     }
     if (is8Bit())
-        return create(m_data8 + start, length);
+        return create(characters8() + start, length);
 
-    return create(m_data16 + start, length);
+    return create(characters16() + start, length);
 }
 
 UChar32 StringImpl::characterStartingAt(unsigned i)
 {
     if (is8Bit())
-        return m_data8[i];
-    if (U16_IS_SINGLE(m_data16[i]))
-        return m_data16[i];
-    if (i + 1 < m_length && U16_IS_LEAD(m_data16[i]) && U16_IS_TRAIL(m_data16[i + 1]))
-        return U16_GET_SUPPLEMENTARY(m_data16[i], m_data16[i + 1]);
+        return characters8()[i];
+    if (U16_IS_SINGLE(characters16()[i]))
+        return characters16()[i];
+    if (i + 1 < m_length && U16_IS_LEAD(characters16()[i]) && U16_IS_TRAIL(characters16()[i + 1]))
+        return U16_GET_SUPPLEMENTARY(characters16()[i], characters16()[i + 1]);
     return 0;
 }
 
 PassRefPtr<StringImpl> StringImpl::lower()
 {
     // Note: This is a hot function in the Dromaeo benchmark, specifically the
     // no-op code path up through the first 'return' statement.
 
     // First scan the string for uppercase and non-ASCII characters:
     bool noUpper = true;
     UChar ored = 0;
     if (is8Bit()) {
-        const LChar* end = m_data8 + m_length;
-        for (const LChar* chp = m_data8; chp != end; ++chp) {
+        const LChar* end = characters8() + m_length;
+        for (const LChar* chp = characters8(); chp != end; ++chp) {
             if (UNLIKELY(isASCIIUpper(*chp)))
                 noUpper = false;
             ored |= *chp;
         }
         // Nothing to do if the string is all ASCII with no uppercase.
         if (noUpper && !(ored & ~0x7F))
             return this;
 
         RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<int32_t>::max()));
         int32_t length = m_length;
 
         LChar* data8;
         RefPtr<StringImpl> newImpl = createUninitialized(length, data8);
 
         if (!(ored & ~0x7F)) {
             for (int32_t i = 0; i < length; ++i)
-                data8[i] = toASCIILower(m_data8[i]);
+                data8[i] = toASCIILower(characters8()[i]);
 
             return newImpl.release();
         }
 
         // Do a slower implementation for cases that include non-ASCII Latin-1 characters.
         for (int32_t i = 0; i < length; ++i)
-            data8[i] = static_cast<LChar>(Unicode::toLower(m_data8[i]));
+            data8[i] = static_cast<LChar>(Unicode::toLower(characters8()[i]));
 
         return newImpl.release();
     }
 
-    const UChar *end = m_data16 + m_length;
-    for (const UChar* chp = m_data16; chp != end; ++chp) {
+    const UChar* end = characters16() + m_length;
+    for (const UChar* chp = characters16(); chp != end; ++chp) {
         if (UNLIKELY(isASCIIUpper(*chp)))
             noUpper = false;
         ored |= *chp;
     }
     // Nothing to do if the string is all ASCII with no uppercase.
     if (noUpper && !(ored & ~0x7F))
         return this;
 
     RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<int32_t>::max()));
     int32_t length = m_length;
 
     if (!(ored & ~0x7F)) {
         UChar* data16;
         RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
 
         for (int32_t i = 0; i < length; ++i) {
-            UChar c = m_data16[i];
+            UChar c = characters16()[i];
             data16[i] = toASCIILower(c);
         }
         return newImpl.release();
     }
 
     // Do a slower implementation for cases that include non-ASCII characters.
     UChar* data16;
     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
 
     bool error;
-    int32_t realLength = Unicode::toLower(data16, length, m_data16, m_length, &error);
+    int32_t realLength = Unicode::toLower(data16, length, characters16(), m_length, &error);
     if (!error && realLength == length)
         return newImpl.release();
 
     newImpl = createUninitialized(realLength, data16);
-    Unicode::toLower(data16, realLength, m_data16, m_length, &error);
+    Unicode::toLower(data16, realLength, characters16(), m_length, &error);
     if (error)
         return this;
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::upper()
 {
     // This function could be optimized for no-op cases the way lower() is,
     // but in empirical testing, few actual calls to upper() are no-ops, so
     // it wouldn't be worth the extra time for pre-scanning.
 
     RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<int32_t>::max()));
     int32_t length = m_length;
 
     if (is8Bit()) {
         LChar* data8;
         RefPtr<StringImpl> newImpl = createUninitialized(m_length, data8);
 
         // Do a faster loop for the case where all the characters are ASCII.
         LChar ored = 0;
         for (int i = 0; i < length; ++i) {
-            LChar c = m_data8[i];
+            LChar c = characters8()[i];
             ored |= c;
             data8[i] = toASCIIUpper(c);
         }
         if (!(ored & ~0x7F))
             return newImpl.release();
 
         // Do a slower implementation for cases that include non-ASCII Latin-1 characters.
         int numberSharpSCharacters = 0;
 
         // There are two special cases.
         //  1. latin-1 characters when converted to upper case are 16 bit characters.
         //  2. Lower case sharp-S converts to "SS" (two characters)
         for (int32_t i = 0; i < length; ++i) {
-            LChar c = m_data8[i];
+            LChar c = characters8()[i];
             if (UNLIKELY(c == smallLetterSharpS))
                 ++numberSharpSCharacters;
             UChar upper = Unicode::toUpper(c);
             if (UNLIKELY(upper > 0xff)) {
                 // Since this upper-cased character does not fit in an 8-bit string, we need to take the 16-bit path.
                 goto upconvert;
             }
             data8[i] = static_cast<LChar>(upper);
         }
 
         if (!numberSharpSCharacters)
             return newImpl.release();
 
         // We have numberSSCharacters sharp-s characters, but none of the other special characters.
         newImpl = createUninitialized(m_length + numberSharpSCharacters, data8);
 
         LChar* dest = data8;
 
         for (int32_t i = 0; i < length; ++i) {
-            LChar c = m_data8[i];
+            LChar c = characters8()[i];
             if (c == smallLetterSharpS) {
                 *dest++ = 'S';
                 *dest++ = 'S';
             } else
                 *dest++ = static_cast<LChar>(Unicode::toUpper(c));
         }
 
         return newImpl.release();
     }
 
@@ skipping 57 matching lines @@
     RELEASE_ASSERT(m_length <= static_cast<unsigned>(numeric_limits<int32_t>::max()));
     int32_t length = m_length;
 
     if (is8Bit()) {
         // Do a faster loop for the case where all the characters are ASCII.
         LChar* data;
         RefPtr <StringImpl>newImpl = createUninitialized(m_length, data);
         LChar ored = 0;
 
         for (int32_t i = 0; i < length; ++i) {
-            LChar c = m_data8[i];
+            LChar c = characters8()[i];
             data[i] = toASCIILower(c);
             ored |= c;
         }
 
         if (!(ored & ~0x7F))
             return newImpl.release();
 
         // Do a slower implementation for cases that include non-ASCII Latin-1 characters.
         for (int32_t i = 0; i < length; ++i)
-            data[i] = static_cast<LChar>(Unicode::toLower(m_data8[i]));
+            data[i] = static_cast<LChar>(Unicode::toLower(characters8()[i]));
 
         return newImpl.release();
     }
 
     // Do a faster loop for the case where all the characters are ASCII.
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
     UChar ored = 0;
     for (int32_t i = 0; i < length; ++i) {
-        UChar c = m_data16[i];
+        UChar c = characters16()[i];
         ored |= c;
         data[i] = toASCIILower(c);
     }
     if (!(ored & ~0x7F))
         return newImpl.release();
 
     // Do a slower implementation for cases that include non-ASCII characters.
     bool error;
-    int32_t realLength = Unicode::foldCase(data, length, m_data16, m_length, &error);
+    int32_t realLength = Unicode::foldCase(data, length, characters16(), m_length, &error);
     if (!error && realLength == length)
         return newImpl.release();
     newImpl = createUninitialized(realLength, data);
-    Unicode::foldCase(data, realLength, m_data16, m_length, &error);
+    Unicode::foldCase(data, realLength, characters16(), m_length, &error);
     if (error)
         return this;
     return newImpl.release();
 }
 
 template <class UCharPredicate>
 inline PassRefPtr<StringImpl> StringImpl::stripMatchedCharacters(UCharPredicate predicate)
 {
     if (!m_length)
         return empty();
 
     unsigned start = 0;
     unsigned end = m_length - 1;
 
     // skip white space from start
-    while (start <= end && predicate(is8Bit() ? m_data8[start] : m_data16[start]))
+    while (start <= end && predicate(is8Bit() ? characters8()[start] : characters16()[start]))
         ++start;
 
     // only white space
     if (start > end)
         return empty();
 
     // skip white space from end
-    while (end && predicate(is8Bit() ? m_data8[end] : m_data16[end]))
+    while (end && predicate(is8Bit() ? characters8()[end] : characters16()[end]))
         --end;
 
     if (!start && end == m_length - 1)
         return this;
     if (is8Bit())
-        return create(m_data8 + start, end + 1 - start);
-    return create(m_data16 + start, end + 1 - start);
+        return create(characters8() + start, end + 1 - start);
+    return create(characters16() + start, end + 1 - start);
 }
 
 class UCharPredicate {
 public:
     inline UCharPredicate(CharacterMatchFunctionPtr function): m_function(function) { }
 
     inline bool operator()(UChar ch) const
     {
         return m_function(ch);
     }
@@ skipping 636 matching lines @@
     unsigned startOffset = length() - matchLength;
     return equalInner(this, startOffset, matchString, matchLength, caseSensitive);
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar oldC, UChar newC)
 {
     if (oldC == newC)
         return this;
     unsigned i;
     for (i = 0; i != m_length; ++i) {
-        UChar c = is8Bit() ? m_data8[i] : m_data16[i];
+        UChar c = is8Bit() ? characters8()[i] : characters16()[i];
         if (c == oldC)
             break;
     }
     if (i == m_length)
         return this;
 
     if (is8Bit()) {
         if (oldC > 0xff)
             // Looking for a 16 bit char in an 8 bit string, we're done.
             return this;
 
         if (newC <= 0xff) {
             LChar* data;
             LChar oldChar = static_cast<LChar>(oldC);
             LChar newChar = static_cast<LChar>(newC);
 
             RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
 
             for (i = 0; i != m_length; ++i) {
-                LChar ch = m_data8[i];
+                LChar ch = characters8()[i];
                 if (ch == oldChar)
                     ch = newChar;
                 data[i] = ch;
             }
             return newImpl.release();
         }
 
         // There is the possibility we need to up convert from 8 to 16 bit,
         // create a 16 bit string for the result.
         UChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
 
         for (i = 0; i != m_length; ++i) {
-            UChar ch = m_data8[i];
+            UChar ch = characters8()[i];
             if (ch == oldC)
                 ch = newC;
             data[i] = ch;
         }
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data);
 
     for (i = 0; i != m_length; ++i) {
-        UChar ch = m_data16[i];
+        UChar ch = characters16()[i];
         if (ch == oldC)
             ch = newC;
         data[i] = ch;
     }
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(unsigned position, unsigned lengthToReplace, StringImpl* str)
 {
     position = min(position, length());
     lengthToReplace = min(lengthToReplace, length() - position);
     unsigned lengthToInsert = str ? str->length() : 0;
     if (!lengthToReplace && !lengthToInsert)
         return this;
 
     RELEASE_ASSERT((length() - lengthToReplace) < (numeric_limits<unsigned>::max() - lengthToInsert));
 
     if (is8Bit() && (!str || str->is8Bit())) {
         LChar* data;
         RefPtr<StringImpl> newImpl =
         createUninitialized(length() - lengthToReplace + lengthToInsert, data);
-        memcpy(data, m_data8, position * sizeof(LChar));
+        memcpy(data, characters8(), position * sizeof(LChar));
         if (str)
-            memcpy(data + position, str->m_data8, lengthToInsert * sizeof(LChar));
-        memcpy(data + position + lengthToInsert, m_data8 + position + lengthToReplace,
+            memcpy(data + position, str->characters8(), lengthToInsert * sizeof(LChar));
+        memcpy(data + position + lengthToInsert, characters8() + position + lengthToReplace,
                (length() - position - lengthToReplace) * sizeof(LChar));
         return newImpl.release();
     }
     UChar* data;
     RefPtr<StringImpl> newImpl =
         createUninitialized(length() - lengthToReplace + lengthToInsert, data);
     if (is8Bit())
         for (unsigned i = 0; i < position; ++i)
-            data[i] = m_data8[i];
+            data[i] = characters8()[i];
     else
-        memcpy(data, m_data16, position * sizeof(UChar));
+        memcpy(data, characters16(), position * sizeof(UChar));
     if (str) {
         if (str->is8Bit())
             for (unsigned i = 0; i < lengthToInsert; ++i)
-                data[i + position] = str->m_data8[i];
+                data[i + position] = str->characters8()[i];
         else
-            memcpy(data + position, str->m_data16, lengthToInsert * sizeof(UChar));
+            memcpy(data + position, str->characters16(), lengthToInsert * sizeof(UChar));
     }
     if (is8Bit()) {
         for (unsigned i = 0; i < length() - position - lengthToReplace; ++i)
-            data[i + position + lengthToInsert] = m_data8[i + position + lengthToReplace];
+            data[i + position + lengthToInsert] = characters8()[i + position + lengthToReplace];
     } else {
         memcpy(data + position + lengthToInsert, characters16() + position + lengthToReplace,
             (length() - position - lengthToReplace) * sizeof(UChar));
     }
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, StringImpl* replacement)
 {
     if (!replacement)
         return this;
 
     if (replacement->is8Bit())
-        return replace(pattern, replacement->m_data8, replacement->length());
+        return replace(pattern, replacement->characters8(), replacement->length());
 
-    return replace(pattern, replacement->m_data16, replacement->length());
+    return replace(pattern, replacement->characters16(), replacement->length());
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, const LChar* replacement, unsigned repStrLength)
 {
     ASSERT(replacement);
 
     size_t srcSegmentStart = 0;
     unsigned matchCount = 0;
 
     // Count the matches.
@@ skipping 19 matching lines @@
     unsigned srcSegmentLength;
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
 
     if (is8Bit()) {
         LChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
         while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
             srcSegmentLength = srcSegmentEnd - srcSegmentStart;
-            memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
+            memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
             dstOffset += srcSegmentLength;
             memcpy(data + dstOffset, replacement, repStrLength * sizeof(LChar));
             dstOffset += repStrLength;
             srcSegmentStart = srcSegmentEnd + 1;
         }
 
         srcSegmentLength = m_length - srcSegmentStart;
-        memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
+        memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
 
         ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
     while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
         srcSegmentLength = srcSegmentEnd - srcSegmentStart;
-        memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
+        memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
         dstOffset += srcSegmentLength;
         for (unsigned i = 0; i < repStrLength; ++i)
             data[i + dstOffset] = replacement[i];
 
         dstOffset += repStrLength;
         srcSegmentStart = srcSegmentEnd + 1;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
-    memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
+    memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
     ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(UChar pattern, const UChar* replacement, unsigned repStrLength)
 {
     ASSERT(replacement);
 
@@ skipping 24 matching lines @@
     srcSegmentStart = 0;
     unsigned dstOffset = 0;
 
     if (is8Bit()) {
         UChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
         while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
             srcSegmentLength = srcSegmentEnd - srcSegmentStart;
             for (unsigned i = 0; i < srcSegmentLength; ++i)
-                data[i + dstOffset] = m_data8[i + srcSegmentStart];
+                data[i + dstOffset] = characters8()[i + srcSegmentStart];
 
             dstOffset += srcSegmentLength;
             memcpy(data + dstOffset, replacement, repStrLength * sizeof(UChar));
 
             dstOffset += repStrLength;
             srcSegmentStart = srcSegmentEnd + 1;
         }
 
         srcSegmentLength = m_length - srcSegmentStart;
         for (unsigned i = 0; i < srcSegmentLength; ++i)
-            data[i + dstOffset] = m_data8[i + srcSegmentStart];
+            data[i + dstOffset] = characters8()[i + srcSegmentStart];
 
         ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
 
     while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
         srcSegmentLength = srcSegmentEnd - srcSegmentStart;
-        memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
+        memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
         dstOffset += srcSegmentLength;
         memcpy(data + dstOffset, replacement, repStrLength * sizeof(UChar));
 
         dstOffset += repStrLength;
         srcSegmentStart = srcSegmentEnd + 1;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
-    memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
+    memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
 
     ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
     return newImpl.release();
 }
 
 PassRefPtr<StringImpl> StringImpl::replace(StringImpl* pattern, StringImpl* replacement)
 {
     if (!pattern || !replacement)
         return this;
@@ skipping 36 matching lines @@
     // 1. This and replacement are both 8 bit.
     // 2. This and replacement are both 16 bit.
     // 3. This is 8 bit and replacement is 16 bit.
     // 4. This is 16 bit and replacement is 8 bit.
     if (srcIs8Bit && replacementIs8Bit) {
         // Case 1
         LChar* data;
         RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
         while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
             srcSegmentLength = srcSegmentEnd - srcSegmentStart;
-            memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
+            memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
             dstOffset += srcSegmentLength;
-            memcpy(data + dstOffset, replacement->m_data8, repStrLength * sizeof(LChar));
+            memcpy(data + dstOffset, replacement->characters8(), repStrLength * sizeof(LChar));
             dstOffset += repStrLength;
             srcSegmentStart = srcSegmentEnd + patternLength;
         }
 
         srcSegmentLength = m_length - srcSegmentStart;
-        memcpy(data + dstOffset, m_data8 + srcSegmentStart, srcSegmentLength * sizeof(LChar));
+        memcpy(data + dstOffset, characters8() + srcSegmentStart, srcSegmentLength * sizeof(LChar));
 
         ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
         return newImpl.release();
     }
 
     UChar* data;
     RefPtr<StringImpl> newImpl = createUninitialized(newSize, data);
     while ((srcSegmentEnd = find(pattern, srcSegmentStart)) != notFound) {
         srcSegmentLength = srcSegmentEnd - srcSegmentStart;
         if (srcIs8Bit) {
             // Case 3.
             for (unsigned i = 0; i < srcSegmentLength; ++i)
-                data[i + dstOffset] = m_data8[i + srcSegmentStart];
+                data[i + dstOffset] = characters8()[i + srcSegmentStart];
         } else {
             // Case 2 & 4.
-            memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
+            memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
         }
         dstOffset += srcSegmentLength;
         if (replacementIs8Bit) {
             // Cases 2 & 3.
             for (unsigned i = 0; i < repStrLength; ++i)
-                data[i + dstOffset] = replacement->m_data8[i];
+                data[i + dstOffset] = replacement->characters8()[i];
         } else {
             // Case 4
-            memcpy(data + dstOffset, replacement->m_data16, repStrLength * sizeof(UChar));
+            memcpy(data + dstOffset, replacement->characters16(), repStrLength * sizeof(UChar));
         }
         dstOffset += repStrLength;
         srcSegmentStart = srcSegmentEnd + patternLength;
     }
 
     srcSegmentLength = m_length - srcSegmentStart;
     if (srcIs8Bit) {
         // Case 3.
         for (unsigned i = 0; i < srcSegmentLength; ++i)
-            data[i + dstOffset] = m_data8[i + srcSegmentStart];
+            data[i + dstOffset] = characters8()[i + srcSegmentStart];
     } else {
         // Cases 2 & 4.
-        memcpy(data + dstOffset, m_data16 + srcSegmentStart, srcSegmentLength * sizeof(UChar));
+        memcpy(data + dstOffset, characters16() + srcSegmentStart, srcSegmentLength * sizeof(UChar));
     }
 
     ASSERT(dstOffset + srcSegmentLength == newImpl->length());
 
     return newImpl.release();
 }
 
 static inline bool stringImplContentEqual(const StringImpl* a, const StringImpl* b)
 {
     unsigned aLength = a->length();
@@ skipping 185 matching lines @@
     if (!a && b && !b->length())
         return true;
     if (!b && a && !a->length())
         return true;
     return equal(a, b);
 }
 
 WTF::Unicode::Direction StringImpl::defaultWritingDirection(bool* hasStrongDirectionality)
 {
     for (unsigned i = 0; i < m_length; ++i) {
-        WTF::Unicode::Direction charDirection = WTF::Unicode::direction(is8Bit() ? m_data8[i] : m_data16[i]);
+        WTF::Unicode::Direction charDirection = WTF::Unicode::direction(is8Bit() ? characters8()[i] : characters16()[i]);
         if (charDirection == WTF::Unicode::LeftToRight) {
             if (hasStrongDirectionality)
                 *hasStrongDirectionality = true;
             return WTF::Unicode::LeftToRight;
         }
         if (charDirection == WTF::Unicode::RightToLeft || charDirection == WTF::Unicode::RightToLeftArabic) {
             if (hasStrongDirectionality)
                 *hasStrongDirectionality = true;
             return WTF::Unicode::RightToLeft;
         }
     }
     if (hasStrongDirectionality)
         *hasStrongDirectionality = false;
     return WTF::Unicode::LeftToRight;
 }
 
 size_t StringImpl::sizeInBytes() const
 {
     size_t size = length();
     if (!is8Bit())
         size *= 2;
     return size + sizeof(*this);
 }
 
 } // namespace WTF