Changeset 152356 in webkit


Ignore:
Timestamp:
Jul 3, 2013 8:38:49 AM (11 years ago)
Author:
mikhail.pozdnyakov@intel.com
Message:

Remove code duplication from StringImpl create()/reallocate() methods
​https://bugs.webkit.org/show_bug.cgi?id=118355

Reviewed by Anders Carlsson.

StringImpl create()/reallocate() methods accepting LChar and UChar used to have
duplicated code. The code duplication is removed now via used templates.

  • wtf/text/StringImpl.cpp:

(WTF::StringImpl::constructInternal):
(WTF::LChar):
(WTF::StringImpl::createUninitializedInternal):
(WTF::StringImpl::createUninitialized):
(WTF::StringImpl::reallocateInternal):
(WTF::StringImpl::reallocate):
(WTF::StringImpl::createInternal):
(WTF::StringImpl::create):

  • wtf/text/StringImpl.h:
Location:
trunk/Source/WTF
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WTF/ChangeLog

    r152349 r152356  
     12013-07-03  Mikhail Pozdnyakov  <mikhail.pozdnyakov@intel.com>
     2
     3        Remove code duplication from StringImpl create()/reallocate() methods
     4        https://bugs.webkit.org/show_bug.cgi?id=118355
     5
     6        Reviewed by Anders Carlsson.
     7
     8        StringImpl create()/reallocate() methods accepting LChar and UChar used to have
     9        duplicated code. The code duplication is removed now via used templates.
     10
     11        * wtf/text/StringImpl.cpp:
     12        (WTF::StringImpl::constructInternal):
     13        (WTF::LChar):
     14        (WTF::StringImpl::createUninitializedInternal):
     15        (WTF::StringImpl::createUninitialized):
     16        (WTF::StringImpl::reallocateInternal):
     17        (WTF::StringImpl::reallocate):
     18        (WTF::StringImpl::createInternal):
     19        (WTF::StringImpl::create):
     20        * wtf/text/StringImpl.h:
     21
    1222013-07-03  Csaba Osztrogonác  <ossy@webkit.org>
    223

  • trunk/Source/WTF/wtf/text/StringImpl.cpp

    r152201 r152356  
    183183}
    184184
    185 PassRefPtr<StringImpl> StringImpl::createUninitialized(unsigned length, LChar*& data)
     185template <typename CharType>
     186inline PassRefPtr<StringImpl> StringImpl::constructInternal(StringImpl* stringImpl, unsigned length)
     187{
     188    return adoptRef(new (NotNull, stringImpl) StringImpl(length));
     189}
     190
     191template <>
     192inline PassRefPtr<StringImpl> StringImpl::constructInternal<LChar>(StringImpl* stringImpl, unsigned length)
     193{
     194    return adoptRef(new (NotNull, stringImpl) StringImpl(length, Force8BitConstructor));
     195}
     196
     197template <typename CharType>
     198inline PassRefPtr<StringImpl> StringImpl::createUninitializedInternal(unsigned length, CharType*& data)
    186199{
    187200    if (!length) {
    … …  
    193206    // struct as well as the data which it contains. This removes one
    194207    // heap allocation from this call.
    195     if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(LChar)))
     208    if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(CharType)))
    196209        CRASH();
    197     size_t size = sizeof(StringImpl) + length * sizeof(LChar);
     210    size_t size = sizeof(StringImpl) + length * sizeof(CharType);
    198211    StringImpl* string = static_cast<StringImpl*>(fastMalloc(size));
    199212
    200     data = reinterpret_cast<LChar*>(string + 1);
    201     return adoptRef(new (NotNull, string) StringImpl(length, Force8BitConstructor));
     213    data = reinterpret_cast<CharType*>(string + 1);
     214    return constructInternal<CharType>(string, length);
     215}
     216
     217PassRefPtr<StringImpl> StringImpl::createUninitialized(unsigned length, LChar*& data)
     218{
     219    return createUninitializedInternal(length, data);
    202220}
    203221
    204222PassRefPtr<StringImpl> StringImpl::createUninitialized(unsigned length, UChar*& data)
    205223{
     224    return createUninitializedInternal(length, data);
     225}
     226
     227template <typename CharType>
     228inline PassRefPtr<StringImpl> StringImpl::reallocateInternal(PassRefPtr<StringImpl> originalString, unsigned length, CharType*& data)
     229{
     230    ASSERT(originalString->is8Bit());
     231    ASSERT(originalString->hasOneRef());
     232    ASSERT(originalString->bufferOwnership() == BufferInternal);
     233
    206234    if (!length) {
    207235        data = 0;
    … …  
    209237    }
    210238
    211     // Allocate a single buffer large enough to contain the StringImpl
    212     // struct as well as the data which it contains. This removes one
    213     // heap allocation from this call.
    214     if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(UChar)))
     239    // Same as createUninitialized() except here we use fastRealloc.
     240    if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(CharType)))
    215241        CRASH();
    216     size_t size = sizeof(StringImpl) + length * sizeof(UChar);
    217     StringImpl* string = static_cast<StringImpl*>(fastMalloc(size));
    218 
    219     data = reinterpret_cast<UChar*>(string + 1);
    220     return adoptRef(new (NotNull, string) StringImpl(length));
    221 }
    222 
    223 PassRefPtr<StringImpl> StringImpl::reallocate(PassRefPtr<StringImpl> originalString, unsigned length, LChar*& data)
    224 {
    225     ASSERT(originalString->is8Bit());
    226     ASSERT(originalString->hasOneRef());
    227     ASSERT(originalString->bufferOwnership() == BufferInternal);
    228 
    229     if (!length) {
    230         data = 0;
    231         return empty();
    232     }
    233 
    234     // Same as createUninitialized() except here we use fastRealloc.
    235     if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(LChar)))
    236         CRASH();
    237     size_t size = sizeof(StringImpl) + length * sizeof(LChar);
     242    size_t size = sizeof(StringImpl) + length * sizeof(CharType);
    238243    originalString->~StringImpl();
    239244    StringImpl* string = static_cast<StringImpl*>(fastRealloc(originalString.leakRef(), size));
    240245
    241     data = reinterpret_cast<LChar*>(string + 1);
    242     return adoptRef(new (NotNull, string) StringImpl(length, Force8BitConstructor));
     246    data = reinterpret_cast<CharType*>(string + 1);
     247    return constructInternal<CharType>(string, length);
     248}
     249
     250PassRefPtr<StringImpl> StringImpl::reallocate(PassRefPtr<StringImpl> originalString, unsigned length, LChar*& data)
     251{
     252    return reallocateInternal(originalString, length, data);
    243253}
    244254
    245255PassRefPtr<StringImpl> StringImpl::reallocate(PassRefPtr<StringImpl> originalString, unsigned length, UChar*& data)
    246256{
    247     ASSERT(!originalString->is8Bit());
    248     ASSERT(originalString->hasOneRef());
    249     ASSERT(originalString->bufferOwnership() == BufferInternal);
    250 
    251     if (!length) {
    252         data = 0;
    253         return empty();
    254     }
    255 
    256     // Same as createUninitialized() except here we use fastRealloc.
    257     if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(UChar)))
    258         CRASH();
    259     size_t size = sizeof(StringImpl) + length * sizeof(UChar);
    260     originalString->~StringImpl();
    261     StringImpl* string = static_cast<StringImpl*>(fastRealloc(originalString.leakRef(), size));
    262 
    263     data = reinterpret_cast<UChar*>(string + 1);
    264     return adoptRef(new (NotNull, string) StringImpl(length));
    265 }
    266 
    267 PassRefPtr<StringImpl> StringImpl::create(const UChar* characters, unsigned length)
     257    return reallocateInternal(originalString, length, data);
     258}
     259
     260template <typename CharType>
     261inline PassRefPtr<StringImpl> StringImpl::createInternal(const CharType* characters, unsigned length)
    268262{
    269263    if (!characters || !length)
    270264        return empty();
    271265
    272     UChar* data;
     266    CharType* data;
    273267    RefPtr<StringImpl> string = createUninitialized(length, data);
    274     memcpy(data, characters, length * sizeof(UChar));
     268    memcpy(data, characters, length * sizeof(CharType));
    275269    return string.release();
    276270}
    277271
     272PassRefPtr<StringImpl> StringImpl::create(const UChar* characters, unsigned length)
     273{
     274    return createInternal(characters, length);
     275}
     276
    278277PassRefPtr<StringImpl> StringImpl::create(const LChar* characters, unsigned length)
    279278{
    280     if (!characters || !length)
    281         return empty();
    282 
    283     LChar* data;
    284     RefPtr<StringImpl> string = createUninitialized(length, data);
    285     memcpy(data, characters, length * sizeof(LChar));
    286     return string.release();
     279    return createInternal(characters, length);
    287280}
    288281

  • trunk/Source/WTF/wtf/text/StringImpl.h

    r152201 r152356  
    771771    template <class UCharPredicate> PassRefPtr<StringImpl> stripMatchedCharacters(UCharPredicate);
    772772    template <typename CharType, class UCharPredicate> PassRefPtr<StringImpl> simplifyMatchedCharactersToSpace(UCharPredicate);
     773    template <typename CharType> static PassRefPtr<StringImpl> constructInternal(StringImpl*, unsigned);
     774    template <typename CharType> static PassRefPtr<StringImpl> createUninitializedInternal(unsigned, CharType*&);
     775    template <typename CharType> static PassRefPtr<StringImpl> reallocateInternal(PassRefPtr<StringImpl>, unsigned, CharType*&);
     776    template <typename CharType> static PassRefPtr<StringImpl> createInternal(const CharType*, unsigned);
    773777    WTF_EXPORT_STRING_API NEVER_INLINE const UChar* getData16SlowCase() const;
    774778    WTF_EXPORT_PRIVATE NEVER_INLINE unsigned hashSlowCase() const;
Note: See TracChangeset for help on using the changeset viewer.