Changeset 201782 in webkit


Ignore:
Timestamp:
Jun 7, 2016 6:31:17 PM (8 years ago)
Author:
Keith Rollin
Message:

Remove all uses of PassRefPtr in WTF
​https://bugs.webkit.org/show_bug.cgi?id=157596
<rdar://problem/26234391>

Reviewed by Chris Dumez.

Source/JavaScriptCore:

Update calls to interfaces that no longer take or return PassRefPtrs.

  • runtime/JSString.cpp:

(JSC::JSRopeString::resolveRope):

  • runtime/JSString.h:

(JSC::JSString::JSString):
(JSC::jsSubstring):

  • runtime/PrivateName.h:

(JSC::PrivateName::PrivateName):

  • runtime/SmallStrings.cpp:

(JSC::SmallStringsStorage::SmallStringsStorage):

  • runtime/StringConstructor.cpp:

(JSC::stringFromCharCodeSlowCase):

  • runtime/StringPrototype.cpp:

(JSC::jsSpliceSubstrings):
(JSC::jsSpliceSubstringsWithSeparators):
(JSC::replaceUsingStringSearch):
(JSC::repeatCharacter):
(JSC::stringProtoFuncFontsize):
(JSC::stringProtoFuncLink):
(JSC::normalize):

Source/WebCore:

Update calls to interfaces that no longer take or return PassRefPtrs.

No new tests: no new functionality so changes are covered by existing
tests.

  • css/CSSPrimitiveValue.cpp:

(WebCore::CSSPrimitiveValue::formatNumberValue):

  • dom/Document.cpp:

(WebCore::Document::displayStringModifiedByEncoding):

  • xml/XPathGrammar.y:

Source/WTF:

Remove/update most interfaces that take or return PassRefPtrs.
Remaining references include those in non-Cocoa implementations and
those required for continued compatibility with modules that still use
PassRefPtrs (specifically: Forward.h, RefPtr interoperability,
SizeLimits.h, WorkQueue (Windows) DispatchQueueEfl,
DispatchWorkItemEfl, and PassRefPtr itself).

Update calls to interfaces that no longer take or return PassRefPtrs.

Update adoptRef(T*) to return a RefPtr instead of a PassRefPtr and
move it to RefPtr.h from PassRefPtr.h.

  • wtf/MetaAllocator.cpp:

(WTF::MetaAllocator::allocate):

  • wtf/MetaAllocator.h:
  • wtf/ParallelJobsGeneric.h:

(WTF::ParallelEnvironment::ThreadPrivate::create):

  • wtf/text/AtomicStringImpl.cpp:

(WTF::HashAndUTF8CharactersTranslator::translate):
(WTF::SubstringTranslator::translate):

  • wtf/text/CString.cpp:

(WTF::CStringBuffer::createUninitialized):

  • wtf/text/CString.h:
  • wtf/text/StringBuilder.cpp:

(WTF::StringBuilder::reifyString):
(WTF::StringBuilder::resize):
(WTF::StringBuilder::reallocateBuffer<LChar>):
(WTF::StringBuilder::reallocateBuffer<UChar>):

  • wtf/text/StringImpl.cpp:

(WTF::StringImpl::reallocateInternal):
(WTF::StringImpl::reallocate):
(WTF::StringImpl::create8BitIfPossible):
(WTF::StringImpl::createSymbol):
(WTF::StringImpl::createNullSymbol):
(WTF::StringImpl::convertToLowercaseWithoutLocale):
(WTF::StringImpl::convertToUppercaseWithoutLocale):
(WTF::StringImpl::convertToLowercaseWithLocale):
(WTF::StringImpl::convertToUppercaseWithLocale):
(WTF::StringImpl::convertASCIICase):

  • wtf/text/StringImpl.h:

(WTF::StringImpl::StringImpl):
(WTF::StringImpl::createSubstringSharingImpl):
(WTF::StringImpl::tryCreateUninitialized):
(WTF::StringImpl::extractFoldedStringInSymbol):

  • wtf/text/SymbolRegistry.cpp:

(WTF::SymbolRegistry::symbolForKey):

  • wtf/text/WTFString.cpp:

(WTF::String::substringSharingImpl):

  • wtf/text/WTFString.h:

(WTF::String::String): Deleted.

  • wtf/text/cf/StringImplCF.cpp:

Tools:

Update calls to interfaces that no longer take or return PassRefPtrs.

  • TestWebKitAPI/Tests/WTF/StringImpl.cpp:

(TestWebKitAPI::stringFromUTF8):
(TestWebKitAPI::TEST):

Location:
trunk
Files:
34 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/ChangeLog

    r201776 r201782  
     12016-06-07  Keith Rollin  <krollin@apple.com>
     2
     3        Remove all uses of PassRefPtr in WTF
     4        https://bugs.webkit.org/show_bug.cgi?id=157596
     5        <rdar://problem/26234391>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Update calls to interfaces that no longer take or return PassRefPtrs.
     10
     11        * runtime/JSString.cpp:
     12        (JSC::JSRopeString::resolveRope):
     13        * runtime/JSString.h:
     14        (JSC::JSString::JSString):
     15        (JSC::jsSubstring):
     16        * runtime/PrivateName.h:
     17        (JSC::PrivateName::PrivateName):
     18        * runtime/SmallStrings.cpp:
     19        (JSC::SmallStringsStorage::SmallStringsStorage):
     20        * runtime/StringConstructor.cpp:
     21        (JSC::stringFromCharCodeSlowCase):
     22        * runtime/StringPrototype.cpp:
     23        (JSC::jsSpliceSubstrings):
     24        (JSC::jsSpliceSubstringsWithSeparators):
     25        (JSC::replaceUsingStringSearch):
     26        (JSC::repeatCharacter):
     27        (JSC::stringProtoFuncFontsize):
     28        (JSC::stringProtoFuncLink):
     29        (JSC::normalize):
     30
    1312016-06-07  Saam barati  <sbarati@apple.com>
    232

  • trunk/Source/JavaScriptCore/jit/GCAwareJITStubRoutine.cpp

    r199275 r201782  
    3636#include "SlotVisitor.h"
    3737#include "Structure.h"
     38#include <wtf/RefPtr.h>
    3839
    3940namespace JSC {
    … …  
    145146    if (codeBlockForExceptionHandlers) {
    146147        RELEASE_ASSERT(JITCode::isOptimizingJIT(codeBlockForExceptionHandlers->jitType()));
    147         return static_pointer_cast<JITStubRoutine>(
    148             adoptRef(new GCAwareJITStubRoutineWithExceptionHandler(code, vm, owner, cells, codeBlockForExceptionHandlers, exceptionHandlerCallSiteIndex)));
     148        return adoptRef(new GCAwareJITStubRoutineWithExceptionHandler(code, vm, owner, cells, codeBlockForExceptionHandlers, exceptionHandlerCallSiteIndex));
    149149    }
    150150
    151     if (cells.isEmpty()) {
    152         return static_pointer_cast<JITStubRoutine>(
    153             adoptRef(new GCAwareJITStubRoutine(code, vm)));
    154     }
     151    if (cells.isEmpty())
     152        return adoptRef(new GCAwareJITStubRoutine(code, vm));
    155153   
    156     return static_pointer_cast<JITStubRoutine>(
    157         adoptRef(new MarkingGCAwareJITStubRoutine(code, vm, owner, cells)));
     154    return adoptRef(new MarkingGCAwareJITStubRoutine(code, vm, owner, cells));
    158155}
    159156

  • trunk/Source/JavaScriptCore/runtime/JSString.cpp

    r197379 r201782  
    253253    if (is8Bit()) {
    254254        LChar* buffer;
    255         if (RefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
     255        if (auto newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
    256256            Heap::heap(this)->reportExtraMemoryAllocated(newImpl->cost());
    257             m_value = newImpl.release();
     257            m_value = WTFMove(newImpl);
    258258        } else {
    259259            outOfMemory(exec);
    … …  
    267267
    268268    UChar* buffer;
    269     if (RefPtr<StringImpl> newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
     269    if (auto newImpl = StringImpl::tryCreateUninitialized(m_length, buffer)) {
    270270        Heap::heap(this)->reportExtraMemoryAllocated(newImpl->cost());
    271         m_value = newImpl.release();
     271        m_value = WTFMove(newImpl);
    272272    } else {
    273273        outOfMemory(exec);

  • trunk/Source/JavaScriptCore/runtime/JSString.h

    r200288 r201782  
    9494        : JSCell(vm, vm.stringStructure.get())
    9595        , m_flags(0)
    96         , m_value(value)
     96        , m_value(RefPtr<StringImpl>(value))
    9797    {
    9898    }
    … …  
    604604            return vm->smallStrings.singleCharacterString(c);
    605605    }
    606     return JSString::createHasOtherOwner(*vm, StringImpl::createSubstringSharingImpl(s.impl(), offset, length));
     606    return JSString::createHasOtherOwner(*vm, StringImpl::createSubstringSharingImpl(*s.impl(), offset, length));
    607607}
    608608

  • trunk/Source/JavaScriptCore/runtime/PrivateName.h

    r198168 r201782  
    4545    enum DescriptionTag { Description };
    4646    explicit PrivateName(DescriptionTag, const String& description)
    47         : m_uid(StringImpl::createSymbol(description.impl()))
     47        : m_uid(StringImpl::createSymbol(*description.impl()))
    4848    {
    4949    }

  • trunk/Source/JavaScriptCore/runtime/SmallStrings.cpp

    r191864 r201782  
    5555{
    5656    LChar* characterBuffer = 0;
    57     RefPtr<StringImpl> baseString = StringImpl::createUninitialized(singleCharacterStringCount, characterBuffer);
     57    auto baseString = StringImpl::createUninitialized(singleCharacterStringCount, characterBuffer);
    5858    for (unsigned i = 0; i < singleCharacterStringCount; ++i) {
    5959        characterBuffer[i] = i;
    60         m_reps[i] = AtomicStringImpl::add(PassRefPtr<StringImpl>(StringImpl::createSubstringSharingImpl(baseString, i, 1)).get());
     60        m_reps[i] = AtomicStringImpl::add(StringImpl::createSubstringSharingImpl(baseString.get(), i, 1).ptr());
    6161    }
    6262}

  • trunk/Source/JavaScriptCore/runtime/StringConstructor.cpp

    r201448 r201782  
    7171    unsigned length = exec->argumentCount();
    7272    UChar* buf;
    73     PassRefPtr<StringImpl> impl = StringImpl::createUninitialized(length, buf);
     73    auto impl = StringImpl::createUninitialized(length, buf);
    7474    for (unsigned i = 0; i < length; ++i)
    7575        buf[i] = static_cast<UChar>(exec->uncheckedArgument(i).toUInt32(exec));
    76     return jsString(exec, impl);
     76    return jsString(exec, WTFMove(impl));
    7777}
    7878

  • trunk/Source/JavaScriptCore/runtime/StringPrototype.cpp

    r201448 r201782  
    295295            return sourceVal;
    296296        // We could call String::substringSharingImpl(), but this would result in redundant checks.
    297         return jsString(exec, StringImpl::createSubstringSharingImpl(source.impl(), std::max(0, position), std::min(sourceSize, length)));
     297        return jsString(exec, StringImpl::createSubstringSharingImpl(*source.impl(), std::max(0, position), std::min(sourceSize, length)));
    298298    }
    299299
    … …  
    308308        LChar* buffer;
    309309        const LChar* sourceData = source.characters8();
    310         RefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(totalLength, buffer);
     310        auto impl = StringImpl::tryCreateUninitialized(totalLength, buffer);
    311311        if (!impl)
    312312            return throwOutOfMemoryError(exec);
    … …  
    320320        }
    321321
    322         return jsString(exec, impl.release());
     322        return jsString(exec, WTFMove(impl));
    323323    }
    324324
    … …  
    326326    const UChar* sourceData = source.characters16();
    327327
    328     RefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(totalLength, buffer);
     328    auto impl = StringImpl::tryCreateUninitialized(totalLength, buffer);
    329329    if (!impl)
    330330        return throwOutOfMemoryError(exec);
    … …  
    338338    }
    339339
    340     return jsString(exec, impl.release());
     340    return jsString(exec, WTFMove(impl));
    341341}
    342342
    … …  
    350350            return sourceVal;
    351351        // We could call String::substringSharingImpl(), but this would result in redundant checks.
    352         return jsString(exec, StringImpl::createSubstringSharingImpl(source.impl(), std::max(0, position), std::min(sourceSize, length)));
     352        return jsString(exec, StringImpl::createSubstringSharingImpl(*source.impl(), std::max(0, position), std::min(sourceSize, length)));
    353353    }
    354354
    … …  
    372372        const LChar* sourceData = source.characters8();
    373373
    374         RefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(totalLength.unsafeGet(), buffer);
     374        auto impl = StringImpl::tryCreateUninitialized(totalLength.unsafeGet(), buffer);
    375375        if (!impl)
    376376            return throwOutOfMemoryError(exec);
    … …  
    393393        }       
    394394
    395         return jsString(exec, impl.release());
     395        return jsString(exec, WTFMove(impl));
    396396    }
    397397
    398398    UChar* buffer;
    399     RefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(totalLength.unsafeGet(), buffer);
     399    auto impl = StringImpl::tryCreateUninitialized(totalLength.unsafeGet(), buffer);
    400400    if (!impl)
    401401        return throwOutOfMemoryError(exec);
    … …  
    424424    }
    425425
    426     return jsString(exec, impl.release());
     426    return jsString(exec, WTFMove(impl));
    427427}
    428428
    … …  
    723723
    724724    StringImpl* stringImpl = string.impl();
    725     String leftPart(StringImpl::createSubstringSharingImpl(stringImpl, 0, matchStart));
     725    String leftPart(StringImpl::createSubstringSharingImpl(*stringImpl, 0, matchStart));
    726726
    727727    size_t matchEnd = matchStart + searchString.impl()->length();
    … …  
    730730
    731731    size_t leftLength = stringImpl->length() - matchEnd;
    732     String rightPart(StringImpl::createSubstringSharingImpl(stringImpl, matchEnd, leftLength));
     732    String rightPart(StringImpl::createSubstringSharingImpl(*stringImpl, matchEnd, leftLength));
    733733    return JSValue::encode(JSC::jsString(exec, leftPart, middlePart, rightPart));
    734734}
    … …  
    752752{
    753753    CharacterType* buffer = nullptr;
    754     RefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(repeatCount, buffer);
     754    auto impl = StringImpl::tryCreateUninitialized(repeatCount, buffer);
    755755    if (!impl)
    756756        return throwOutOfMemoryError(exec);
    … …  
    758758    std::fill_n(buffer, repeatCount, character);
    759759
    760     return jsString(exec, impl.release());
     760    return jsString(exec, WTFMove(impl));
    761761}
    762762
    … …  
    765765{
    766766    CharacterType* buffer = nullptr;
    767     RefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(repeatCount, buffer);
     767    auto impl = StringImpl::tryCreateUninitialized(repeatCount, buffer);
    768768    if (!impl)
    769769        return throwOutOfMemoryError(&exec), nullptr;
    … …  
    771771    std::fill_n(buffer, repeatCount, character);
    772772
    773     return jsString(&exec, impl.release());
     773    return jsString(&exec, WTFMove(impl));
    774774}
    775775
    … …  
    15731573        // FIXME: Should we have an 8-bit version of this code path too? Or maybe only an 8-bit version?
    15741574        UChar* buffer;
    1575         PassRefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(bufferSize, buffer);
     1575        auto impl = StringImpl::tryCreateUninitialized(bufferSize, buffer);
    15761576        if (!impl)
    15771577            return JSValue::encode(jsUndefined());
    … …  
    15991599        buffer[20 + stringSize] = 't';
    16001600        buffer[21 + stringSize] = '>';
    1601         return JSValue::encode(jsNontrivialString(exec, impl));
     1601        return JSValue::encode(jsNontrivialString(exec, WTFMove(impl)));
    16021602    }
    16031603
    … …  
    16421642    // FIXME: Should we have an 8-bit version of this code path too? Or maybe only an 8-bit version?
    16431643    UChar* buffer;
    1644     PassRefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(bufferSize, buffer);
     1644    auto impl = StringImpl::tryCreateUninitialized(bufferSize, buffer);
    16451645    if (!impl)
    16461646        return JSValue::encode(jsUndefined());
    … …  
    16621662    buffer[13 + linkTextSize + stringSize] = 'a';
    16631663    buffer[14 + linkTextSize + stringSize] = '>';
    1664     return JSValue::encode(jsNontrivialString(exec, impl));
     1664    return JSValue::encode(jsNontrivialString(exec, WTFMove(impl)));
    16651665}
    16661666
    … …  
    18791879
    18801880    UChar* buffer = nullptr;
    1881     RefPtr<StringImpl> impl = StringImpl::tryCreateUninitialized(normalizedStringLength, buffer);
     1881    auto impl = StringImpl::tryCreateUninitialized(normalizedStringLength, buffer);
    18821882    if (!impl)
    18831883        return throwOutOfMemoryError(exec);
    … …  
    18881888        return throwTypeError(exec);
    18891889
    1890     return jsString(exec, impl.release());
     1890    return jsString(exec, WTFMove(impl));
    18911891}
    18921892

  • trunk/Source/WTF/ChangeLog

    r201756 r201782  
     12016-06-07  Keith Rollin  <krollin@apple.com>
     2
     3        Remove all uses of PassRefPtr in WTF
     4        https://bugs.webkit.org/show_bug.cgi?id=157596
     5        <rdar://problem/26234391>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Remove/update most interfaces that take or return PassRefPtrs.
     10        Remaining references include those in non-Cocoa implementations and
     11        those required for continued compatibility with modules that still use
     12        PassRefPtrs (specifically: Forward.h, RefPtr interoperability,
     13        SizeLimits.h, WorkQueue (Windows) DispatchQueueEfl,
     14        DispatchWorkItemEfl, and PassRefPtr itself).
     15
     16        Update calls to interfaces that no longer take or return PassRefPtrs.
     17
     18        Update adoptRef(T*) to return a RefPtr instead of a PassRefPtr and
     19        move it to RefPtr.h from PassRefPtr.h.
     20
     21        * wtf/MetaAllocator.cpp:
     22        (WTF::MetaAllocator::allocate):
     23        * wtf/MetaAllocator.h:
     24        * wtf/ParallelJobsGeneric.h:
     25        (WTF::ParallelEnvironment::ThreadPrivate::create):
     26        * wtf/text/AtomicStringImpl.cpp:
     27        (WTF::HashAndUTF8CharactersTranslator::translate):
     28        (WTF::SubstringTranslator::translate):
     29        * wtf/text/CString.cpp:
     30        (WTF::CStringBuffer::createUninitialized):
     31        * wtf/text/CString.h:
     32        * wtf/text/StringBuilder.cpp:
     33        (WTF::StringBuilder::reifyString):
     34        (WTF::StringBuilder::resize):
     35        (WTF::StringBuilder::reallocateBuffer<LChar>):
     36        (WTF::StringBuilder::reallocateBuffer<UChar>):
     37        * wtf/text/StringImpl.cpp:
     38        (WTF::StringImpl::reallocateInternal):
     39        (WTF::StringImpl::reallocate):
     40        (WTF::StringImpl::create8BitIfPossible):
     41        (WTF::StringImpl::createSymbol):
     42        (WTF::StringImpl::createNullSymbol):
     43        (WTF::StringImpl::convertToLowercaseWithoutLocale):
     44        (WTF::StringImpl::convertToUppercaseWithoutLocale):
     45        (WTF::StringImpl::convertToLowercaseWithLocale):
     46        (WTF::StringImpl::convertToUppercaseWithLocale):
     47        (WTF::StringImpl::convertASCIICase):
     48        * wtf/text/StringImpl.h:
     49        (WTF::StringImpl::StringImpl):
     50        (WTF::StringImpl::createSubstringSharingImpl):
     51        (WTF::StringImpl::tryCreateUninitialized):
     52        (WTF::StringImpl::extractFoldedStringInSymbol):
     53        * wtf/text/SymbolRegistry.cpp:
     54        (WTF::SymbolRegistry::symbolForKey):
     55        * wtf/text/WTFString.cpp:
     56        (WTF::String::substringSharingImpl):
     57        * wtf/text/WTFString.h:
     58        (WTF::String::String): Deleted.
     59        * wtf/text/cf/StringImplCF.cpp:
     60
    1612016-06-07  Yusuke Suzuki  <utatane.tea@gmail.com>
    262

  • trunk/Source/WTF/wtf/MetaAllocator.cpp

    r194840 r201782  
    149149}
    150150
    151 PassRefPtr<MetaAllocatorHandle> MetaAllocator::allocate(size_t sizeInBytes, void* ownerUID)
     151RefPtr<MetaAllocatorHandle> MetaAllocator::allocate(size_t sizeInBytes, void* ownerUID)
    152152{
    153153    LockHolder locker(&m_lock);
    154154
    155155    if (!sizeInBytes)
    156         return 0;
     156        return nullptr;
    157157   
    158158    sizeInBytes = roundUp(sizeInBytes);
    … …  
    165165        start = allocateNewSpace(numberOfPages);
    166166        if (!start)
    167             return 0;
     167            return nullptr;
    168168       
    169169        ASSERT(numberOfPages >= requestedNumberOfPages);
    … …  
    187187#endif
    188188
    189     MetaAllocatorHandle* handle = new MetaAllocatorHandle(this, start, sizeInBytes, ownerUID);
     189    auto handle = adoptRef(*new MetaAllocatorHandle(this, start, sizeInBytes, ownerUID));
    190190
    191191    if (UNLIKELY(!!m_tracker))
    192         m_tracker->notify(handle);
    193 
    194     return adoptRef(handle);
     192        m_tracker->notify(handle.ptr());
     193
     194    return WTFMove(handle);
    195195}
    196196

  • trunk/Source/WTF/wtf/MetaAllocator.h

    r194840 r201782  
    6969    WTF_EXPORT_PRIVATE virtual ~MetaAllocator();
    7070   
    71     WTF_EXPORT_PRIVATE PassRefPtr<MetaAllocatorHandle> allocate(size_t sizeInBytes, void* ownerUID);
     71    WTF_EXPORT_PRIVATE RefPtr<MetaAllocatorHandle> allocate(size_t sizeInBytes, void* ownerUID);
    7272
    7373    void trackAllocations(MetaAllocatorTracker* tracker)

  • trunk/Source/WTF/wtf/ParallelJobsGeneric.h

    r188594 r201782  
    6767        void waitForFinish();
    6868
    69         static PassRefPtr<ThreadPrivate> create()
     69        static Ref<ThreadPrivate> create()
    7070        {
    71             return adoptRef(new ThreadPrivate());
     71            return adoptRef(*new ThreadPrivate());
    7272        }
    7373

  • trunk/Source/WTF/wtf/PassRefPtr.h

    r184316 r201782  
    2222#define WTF_PassRefPtr_h
    2323
    24 #include <wtf/GetPtr.h>
    2524#include <wtf/Ref.h>
    2625
    … …  
    2928    template<typename T> class RefPtr;
    3029    template<typename T> class PassRefPtr;
    31     template<typename T> PassRefPtr<T> adoptRef(T*);
    3230
    3331    template<typename T> ALWAYS_INLINE void refIfNotNull(T* ptr)
    … …  
    6058        template<typename U> PassRefPtr(const RefPtr<U>&);
    6159        template<typename U> PassRefPtr(Ref<U>&& reference) : m_ptr(&reference.leakRef()) { }
     60        template<typename U> PassRefPtr(RefPtr<U>&& reference) : m_ptr(reference.leakRef()) { }
    6261
    6362        T* get() const { return m_ptr; }
    … …  
    7473        operator UnspecifiedBoolType() const { return m_ptr ? &PassRefPtr::m_ptr : nullptr; }
    7574
    76         friend PassRefPtr adoptRef<T>(T*);
     75        template<typename V, typename U> friend PassRefPtr<V> static_pointer_cast(const PassRefPtr<U>&);
    7776
    7877    private:
    … …  
    146145        return a != b.get();
    147146    }
    148    
    149     template<typename T> inline PassRefPtr<T> adoptRef(T* p)
     147
     148    template<typename V, typename U> inline PassRefPtr<V> static_pointer_cast(const PassRefPtr<U>& p)
    150149    {
    151         adopted(p);
    152         return PassRefPtr<T>(p, PassRefPtr<T>::Adopt);
    153     }
    154 
    155     template<typename T, typename U> inline PassRefPtr<T> static_pointer_cast(const PassRefPtr<U>& p)
    156     {
    157         return adoptRef(static_cast<T*>(p.leakRef()));
     150        return PassRefPtr<V>(static_cast<V*>(p.leakRef()), PassRefPtr<V>::Adopt);
    158151    }
    159152
    … …  
    165158
    166159using WTF::PassRefPtr;
    167 using WTF::adoptRef;
    168160using WTF::static_pointer_cast;
    169161

  • trunk/Source/WTF/wtf/RefPtr.h

    r201013 r201782  
    3232namespace WTF {
    3333
     34template<typename T> class RefPtr;
     35template<typename T> RefPtr<T> adoptRef(T*);
     36
    3437enum HashTableDeletedValueType { HashTableDeletedValue };
    3538
    … …  
    6366    T* get() const { return m_ptr; }
    6467   
    65     PassRefPtr<T> release() { PassRefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }
     68    // FIXME: Remove release() and change all call sites to call WTFMove().
     69    RefPtr<T> release() { RefPtr<T> tmp = adoptRef(m_ptr); m_ptr = nullptr; return tmp; }
    6670    Ref<T> releaseNonNull() { ASSERT(m_ptr); Ref<T> tmp(adoptRef(*m_ptr)); m_ptr = nullptr; return tmp; }
    6771
    … …  
    99103
    100104private:
     105    friend RefPtr adoptRef<T>(T*);
     106
     107    enum AdoptTag { Adopt };
     108    RefPtr(T* ptr, AdoptTag) : m_ptr(ptr) { }
     109
    101110    T* m_ptr;
    102111};
    … …  
    229238};
    230239
     240template<typename T> inline RefPtr<T> adoptRef(T* p)
     241{
     242    adopted(p);
     243    return RefPtr<T>(p, RefPtr<T>::Adopt);
     244}
     245
    231246} // namespace WTF
    232247
    233248using WTF::RefPtr;
     249using WTF::adoptRef;
    234250using WTF::static_pointer_cast;
    235251

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

    r200626 r201782  
    220220    {
    221221        UChar* target;
    222         RefPtr<StringImpl> newString = StringImpl::createUninitialized(buffer.utf16Length, target);
     222        auto newString = StringImpl::createUninitialized(buffer.utf16Length, target);
    223223
    224224        bool isAllASCII;
    … …  
    230230            newString = StringImpl::create(buffer.characters, buffer.length);
    231231
    232         location = newString.leakRef();
     232        location = &newString.leakRef();
    233233        location->setHash(hash);
    234234        location->setIsAtomic(true);
    … …  
    285285    static void translate(StringImpl*& location, const SubstringLocation& buffer, unsigned hash)
    286286    {
    287         location = &StringImpl::createSubstringSharingImpl(buffer.baseString, buffer.start, buffer.length).leakRef();
     287        location = &StringImpl::createSubstringSharingImpl(*buffer.baseString, buffer.start, buffer.length).leakRef();
    288288        location->setHash(hash);
    289289        location->setIsAtomic(true);

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

    r200626 r201782  
    3333namespace WTF {
    3434
    35 PassRefPtr<CStringBuffer> CStringBuffer::createUninitialized(size_t length)
     35Ref<CStringBuffer> CStringBuffer::createUninitialized(size_t length)
    3636{
    3737    RELEASE_ASSERT(length < (std::numeric_limits<unsigned>::max() - sizeof(CStringBuffer)));
    … …  
    4040    size_t size = sizeof(CStringBuffer) + length + 1;
    4141    CStringBuffer* stringBuffer = static_cast<CStringBuffer*>(fastMalloc(size));
    42     return adoptRef(new (NotNull, stringBuffer) CStringBuffer(length));
     42    return adoptRef(*new (NotNull, stringBuffer) CStringBuffer(length));
    4343}
    4444
    … …  
    7777    return m_buffer->mutableData();
    7878}
    79    
     79
    8080CString CString::newUninitialized(size_t length, char*& characterBuffer)
    8181{

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

    r165676 r201782  
    2929#include <wtf/HashFunctions.h>
    3030#include <wtf/HashTraits.h>
    31 #include <wtf/PassRefPtr.h>
     31#include <wtf/Ref.h>
    3232#include <wtf/RefCounted.h>
    3333
    … …  
    4444    friend class CString;
    4545
    46     static PassRefPtr<CStringBuffer> createUninitialized(size_t length);
     46    static Ref<CStringBuffer> createUninitialized(size_t length);
    4747
    4848    CStringBuffer(size_t length) : m_length(length) { }

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

    r201121 r201782  
    6060        m_string = m_buffer.get();
    6161    else
    62         m_string = StringImpl::createSubstringSharingImpl(m_buffer, 0, m_length);
     62        m_string = StringImpl::createSubstringSharingImpl(*m_buffer, 0, m_length);
    6363}
    6464
    … …  
    8989    ASSERT(newSize < m_string.length());
    9090    m_length = newSize;
    91     m_string = StringImpl::createSubstringSharingImpl(m_string.impl(), 0, newSize);
     91    m_string = StringImpl::createSubstringSharingImpl(*m_string.impl(), 0, newSize);
    9292}
    9393
    … …  
    148148   
    149149    if (m_buffer->hasOneRef())
    150         m_buffer = StringImpl::reallocate(m_buffer.release(), requiredLength, m_bufferCharacters8);
     150        m_buffer = StringImpl::reallocate(m_buffer.releaseNonNull(), requiredLength, m_bufferCharacters8);
    151151    else
    152152        allocateBuffer(m_buffer->characters8(), requiredLength);
    … …  
    163163        allocateBufferUpConvert(m_buffer->characters8(), requiredLength);
    164164    else if (m_buffer->hasOneRef())
    165         m_buffer = StringImpl::reallocate(m_buffer.release(), requiredLength, m_bufferCharacters16);
     165        m_buffer = StringImpl::reallocate(m_buffer.releaseNonNull(), requiredLength, m_bufferCharacters16);
    166166    else
    167167        allocateBuffer(m_buffer->characters16(), requiredLength);

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

    r198168 r201782  
    205205
    206206template <typename CharType>
    207 inline Ref<StringImpl> StringImpl::reallocateInternal(PassRefPtr<StringImpl> originalString, unsigned length, CharType*& data)
    208 {   
     207inline Ref<StringImpl> StringImpl::reallocateInternal(Ref<StringImpl>&& originalString, unsigned length, CharType*& data)
     208{
    209209    ASSERT(originalString->hasOneRef());
    210210    ASSERT(originalString->bufferOwnership() == BufferInternal);
    … …  
    220220
    221221    originalString->~StringImpl();
    222     StringImpl* string = static_cast<StringImpl*>(fastRealloc(originalString.leakRef(), allocationSize<CharType>(length)));
     222    auto* string = static_cast<StringImpl*>(fastRealloc(&originalString.leakRef(), allocationSize<CharType>(length)));
    223223
    224224    data = string->tailPointer<CharType>();
    … …  
    226226}
    227227
    228 Ref<StringImpl> StringImpl::reallocate(PassRefPtr<StringImpl> originalString, unsigned length, LChar*& data)
     228Ref<StringImpl> StringImpl::reallocate(Ref<StringImpl>&& originalString, unsigned length, LChar*& data)
    229229{
    230230    ASSERT(originalString->is8Bit());
    231     return reallocateInternal(originalString, length, data);
    232 }
    233 
    234 Ref<StringImpl> StringImpl::reallocate(PassRefPtr<StringImpl> originalString, unsigned length, UChar*& data)
     231    return reallocateInternal(WTFMove(originalString), length, data);
     232}
     233
     234Ref<StringImpl> StringImpl::reallocate(Ref<StringImpl>&& originalString, unsigned length, UChar*& data)
    235235{
    236236    ASSERT(!originalString->is8Bit());
    237     return reallocateInternal(originalString, length, data);
     237    return reallocateInternal(WTFMove(originalString), length, data);
    238238}
    239239
    … …  
    266266
    267267    LChar* data;
    268     RefPtr<StringImpl> string = createUninitializedInternalNonEmpty(length, data);
     268    auto string = createUninitializedInternalNonEmpty(length, data);
    269269
    270270    for (size_t i = 0; i < length; ++i) {
    … …  
    274274    }
    275275
    276     return string.releaseNonNull();
     276    return string;
    277277}
    278278
    … …  
    292292}
    293293
    294 Ref<SymbolImpl> StringImpl::createSymbol(PassRefPtr<StringImpl> rep)
    295 {
    296     StringImpl* ownerRep = (rep->bufferOwnership() == BufferSubstring) ? rep->substringBuffer() : rep.get();
     294Ref<SymbolImpl> StringImpl::createSymbol(StringImpl& rep)
     295{
     296    auto* ownerRep = (rep.bufferOwnership() == BufferSubstring) ? rep.substringBuffer() : &rep;
    297297
    298298    // We allocate a buffer that contains
    … …  
    301301    // 3. the pointer to the symbol registry
    302302    // 4. the placeholder for symbol aware hash value (allocated size is pointer size, but only 4 bytes are used)
    303     StringImpl* stringImpl = static_cast<StringImpl*>(fastMalloc(allocationSize<StringImpl*>(3)));
    304     if (rep->is8Bit())
    305         return adoptRef(static_cast<SymbolImpl&>(*new (NotNull, stringImpl) StringImpl(CreateSymbol, rep->m_data8, rep->length(), ownerRep)));
    306     return adoptRef(static_cast<SymbolImpl&>(*new (NotNull, stringImpl) StringImpl(CreateSymbol, rep->m_data16, rep->length(), ownerRep)));
     303    auto* stringImpl = static_cast<StringImpl*>(fastMalloc(allocationSize<StringImpl*>(3)));
     304    if (rep.is8Bit())
     305        return adoptRef(static_cast<SymbolImpl&>(*new (NotNull, stringImpl) StringImpl(CreateSymbol, rep.m_data8, rep.length(), *ownerRep)));
     306    return adoptRef(static_cast<SymbolImpl&>(*new (NotNull, stringImpl) StringImpl(CreateSymbol, rep.m_data16, rep.length(), *ownerRep)));
    307307}
    308308
    309309Ref<SymbolImpl> StringImpl::createNullSymbol()
    310310{
    311     return createSymbol(null());
     311    return createSymbol(*null());
    312312}
    313313
    … …  
    428428    // Do a slower implementation for cases that include non-ASCII characters.
    429429    UChar* data16;
    430     RefPtr<StringImpl> newImpl = createUninitializedInternalNonEmpty(m_length, data16);
     430    auto newImpl = createUninitializedInternalNonEmpty(m_length, data16);
    431431
    432432    UErrorCode status = U_ZERO_ERROR;
    433433    int32_t realLength = u_strToLower(data16, length, m_data16, m_length, "", &status);
    434434    if (U_SUCCESS(status) && realLength == length)
    435         return newImpl.releaseNonNull();
     435        return newImpl;
    436436
    437437    newImpl = createUninitialized(realLength, data16);
    … …  
    440440    if (U_FAILURE(status))
    441441        return *this;
    442     return newImpl.releaseNonNull();
     442    return newImpl;
    443443}
    444444
    … …  
    456456    if (is8Bit()) {
    457457        LChar* data8;
    458         RefPtr<StringImpl> newImpl = createUninitialized(m_length, data8);
     458        auto newImpl = createUninitialized(m_length, data8);
    459459       
    460460        // Do a faster loop for the case where all the characters are ASCII.
    … …  
    473473        }
    474474        if (!(ored & ~0x7F))
    475             return newImpl.releaseNonNull();
     475            return newImpl;
    476476
    477477        // Do a slower implementation for cases that include non-ASCII Latin-1 characters.
    … …  
    495495
    496496        if (!numberSharpSCharacters)
    497             return newImpl.releaseNonNull();
     497            return newImpl;
    498498
    499499        // We have numberSSCharacters sharp-s characters, but none of the other special characters.
    … …  
    513513        }
    514514
    515         return newImpl.releaseNonNull();
     515        return newImpl;
    516516    }
    517517
    … …  
    521521
    522522    UChar* data16;
    523     RefPtr<StringImpl> newImpl = createUninitialized(m_length, data16);
     523    auto newImpl = createUninitialized(m_length, data16);
    524524   
    525525    // Do a faster loop for the case where all the characters are ASCII.
    … …  
    531531    }
    532532    if (!(ored & ~0x7F))
    533         return newImpl.releaseNonNull();
     533        return newImpl;
    534534
    535535    // Do a slower implementation for cases that include non-ASCII characters.
    … …  
    537537    int32_t realLength = u_strToUpper(data16, length, source16, m_length, "", &status);
    538538    if (U_SUCCESS(status) && realLength == length)
    539         return newImpl.releaseNonNull();
     539        return newImpl;
    540540    newImpl = createUninitialized(realLength, data16);
    541541    status = U_ZERO_ERROR;
    … …  
    543543    if (U_FAILURE(status))
    544544        return *this;
    545     return newImpl.releaseNonNull();
     545    return newImpl;
    546546}
    547547
    … …  
    579579    const UChar* source16 = upconvertedCharacters;
    580580    UChar* data16;
    581     RefPtr<StringImpl> newString = createUninitialized(length, data16);
     581    auto newString = createUninitialized(length, data16);
    582582    UErrorCode status = U_ZERO_ERROR;
    583583    int realLength = u_strToLower(data16, length, source16, length, "tr", &status);
    584584    if (U_SUCCESS(status) && realLength == length)
    585         return newString.releaseNonNull();
     585        return newString;
    586586    newString = createUninitialized(realLength, data16);
    587587    status = U_ZERO_ERROR;
    … …  
    589589    if (U_FAILURE(status))
    590590        return *this;
    591     return newString.releaseNonNull();
     591    return newString;
    592592}
    593593
    … …  
    610610    const UChar* source16 = upconvertedCharacters;
    611611    UChar* data16;
    612     RefPtr<StringImpl> newString = createUninitialized(length, data16);
     612    auto newString = createUninitialized(length, data16);
    613613    UErrorCode status = U_ZERO_ERROR;
    614614    int realLength = u_strToUpper(data16, length, source16, length, "tr", &status);
    615615    if (U_SUCCESS(status) && realLength == length)
    616         return newString.releaseNonNull();
     616        return newString;
    617617    newString = createUninitialized(realLength, data16);
    618618    status = U_ZERO_ERROR;
    … …  
    620620    if (U_FAILURE(status))
    621621        return *this;
    622     return newString.releaseNonNull();
     622    return newString;
    623623}
    624624
    … …  
    722722SlowPath:
    723723    CharacterType* newData;
    724     Ref<StringImpl> newImpl = createUninitializedInternalNonEmpty(length, newData);
     724    auto newImpl = createUninitializedInternalNonEmpty(length, newData);
    725725    for (unsigned i = 0; i < failingIndex; ++i)
    726726        newData[i] = data[i];

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

    r198168 r201782  
    266266
    267267    // Used to create new strings that are a substring of an existing 8-bit StringImpl (BufferSubstring)
    268     StringImpl(const LChar* characters, unsigned length, PassRefPtr<StringImpl> base)
     268    StringImpl(const LChar* characters, unsigned length, Ref<StringImpl>&& base)
    269269        : m_refCount(s_refCountIncrement)
    270270        , m_length(length)
    … …  
    277277        ASSERT(base->bufferOwnership() != BufferSubstring);
    278278
    279         substringBuffer() = base.leakRef();
     279        substringBuffer() = &base.leakRef();
    280280
    281281        STRING_STATS_ADD_8BIT_STRING2(m_length, true);
    … …  
    283283
    284284    // Used to create new strings that are a substring of an existing 16-bit StringImpl (BufferSubstring)
    285     StringImpl(const UChar* characters, unsigned length, PassRefPtr<StringImpl> base)
     285    StringImpl(const UChar* characters, unsigned length, Ref<StringImpl>&& base)
    286286        : m_refCount(s_refCountIncrement)
    287287        , m_length(length)
    … …  
    294294        ASSERT(base->bufferOwnership() != BufferSubstring);
    295295
    296         substringBuffer() = base.leakRef();
     296        substringBuffer() = &base.leakRef();
    297297
    298298        STRING_STATS_ADD_16BIT_STRING2(m_length, true);
    … …  
    301301    enum CreateSymbolTag { CreateSymbol };
    302302    // Used to create new symbol strings that holds existing 8-bit [[Description]] string as a substring buffer (BufferSubstring).
    303     StringImpl(CreateSymbolTag, const LChar* characters, unsigned length, PassRefPtr<StringImpl> base)
     303    StringImpl(CreateSymbolTag, const LChar* characters, unsigned length, Ref<StringImpl>&& base)
    304304        : m_refCount(s_refCountIncrement)
    305305        , m_length(length)
    … …  
    311311        ASSERT(base->bufferOwnership() != BufferSubstring);
    312312
    313         substringBuffer() = base.leakRef();
     313        substringBuffer() = &base.leakRef();
    314314        symbolRegistry() = nullptr;
    315315        hashForSymbol() = nextHashForSymbol();
    … …  
    319319
    320320    // Used to create new symbol strings that holds existing 16-bit [[Description]] string as a substring buffer (BufferSubstring).
    321     StringImpl(CreateSymbolTag, const UChar* characters, unsigned length, PassRefPtr<StringImpl> base)
     321    StringImpl(CreateSymbolTag, const UChar* characters, unsigned length, Ref<StringImpl>&& base)
    322322        : m_refCount(s_refCountIncrement)
    323323        , m_length(length)
    … …  
    329329        ASSERT(base->bufferOwnership() != BufferSubstring);
    330330
    331         substringBuffer() = base.leakRef();
     331        substringBuffer() = &base.leakRef();
    332332        symbolRegistry() = nullptr;
    333333        hashForSymbol() = nextHashForSymbol();
    … …  
    353353    ALWAYS_INLINE static Ref<StringImpl> create(const char* s) { return create(reinterpret_cast<const LChar*>(s)); }
    354354
    355     static ALWAYS_INLINE Ref<StringImpl> createSubstringSharingImpl(PassRefPtr<StringImpl> rep, unsigned offset, unsigned length)
    356     {
    357         ASSERT(rep);
    358         ASSERT(length <= rep->length());
     355    static ALWAYS_INLINE Ref<StringImpl> createSubstringSharingImpl(StringImpl& rep, unsigned offset, unsigned length)
     356    {
     357        ASSERT(length <= rep.length());
    359358
    360359        if (!length)
    361360            return *empty();
    362361
    363         StringImpl* ownerRep = (rep->bufferOwnership() == BufferSubstring) ? rep->substringBuffer() : rep.get();
     362        auto* ownerRep = ((rep.bufferOwnership() == BufferSubstring) ? rep.substringBuffer() : &rep);
    364363
    365364        // We allocate a buffer that contains both the StringImpl struct as well as the pointer to the owner string.
    366         StringImpl* stringImpl = static_cast<StringImpl*>(fastMalloc(allocationSize<StringImpl*>(1)));
    367         if (rep->is8Bit())
    368             return adoptRef(*new (NotNull, stringImpl) StringImpl(rep->m_data8 + offset, length, ownerRep));
    369         return adoptRef(*new (NotNull, stringImpl) StringImpl(rep->m_data16 + offset, length, ownerRep));
     365        auto* stringImpl = static_cast<StringImpl*>(fastMalloc(allocationSize<StringImpl*>(1)));
     366        if (rep.is8Bit())
     367            return adoptRef(*new (NotNull, stringImpl) StringImpl(rep.m_data8 + offset, length, *ownerRep));
     368        return adoptRef(*new (NotNull, stringImpl) StringImpl(rep.m_data16 + offset, length, *ownerRep));
    370369    }
    371370
    … …  
    388387    WTF_EXPORT_STRING_API static Ref<StringImpl> createUninitialized(unsigned length, LChar*& data);
    389388    WTF_EXPORT_STRING_API static Ref<StringImpl> createUninitialized(unsigned length, UChar*& data);
    390     template <typename T> static ALWAYS_INLINE PassRefPtr<StringImpl> tryCreateUninitialized(unsigned length, T*& output)
     389    template <typename T> static ALWAYS_INLINE RefPtr<StringImpl> tryCreateUninitialized(unsigned length, T*& output)
    391390    {
    392391        if (!length) {
    393             output = 0;
     392            output = nullptr;
    394393            return empty();
    395394        }
    396395
    397396        if (length > ((std::numeric_limits<unsigned>::max() - sizeof(StringImpl)) / sizeof(T))) {
    398             output = 0;
    399             return 0;
     397            output = nullptr;
     398            return nullptr;
    400399        }
    401400        StringImpl* resultImpl;
    402401        if (!tryFastMalloc(allocationSize<T>(length)).getValue(resultImpl)) {
    403             output = 0;
    404             return 0;
     402            output = nullptr;
     403            return nullptr;
    405404        }
    406405        output = resultImpl->tailPointer<T>();
    … …  
    410409
    411410    WTF_EXPORT_STRING_API static Ref<SymbolImpl> createNullSymbol();
    412     WTF_EXPORT_STRING_API static Ref<SymbolImpl> createSymbol(PassRefPtr<StringImpl> rep);
    413 
    414     // Reallocate the StringImpl. The originalString must be only owned by the PassRefPtr,
     411    WTF_EXPORT_STRING_API static Ref<SymbolImpl> createSymbol(StringImpl& rep);
     412
     413    // Reallocate the StringImpl. The originalString must be only owned by the Ref,
    415414    // and the buffer ownership must be BufferInternal. Just like the input pointer of realloc(),
    416415    // the originalString can't be used after this function.
    417     static Ref<StringImpl> reallocate(PassRefPtr<StringImpl> originalString, unsigned length, LChar*& data);
    418     static Ref<StringImpl> reallocate(PassRefPtr<StringImpl> originalString, unsigned length, UChar*& data);
     416    static Ref<StringImpl> reallocate(Ref<StringImpl>&& originalString, unsigned length, LChar*& data);
     417    static Ref<StringImpl> reallocate(Ref<StringImpl>&& originalString, unsigned length, UChar*& data);
    419418
    420419    static unsigned flagsOffset() { return OBJECT_OFFSETOF(StringImpl, m_hashAndFlags); }
    … …  
    766765        ASSERT(substringBuffer());
    767766        ASSERT(!substringBuffer()->isSymbol());
    768         return createSubstringSharingImpl(this, 0, length());
     767        return createSubstringSharingImpl(*this, 0, length());
    769768    }
    770769
    … …  
    861860    template <typename CharType> static Ref<StringImpl> createUninitializedInternal(unsigned, CharType*&);
    862861    template <typename CharType> static Ref<StringImpl> createUninitializedInternalNonEmpty(unsigned, CharType*&);
    863     template <typename CharType> static Ref<StringImpl> reallocateInternal(PassRefPtr<StringImpl>, unsigned, CharType*&);
     862    template <typename CharType> static Ref<StringImpl> reallocateInternal(Ref<StringImpl>&&, unsigned, CharType*&);
    864863    template <typename CharType> static Ref<StringImpl> createInternal(const CharType*, unsigned);
    865864    WTF_EXPORT_PRIVATE NEVER_INLINE unsigned hashSlowCase() const;

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

    r184828 r201782  
    4141        return *static_cast<SymbolImpl*>(addResult.iterator->impl());
    4242
    43     Ref<SymbolImpl> symbol = StringImpl::createSymbol(rep.impl());
     43    auto symbol = StringImpl::createSymbol(*rep.impl());
    4444    symbol->symbolRegistry() = this;
    4545    *addResult.iterator = SymbolRegistryKey(&symbol.get());

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

    r200626 r201782  
    333333    if (!offset && length == stringLength)
    334334        return *this;
    335     return String(StringImpl::createSubstringSharingImpl(m_impl, offset, length));
     335    return String(StringImpl::createSubstringSharingImpl(*m_impl, offset, length));
    336336}
    337337

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

    r201594 r201782  
    108108    String(StringImpl&);
    109109    String(StringImpl*);
    110     String(PassRefPtr<StringImpl>);
    111110    String(Ref<StringImpl>&&);
    112111    String(RefPtr<StringImpl>&&);
    … …  
    528527
    529528inline String::String(StringImpl* impl)
    530     : m_impl(impl)
    531 {
    532 }
    533 
    534 inline String::String(PassRefPtr<StringImpl> impl)
    535529    : m_impl(impl)
    536530{

  • trunk/Source/WTF/wtf/text/cf/StringImplCF.cpp

    r193378 r201782  
    2626#include <CoreFoundation/CoreFoundation.h>
    2727#include <wtf/MainThread.h>
    28 #include <wtf/PassRefPtr.h>
    2928#include <wtf/RetainPtr.h>
    3029#include <wtf/Threading.h>

  • trunk/Source/WebCore/ChangeLog

    r201777 r201782  
     12016-06-07  Keith Rollin  <krollin@apple.com>
     2
     3        Remove all uses of PassRefPtr in WTF
     4        https://bugs.webkit.org/show_bug.cgi?id=157596
     5        <rdar://problem/26234391>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Update calls to interfaces that no longer take or return PassRefPtrs.
     10
     11        No new tests: no new functionality so changes are covered by existing
     12        tests.
     13
     14        * css/CSSPrimitiveValue.cpp:
     15        (WebCore::CSSPrimitiveValue::formatNumberValue):
     16        * dom/Document.cpp:
     17        (WebCore::Document::displayStringModifiedByEncoding):
     18        * xml/XPathGrammar.y:
     19
    1202016-06-07  Myles C. Maxfield  <mmaxfield@apple.com>
    221

  • trunk/Source/WebCore/css/CSSPrimitiveValue.cpp

    r201690 r201782  
    10451045    unsigned bufferLength = decimal.bufferLengthForStringDecimal() + suffixLength;
    10461046    LChar* buffer;
    1047     Ref<StringImpl> string = StringImpl::createUninitialized(bufferLength, buffer);
     1047    auto string = StringImpl::createUninitialized(bufferLength, buffer);
    10481048
    10491049    unsigned length = decimal.toStringDecimal(buffer, bufferLength);

  • trunk/Source/WebCore/dom/Document.cpp

    r201753 r201782  
    55115511{
    55125512    if (m_decoder)
    5513         return m_decoder->encoding().displayString(str.impl());
     5513        return m_decoder->encoding().displayString(str.impl()).get();
    55145514    return str;
    55155515}

  • trunk/Source/WebCore/html/canvas/WebGL2RenderingContext.cpp

    r200298 r201782  
    18371837        return getBooleanArrayParameter(pname);
    18381838    case GraphicsContext3D::COMPRESSED_TEXTURE_FORMATS:
    1839         return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()).release());
     1839        return WebGLGetInfo(PassRefPtr<Uint32Array>(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size())));
    18401840    case GraphicsContext3D::CULL_FACE:
    18411841        return getBooleanParameter(pname);

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContext.cpp

    r200298 r201782  
    956956        return getBooleanArrayParameter(pname);
    957957    case GraphicsContext3D::COMPRESSED_TEXTURE_FORMATS:
    958         return WebGLGetInfo(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size()).release());
     958        return WebGLGetInfo(PassRefPtr<Uint32Array>(Uint32Array::create(m_compressedTextureFormats.data(), m_compressedTextureFormats.size())));
    959959    case GraphicsContext3D::CULL_FACE:
    960960        return getBooleanParameter(pname);

  • trunk/Source/WebCore/html/canvas/WebGLRenderingContextBase.cpp

    r200789 r201782  
    25112511        if (length == 1)
    25122512            return WebGLGetInfo(value[0]);
    2513         return WebGLGetInfo(Float32Array::create(value, length).release());
     2513        return WebGLGetInfo(PassRefPtr<Float32Array>(Float32Array::create(value, length)));
    25142514    }
    25152515    case GraphicsContext3D::INT: {
    … …  
    25212521        if (length == 1)
    25222522            return WebGLGetInfo(value[0]);
    2523         return WebGLGetInfo(Int32Array::create(value, length).release());
     2523        return WebGLGetInfo(PassRefPtr<Int32Array>(Int32Array::create(value, length)));
    25242524    }
    25252525    case GraphicsContext3D::BOOL: {
    … …  
    26172617        return WebGLGetInfo(state.type);
    26182618    case GraphicsContext3D::CURRENT_VERTEX_ATTRIB:
    2619         return WebGLGetInfo(Float32Array::create(m_vertexAttribValue[index].value, 4).release());
     2619        return WebGLGetInfo(PassRefPtr<Float32Array>(Float32Array::create(m_vertexAttribValue[index].value, 4)));
    26202620    default:
    26212621        synthesizeGLError(GraphicsContext3D::INVALID_ENUM, "getVertexAttrib", "invalid parameter name");
    … …  
    39653965        notImplemented();
    39663966    }
    3967     return WebGLGetInfo(Float32Array::create(value, length).release());
     3967    return WebGLGetInfo(PassRefPtr<Float32Array>(Float32Array::create(value, length)));
    39683968}
    39693969
    … …  
    39843984        notImplemented();
    39853985    }
    3986     return WebGLGetInfo(Int32Array::create(value, length).release());
     3986    return WebGLGetInfo(PassRefPtr<Int32Array>(Int32Array::create(value, length)));
    39873987}
    39883988

  • trunk/Source/WebCore/platform/animation/TimingFunction.h

    r201759 r201782  
    2828#include <wtf/PassRefPtr.h>
    2929#include <wtf/RefCounted.h>
     30#include <wtf/RefPtr.h>
    3031
    3132namespace WebCore {

  • trunk/Source/WebKit2/Platform/IPC/HandleMessage.h

    r194496 r201782  
    142142
    143143    RefPtr<typename T::DelayedReply> delayedReply = adoptRef(new typename T::DelayedReply(&connection, WTFMove(replyEncoder)));
    144     callMemberFunction(WTFMove(arguments), delayedReply.release(), object, function);
     144    callMemberFunction(WTFMove(arguments), PassRefPtr<typename T::DelayedReply>(WTFMove(delayedReply)), object, function);
    145145}
    146146

  • trunk/Tools/ChangeLog

    r201760 r201782  
     12016-06-07  Keith Rollin  <krollin@apple.com>
     2
     3        Remove all uses of PassRefPtr in WTF
     4        https://bugs.webkit.org/show_bug.cgi?id=157596
     5        <rdar://problem/26234391>
     6
     7        Reviewed by Chris Dumez.
     8
     9        Update calls to interfaces that no longer take or return PassRefPtrs.
     10
     11        * TestWebKitAPI/Tests/WTF/StringImpl.cpp:
     12        (TestWebKitAPI::stringFromUTF8):
     13        (TestWebKitAPI::TEST):
     14
    1152016-06-07  Per Arne Vollan  <pvollan@apple.com>
    216

  • trunk/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp

    r198168 r201782  
    3434{
    3535    // Constructor using the template to determine the size.
    36     RefPtr<StringImpl> stringWithTemplate = StringImpl::createFromLiteral("Template Literal");
     36    auto stringWithTemplate = StringImpl::createFromLiteral("Template Literal");
    3737    ASSERT_EQ(strlen("Template Literal"), stringWithTemplate->length());
    3838    ASSERT_TRUE(equal(stringWithTemplate.get(), "Template Literal"));
    … …  
    4141    // Constructor taking the size explicitely.
    4242    const char* programmaticStringData = "Explicit Size Literal";
    43     RefPtr<StringImpl> programmaticString = StringImpl::createFromLiteral(programmaticStringData, strlen(programmaticStringData));
     43    auto programmaticString = StringImpl::createFromLiteral(programmaticStringData, strlen(programmaticStringData));
    4444    ASSERT_EQ(strlen(programmaticStringData), programmaticString->length());
    4545    ASSERT_TRUE(equal(programmaticString.get(), programmaticStringData));
    … …  
    4949    // Constructor without explicit size.
    5050    const char* stringWithoutLengthLiteral = "No Size Literal";
    51     RefPtr<StringImpl> programmaticStringNoLength = StringImpl::createFromLiteral(stringWithoutLengthLiteral);
     51    auto programmaticStringNoLength = StringImpl::createFromLiteral(stringWithoutLengthLiteral);
    5252    ASSERT_EQ(strlen(stringWithoutLengthLiteral), programmaticStringNoLength->length());
    5353    ASSERT_TRUE(equal(programmaticStringNoLength.get(), stringWithoutLengthLiteral));
    … …  
    5858TEST(WTF, StringImplReplaceWithLiteral)
    5959{
    60     RefPtr<StringImpl> testStringImpl = StringImpl::createFromLiteral("1224");
     60    auto testStringImpl = StringImpl::createFromLiteral("1224");
    6161    ASSERT_TRUE(testStringImpl->is8Bit());
    6262
    … …  
    102102TEST(WTF, StringImplEqualIgnoringASCIICaseBasic)
    103103{
    104     RefPtr<StringImpl> a = StringImpl::createFromLiteral("aBcDeFG");
    105     RefPtr<StringImpl> b = StringImpl::createFromLiteral("ABCDEFG");
    106     RefPtr<StringImpl> c = StringImpl::createFromLiteral("abcdefg");
     104    auto a = StringImpl::createFromLiteral("aBcDeFG");
     105    auto b = StringImpl::createFromLiteral("ABCDEFG");
     106    auto c = StringImpl::createFromLiteral("abcdefg");
    107107    const char d[] = "aBcDeFG";
    108     RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
    109     RefPtr<StringImpl> shorter = StringImpl::createFromLiteral("abcdef");
    110     RefPtr<StringImpl> different = StringImpl::createFromLiteral("abcrefg");
     108    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
     109    auto shorter = StringImpl::createFromLiteral("abcdef");
     110    auto different = StringImpl::createFromLiteral("abcrefg");
    111111
    112112    // Identity.
    113     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), a.get()));
    114     ASSERT_TRUE(equalIgnoringASCIICase(b.get(), b.get()));
    115     ASSERT_TRUE(equalIgnoringASCIICase(c.get(), c.get()));
    116     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), d));
    117     ASSERT_TRUE(equalIgnoringASCIICase(b.get(), d));
    118     ASSERT_TRUE(equalIgnoringASCIICase(c.get(), d));
     113    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), a.ptr()));
     114    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), b.ptr()));
     115    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), c.ptr()));
     116    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), d));
     117    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), d));
     118    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), d));
    119119
    120120    // Transitivity.
    121     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), b.get()));
    122     ASSERT_TRUE(equalIgnoringASCIICase(b.get(), c.get()));
    123     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), c.get()));
     121    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), b.ptr()));
     122    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), c.ptr()));
     123    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), c.ptr()));
    124124
    125125    // Negative cases.
    126     ASSERT_FALSE(equalIgnoringASCIICase(a.get(), empty.get()));
    127     ASSERT_FALSE(equalIgnoringASCIICase(b.get(), empty.get()));
    128     ASSERT_FALSE(equalIgnoringASCIICase(c.get(), empty.get()));
    129     ASSERT_FALSE(equalIgnoringASCIICase(a.get(), shorter.get()));
    130     ASSERT_FALSE(equalIgnoringASCIICase(b.get(), shorter.get()));
    131     ASSERT_FALSE(equalIgnoringASCIICase(c.get(), shorter.get()));
    132     ASSERT_FALSE(equalIgnoringASCIICase(a.get(), different.get()));
    133     ASSERT_FALSE(equalIgnoringASCIICase(b.get(), different.get()));
    134     ASSERT_FALSE(equalIgnoringASCIICase(c.get(), different.get()));
    135     ASSERT_FALSE(equalIgnoringASCIICase(empty.get(), d));
    136     ASSERT_FALSE(equalIgnoringASCIICase(shorter.get(), d));
    137     ASSERT_FALSE(equalIgnoringASCIICase(different.get(), d));
     126    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), empty.ptr()));
     127    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), empty.ptr()));
     128    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), empty.ptr()));
     129    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), shorter.ptr()));
     130    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), shorter.ptr()));
     131    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), shorter.ptr()));
     132    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), different.ptr()));
     133    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), different.ptr()));
     134    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), different.ptr()));
     135    ASSERT_FALSE(equalIgnoringASCIICase(empty.ptr(), d));
     136    ASSERT_FALSE(equalIgnoringASCIICase(shorter.ptr(), d));
     137    ASSERT_FALSE(equalIgnoringASCIICase(different.ptr(), d));
    138138}
    139139
    140140TEST(WTF, StringImplEqualIgnoringASCIICaseWithNull)
    141141{
    142     RefPtr<StringImpl> reference = StringImpl::createFromLiteral("aBcDeFG");
     142    auto reference = StringImpl::createFromLiteral("aBcDeFG");
    143143    StringImpl* nullStringImpl = nullptr;
    144     ASSERT_FALSE(equalIgnoringASCIICase(nullStringImpl, reference.get()));
    145     ASSERT_FALSE(equalIgnoringASCIICase(reference.get(), nullStringImpl));
     144    ASSERT_FALSE(equalIgnoringASCIICase(nullStringImpl, reference.ptr()));
     145    ASSERT_FALSE(equalIgnoringASCIICase(reference.ptr(), nullStringImpl));
    146146    ASSERT_TRUE(equalIgnoringASCIICase(nullStringImpl, nullStringImpl));
    147147}
    … …  
    149149TEST(WTF, StringImplEqualIgnoringASCIICaseWithEmpty)
    150150{
    151     RefPtr<StringImpl> a = StringImpl::create(reinterpret_cast<const LChar*>(""));
    152     RefPtr<StringImpl> b = StringImpl::create(reinterpret_cast<const LChar*>(""));
    153     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), b.get()));
    154     ASSERT_TRUE(equalIgnoringASCIICase(b.get(), a.get()));
    155 }
    156 
    157 static RefPtr<StringImpl> stringFromUTF8(const char* characters)
    158 {
    159     return String::fromUTF8(characters).impl();
     151    auto a = StringImpl::create(reinterpret_cast<const LChar*>(""));
     152    auto b = StringImpl::create(reinterpret_cast<const LChar*>(""));
     153    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), b.ptr()));
     154    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), a.ptr()));
     155}
     156
     157static Ref<StringImpl> stringFromUTF8(const char* characters)
     158{
     159    return String::fromUTF8(characters).releaseImpl().releaseNonNull();
    160160}
    161161
    162162TEST(WTF, StringImplEqualIgnoringASCIICaseWithLatin1Characters)
    163163{
    164     RefPtr<StringImpl> a = stringFromUTF8("aBcéeFG");
    165     RefPtr<StringImpl> b = stringFromUTF8("ABCÉEFG");
    166     RefPtr<StringImpl> c = stringFromUTF8("ABCéEFG");
    167     RefPtr<StringImpl> d = stringFromUTF8("abcéefg");
     164    auto a = stringFromUTF8("aBcéeFG");
     165    auto b = stringFromUTF8("ABCÉEFG");
     166    auto c = stringFromUTF8("ABCéEFG");
     167    auto d = stringFromUTF8("abcéefg");
    168168    const char e[] = "aBcéeFG";
    169169
    170170    // Identity.
    171     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), a.get()));
    172     ASSERT_TRUE(equalIgnoringASCIICase(b.get(), b.get()));
    173     ASSERT_TRUE(equalIgnoringASCIICase(c.get(), c.get()));
    174     ASSERT_TRUE(equalIgnoringASCIICase(d.get(), d.get()));
     171    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), a.ptr()));
     172    ASSERT_TRUE(equalIgnoringASCIICase(b.ptr(), b.ptr()));
     173    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), c.ptr()));
     174    ASSERT_TRUE(equalIgnoringASCIICase(d.ptr(), d.ptr()));
    175175
    176176    // All combination.
    177     ASSERT_FALSE(equalIgnoringASCIICase(a.get(), b.get()));
    178     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), c.get()));
    179     ASSERT_TRUE(equalIgnoringASCIICase(a.get(), d.get()));
    180     ASSERT_FALSE(equalIgnoringASCIICase(b.get(), c.get()));
    181     ASSERT_FALSE(equalIgnoringASCIICase(b.get(), d.get()));
    182     ASSERT_TRUE(equalIgnoringASCIICase(c.get(), d.get()));
    183     ASSERT_FALSE(equalIgnoringASCIICase(a.get(), e));
    184     ASSERT_FALSE(equalIgnoringASCIICase(b.get(), e));
    185     ASSERT_FALSE(equalIgnoringASCIICase(c.get(), e));
    186     ASSERT_FALSE(equalIgnoringASCIICase(d.get(), e));
     177    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), b.ptr()));
     178    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), c.ptr()));
     179    ASSERT_TRUE(equalIgnoringASCIICase(a.ptr(), d.ptr()));
     180    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), c.ptr()));
     181    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), d.ptr()));
     182    ASSERT_TRUE(equalIgnoringASCIICase(c.ptr(), d.ptr()));
     183    ASSERT_FALSE(equalIgnoringASCIICase(a.ptr(), e));
     184    ASSERT_FALSE(equalIgnoringASCIICase(b.ptr(), e));
     185    ASSERT_FALSE(equalIgnoringASCIICase(c.ptr(), e));
     186    ASSERT_FALSE(equalIgnoringASCIICase(d.ptr(), e));
    187187}
    188188
    189189TEST(WTF, StringImplFindIgnoringASCIICaseBasic)
    190190{
    191     RefPtr<StringImpl> referenceA = stringFromUTF8("aBcéeFG");
    192     RefPtr<StringImpl> referenceB = stringFromUTF8("ABCÉEFG");
     191    auto referenceA = stringFromUTF8("aBcéeFG");
     192    auto referenceB = stringFromUTF8("ABCÉEFG");
    193193
    194194    // Search the exact string.
    195     EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(referenceA.get()));
    196     EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(referenceB.get()));
     195    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(referenceA.ptr()));
     196    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(referenceB.ptr()));
    197197
    198198    // A and B are distinct by the non-ascii character é/É.
    199     EXPECT_EQ(static_cast<size_t>(notFound), referenceA->findIgnoringASCIICase(referenceB.get()));
    200     EXPECT_EQ(static_cast<size_t>(notFound), referenceB->findIgnoringASCIICase(referenceA.get()));
     199    EXPECT_EQ(static_cast<size_t>(notFound), referenceA->findIgnoringASCIICase(referenceB.ptr()));
     200    EXPECT_EQ(static_cast<size_t>(notFound), referenceB->findIgnoringASCIICase(referenceA.ptr()));
    201201
    202202    // Find the prefix.
    203     EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("a").get()));
    204     EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("abcé").get()));
    205     EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("A").get()));
    206     EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCé").get()));
    207     EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("a").get()));
    208     EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("abcÉ").get()));
    209     EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("A").get()));
    210     EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get()));
     203    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("a").ptr()));
     204    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("abcé").ptr()));
     205    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("A").ptr()));
     206    EXPECT_EQ(static_cast<size_t>(0), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr()));
     207    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("a").ptr()));
     208    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("abcÉ").ptr()));
     209    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("A").ptr()));
     210    EXPECT_EQ(static_cast<size_t>(0), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr()));
    211211
    212212    // Not a prefix.
    213     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("x").get()));
    214     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("accé").get()));
    215     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("abcÉ").get()));
    216     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").get()));
    217     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABDé").get()));
    218     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get()));
    219     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("y").get()));
    220     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("accÉ").get()));
    221     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("abcé").get()));
    222     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Y").get()));
    223     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABdÉ").get()));
    224     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCé").get()));
     213    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("x").ptr()));
     214    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("accé").ptr()));
     215    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("abcÉ").ptr()));
     216    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").ptr()));
     217    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABDé").ptr()));
     218    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr()));
     219    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("y").ptr()));
     220    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("accÉ").ptr()));
     221    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("abcé").ptr()));
     222    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Y").ptr()));
     223    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABdÉ").ptr()));
     224    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr()));
    225225
    226226    // Find the infix.
    227     EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cée").get()));
    228     EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("ée").get()));
    229     EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cé").get()));
    230     EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("c").get()));
    231     EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("é").get()));
    232     EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cée").get()));
    233     EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éE").get()));
    234     EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cé").get()));
    235     EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("C").get()));
    236 
    237     EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉe").get()));
    238     EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Ée").get()));
    239     EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉ").get()));
    240     EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("c").get()));
    241     EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("É").get()));
    242     EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉe").get()));
    243     EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉE").get()));
    244     EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉ").get()));
    245     EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("C").get()));
     227    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cée").ptr()));
     228    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("ée").ptr()));
     229    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("cé").ptr()));
     230    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("c").ptr()));
     231    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("é").ptr()));
     232    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cée").ptr()));
     233    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éE").ptr()));
     234    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("Cé").ptr()));
     235    EXPECT_EQ(static_cast<size_t>(2), referenceA->findIgnoringASCIICase(stringFromUTF8("C").ptr()));
     236
     237    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉe").ptr()));
     238    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Ée").ptr()));
     239    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("cÉ").ptr()));
     240    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("c").ptr()));
     241    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("É").ptr()));
     242    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉe").ptr()));
     243    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉE").ptr()));
     244    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("CÉ").ptr()));
     245    EXPECT_EQ(static_cast<size_t>(2), referenceB->findIgnoringASCIICase(stringFromUTF8("C").ptr()));
    246246
    247247    // Not an infix.
    248     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("céd").get()));
    249     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Ée").get()));
    250     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("bé").get()));
    251     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("x").get()));
    252     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("É").get()));
    253     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉe").get()));
    254     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("éd").get()));
    255     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉ").get()));
    256     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Y").get()));
    257 
    258     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cée").get()));
    259     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("Éc").get()));
    260     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cé").get()));
    261     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("W").get()));
    262     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("é").get()));
    263     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("bÉe").get()));
    264     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éE").get()));
    265     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("BÉ").get()));
    266     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("z").get()));
     248    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("céd").ptr()));
     249    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Ée").ptr()));
     250    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("bé").ptr()));
     251    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("x").ptr()));
     252    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("É").ptr()));
     253    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉe").ptr()));
     254    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("éd").ptr()));
     255    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("CÉ").ptr()));
     256    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Y").ptr()));
     257
     258    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cée").ptr()));
     259    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("Éc").ptr()));
     260    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("cé").ptr()));
     261    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("W").ptr()));
     262    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("é").ptr()));
     263    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("bÉe").ptr()));
     264    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éE").ptr()));
     265    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("BÉ").ptr()));
     266    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("z").ptr()));
    267267
    268268    // Find the suffix.
    269     EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("g").get()));
    270     EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("efg").get()));
    271     EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éefg").get()));
    272     EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("G").get()));
    273     EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("EFG").get()));
    274     EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éEFG").get()));
    275 
    276     EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("g").get()));
    277     EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("efg").get()));
    278     EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Éefg").get()));
    279     EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("G").get()));
    280     EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("EFG").get()));
    281     EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉEFG").get()));
     269    EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("g").ptr()));
     270    EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("efg").ptr()));
     271    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éefg").ptr()));
     272    EXPECT_EQ(static_cast<size_t>(6), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("G").ptr()));
     273    EXPECT_EQ(static_cast<size_t>(4), referenceA->findIgnoringASCIICase(stringFromUTF8("EFG").ptr()));
     274    EXPECT_EQ(static_cast<size_t>(3), referenceA->findIgnoringASCIICase(stringFromUTF8("éEFG").ptr()));
     275
     276    EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("g").ptr()));
     277    EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("efg").ptr()));
     278    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("Éefg").ptr()));
     279    EXPECT_EQ(static_cast<size_t>(6), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("G").ptr()));
     280    EXPECT_EQ(static_cast<size_t>(4), referenceB->findIgnoringASCIICase(stringFromUTF8("EFG").ptr()));
     281    EXPECT_EQ(static_cast<size_t>(3), referenceB->findIgnoringASCIICase(stringFromUTF8("ÉEFG").ptr()));
    282282
    283283    // Not a suffix.
    284     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").get()));
    285     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("edg").get()));
    286     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Éefg").get()));
    287     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("w").get()));
    288     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("dFG").get()));
    289     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ÉEFG").get()));
    290 
    291     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Z").get()));
    292     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ffg").get()));
    293     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éefg").get()));
    294     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("r").get()));
    295     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("EgG").get()));
    296     EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éEFG").get()));
     284    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("X").ptr()));
     285    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("edg").ptr()));
     286    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("Éefg").ptr()));
     287    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(StringImpl::createFromLiteral("w").ptr()));
     288    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("dFG").ptr()));
     289    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceA->findIgnoringASCIICase(stringFromUTF8("ÉEFG").ptr()));
     290
     291    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("Z").ptr()));
     292    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("ffg").ptr()));
     293    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éefg").ptr()));
     294    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(StringImpl::createFromLiteral("r").ptr()));
     295    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("EgG").ptr()));
     296    EXPECT_EQ(static_cast<size_t>(WTF::notFound), referenceB->findIgnoringASCIICase(stringFromUTF8("éEFG").ptr()));
    297297}
    298298
    299299TEST(WTF, StringImplFindIgnoringASCIICaseWithValidOffset)
    300300{
    301     RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFGaBcéeFG");
    302     EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 0));
    303     EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 1));
    304     EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 0));
    305     EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 1));
    306     EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").get(), 0));
    307     EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").get(), 1));
     301    auto reference = stringFromUTF8("ABCÉEFGaBcéeFG");
     302    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 0));
     303    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 1));
     304    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 0));
     305    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 1));
     306    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr(), 0));
     307    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(stringFromUTF8("ABCé").ptr(), 1));
    308308}
    309309
    310310TEST(WTF, StringImplFindIgnoringASCIICaseWithInvalidOffset)
    311311{
    312     RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFGaBcéeFG");
    313     EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 15));
    314     EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").get(), 16));
    315     EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 17));
    316     EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), 42));
    317     EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").get(), std::numeric_limits<unsigned>::max()));
     312    auto reference = stringFromUTF8("ABCÉEFGaBcéeFG");
     313    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 15));
     314    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABC").ptr(), 16));
     315    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 17));
     316    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), 42));
     317    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(stringFromUTF8("ABCÉ").ptr(), std::numeric_limits<unsigned>::max()));
    318318}
    319319
    320320TEST(WTF, StringImplFindIgnoringASCIICaseOnNull)
    321321{
    322     RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFG");
     322    auto reference = stringFromUTF8("ABCÉEFG");
    323323    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr));
    324324    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(nullptr, 0));
    … …  
    332332TEST(WTF, StringImplFindIgnoringASCIICaseOnEmpty)
    333333{
    334     RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFG");
    335     RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
    336     EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.get()));
    337     EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.get(), 0));
    338     EXPECT_EQ(static_cast<size_t>(3), reference->findIgnoringASCIICase(empty.get(), 3));
    339     EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), 7));
    340     EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), 8));
    341     EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), 42));
    342     EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.get(), std::numeric_limits<unsigned>::max()));
     334    auto reference = stringFromUTF8("ABCÉEFG");
     335    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
     336    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.ptr()));
     337    EXPECT_EQ(static_cast<size_t>(0), reference->findIgnoringASCIICase(empty.ptr(), 0));
     338    EXPECT_EQ(static_cast<size_t>(3), reference->findIgnoringASCIICase(empty.ptr(), 3));
     339    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), 7));
     340    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), 8));
     341    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), 42));
     342    EXPECT_EQ(static_cast<size_t>(7), reference->findIgnoringASCIICase(empty.ptr(), std::numeric_limits<unsigned>::max()));
    343343}
    344344
    345345TEST(WTF, StringImplFindIgnoringASCIICaseWithPatternLongerThanReference)
    346346{
    347     RefPtr<StringImpl> reference = stringFromUTF8("ABCÉEFG");
    348     RefPtr<StringImpl> pattern = stringFromUTF8("XABCÉEFG");
    349     EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(pattern.get()));
    350     EXPECT_EQ(static_cast<size_t>(1), pattern->findIgnoringASCIICase(reference.get()));
     347    auto reference = stringFromUTF8("ABCÉEFG");
     348    auto pattern = stringFromUTF8("XABCÉEFG");
     349    EXPECT_EQ(static_cast<size_t>(WTF::notFound), reference->findIgnoringASCIICase(pattern.ptr()));
     350    EXPECT_EQ(static_cast<size_t>(1), pattern->findIgnoringASCIICase(reference.ptr()));
    351351}
    352352
    353353TEST(WTF, StringImplStartsWithIgnoringASCIICaseBasic)
    354354{
    355     RefPtr<StringImpl> reference = stringFromUTF8("aBcéX");
    356     RefPtr<StringImpl> referenceEquivalent = stringFromUTF8("AbCéx");
     355    auto reference = stringFromUTF8("aBcéX");
     356    auto referenceEquivalent = stringFromUTF8("AbCéx");
    357357
    358358    // Identity.
    359     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(reference.get()));
    360     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*reference.get()));
    361     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(referenceEquivalent.get()));
    362     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*referenceEquivalent.get()));
    363     ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(reference.get()));
    364     ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(*reference.get()));
    365     ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(referenceEquivalent.get()));
    366     ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(*referenceEquivalent.get()));
     359    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(reference.ptr()));
     360    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*reference.ptr()));
     361    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(referenceEquivalent.ptr()));
     362    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
     363    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(reference.ptr()));
     364    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(*reference.ptr()));
     365    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(referenceEquivalent.ptr()));
     366    ASSERT_TRUE(referenceEquivalent->startsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
    367367
    368368    // Proper prefixes.
    369     RefPtr<StringImpl> aLower = StringImpl::createFromLiteral("a");
    370     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(aLower.get()));
    371     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*aLower.get()));
    372     RefPtr<StringImpl> aUpper = StringImpl::createFromLiteral("A");
    373     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(aUpper.get()));
    374     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*aUpper.get()));
    375 
    376     RefPtr<StringImpl> abcLower = StringImpl::createFromLiteral("abc");
    377     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcLower.get()));
    378     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcLower.get()));
    379     RefPtr<StringImpl> abcUpper = StringImpl::createFromLiteral("ABC");
    380     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcUpper.get()));
    381     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcUpper.get()));
    382 
    383     RefPtr<StringImpl> abcAccentLower = stringFromUTF8("abcé");
    384     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentLower.get()));
    385     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentLower.get()));
    386     RefPtr<StringImpl> abcAccentUpper = stringFromUTF8("ABCé");
    387     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentUpper.get()));
    388     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentUpper.get()));
     369    auto aLower = StringImpl::createFromLiteral("a");
     370    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(aLower.ptr()));
     371    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*aLower.ptr()));
     372    auto aUpper = StringImpl::createFromLiteral("A");
     373    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(aUpper.ptr()));
     374    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*aUpper.ptr()));
     375
     376    auto abcLower = StringImpl::createFromLiteral("abc");
     377    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcLower.ptr()));
     378    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcLower.ptr()));
     379    auto abcUpper = StringImpl::createFromLiteral("ABC");
     380    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcUpper.ptr()));
     381    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcUpper.ptr()));
     382
     383    auto abcAccentLower = stringFromUTF8("abcé");
     384    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentLower.ptr()));
     385    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentLower.ptr()));
     386    auto abcAccentUpper = stringFromUTF8("ABCé");
     387    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(abcAccentUpper.ptr()));
     388    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*abcAccentUpper.ptr()));
    389389
    390390    // Negative cases.
    391     RefPtr<StringImpl> differentFirstChar = stringFromUTF8("bBcéX");
    392     RefPtr<StringImpl> differentFirstCharProperPrefix = stringFromUTF8("CBcé");
    393     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(differentFirstChar.get()));
    394     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstChar.get()));
    395     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(differentFirstCharProperPrefix.get()));
    396     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstCharProperPrefix.get()));
    397 
    398     RefPtr<StringImpl> uppercaseAccent = stringFromUTF8("aBcÉX");
    399     RefPtr<StringImpl> uppercaseAccentProperPrefix = stringFromUTF8("aBcÉX");
    400     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(uppercaseAccent.get()));
    401     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*uppercaseAccent.get()));
    402     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(uppercaseAccentProperPrefix.get()));
    403     ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*uppercaseAccentProperPrefix.get()));
     391    auto differentFirstChar = stringFromUTF8("bBcéX");
     392    auto differentFirstCharProperPrefix = stringFromUTF8("CBcé");
     393    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(differentFirstChar.ptr()));
     394    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstChar.ptr()));
     395    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(differentFirstCharProperPrefix.ptr()));
     396    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*differentFirstCharProperPrefix.ptr()));
     397
     398    auto uppercaseAccent = stringFromUTF8("aBcÉX");
     399    auto uppercaseAccentProperPrefix = stringFromUTF8("aBcÉX");
     400    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(uppercaseAccent.ptr()));
     401    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*uppercaseAccent.ptr()));
     402    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(uppercaseAccentProperPrefix.ptr()));
     403    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(*uppercaseAccentProperPrefix.ptr()));
    404404}
    405405
    406406TEST(WTF, StringImplStartsWithIgnoringASCIICaseWithNull)
    407407{
    408     RefPtr<StringImpl> reference = StringImpl::createFromLiteral("aBcDeFG");
     408    auto reference = StringImpl::createFromLiteral("aBcDeFG");
    409409    ASSERT_FALSE(reference->startsWithIgnoringASCIICase(nullptr));
    410410
    411     RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
     411    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
    412412    ASSERT_FALSE(empty->startsWithIgnoringASCIICase(nullptr));
    413413}
    … …  
    415415TEST(WTF, StringImplStartsWithIgnoringASCIICaseWithEmpty)
    416416{
    417     RefPtr<StringImpl> reference = StringImpl::createFromLiteral("aBcDeFG");
    418     RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
    419     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(empty.get()));
    420     ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*empty.get()));
    421     ASSERT_TRUE(empty->startsWithIgnoringASCIICase(empty.get()));
    422     ASSERT_TRUE(empty->startsWithIgnoringASCIICase(*empty.get()));
    423     ASSERT_FALSE(empty->startsWithIgnoringASCIICase(reference.get()));
    424     ASSERT_FALSE(empty->startsWithIgnoringASCIICase(*reference.get()));
     417    auto reference = StringImpl::createFromLiteral("aBcDeFG");
     418    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
     419    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(empty.ptr()));
     420    ASSERT_TRUE(reference->startsWithIgnoringASCIICase(*empty.ptr()));
     421    ASSERT_TRUE(empty->startsWithIgnoringASCIICase(empty.ptr()));
     422    ASSERT_TRUE(empty->startsWithIgnoringASCIICase(*empty.ptr()));
     423    ASSERT_FALSE(empty->startsWithIgnoringASCIICase(reference.ptr()));
     424    ASSERT_FALSE(empty->startsWithIgnoringASCIICase(*reference.ptr()));
    425425}
    426426
    … …  
    442442TEST(WTF, StringImplEndsWithIgnoringASCIICaseBasic)
    443443{
    444     RefPtr<StringImpl> reference = stringFromUTF8("XÉCbA");
    445     RefPtr<StringImpl> referenceEquivalent = stringFromUTF8("xÉcBa");
     444    auto reference = stringFromUTF8("XÉCbA");
     445    auto referenceEquivalent = stringFromUTF8("xÉcBa");
    446446
    447447    // Identity.
    448     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(reference.get()));
    449     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*reference.get()));
    450     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(referenceEquivalent.get()));
    451     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*referenceEquivalent.get()));
    452     ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(reference.get()));
    453     ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(*reference.get()));
    454     ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(referenceEquivalent.get()));
    455     ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(*referenceEquivalent.get()));
     448    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(reference.ptr()));
     449    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*reference.ptr()));
     450    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(referenceEquivalent.ptr()));
     451    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
     452    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(reference.ptr()));
     453    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(*reference.ptr()));
     454    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(referenceEquivalent.ptr()));
     455    ASSERT_TRUE(referenceEquivalent->endsWithIgnoringASCIICase(*referenceEquivalent.ptr()));
    456456
    457457    // Proper suffixes.
    458     RefPtr<StringImpl> aLower = StringImpl::createFromLiteral("a");
    459     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(aLower.get()));
    460     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*aLower.get()));
    461     RefPtr<StringImpl> aUpper = StringImpl::createFromLiteral("a");
    462     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(aUpper.get()));
    463     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*aUpper.get()));
    464 
    465     RefPtr<StringImpl> abcLower = StringImpl::createFromLiteral("cba");
    466     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcLower.get()));
    467     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcLower.get()));
    468     RefPtr<StringImpl> abcUpper = StringImpl::createFromLiteral("CBA");
    469     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcUpper.get()));
    470     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcUpper.get()));
    471 
    472     RefPtr<StringImpl> abcAccentLower = stringFromUTF8("Écba");
    473     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentLower.get()));
    474     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentLower.get()));
    475     RefPtr<StringImpl> abcAccentUpper = stringFromUTF8("ÉCBA");
    476     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentUpper.get()));
    477     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentUpper.get()));
     458    auto aLower = StringImpl::createFromLiteral("a");
     459    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(aLower.ptr()));
     460    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*aLower.ptr()));
     461    auto aUpper = StringImpl::createFromLiteral("a");
     462    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(aUpper.ptr()));
     463    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*aUpper.ptr()));
     464
     465    auto abcLower = StringImpl::createFromLiteral("cba");
     466    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcLower.ptr()));
     467    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcLower.ptr()));
     468    auto abcUpper = StringImpl::createFromLiteral("CBA");
     469    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcUpper.ptr()));
     470    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcUpper.ptr()));
     471
     472    auto abcAccentLower = stringFromUTF8("Écba");
     473    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentLower.ptr()));
     474    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentLower.ptr()));
     475    auto abcAccentUpper = stringFromUTF8("ÉCBA");
     476    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(abcAccentUpper.ptr()));
     477    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*abcAccentUpper.ptr()));
    478478
    479479    // Negative cases.
    480     RefPtr<StringImpl> differentLastChar = stringFromUTF8("XÉCbB");
    481     RefPtr<StringImpl> differentLastCharProperSuffix = stringFromUTF8("ÉCbb");
    482     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(differentLastChar.get()));
    483     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastChar.get()));
    484     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(differentLastCharProperSuffix.get()));
    485     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastCharProperSuffix.get()));
    486 
    487     RefPtr<StringImpl> lowercaseAccent = stringFromUTF8("aBcéX");
    488     RefPtr<StringImpl> loweraseAccentProperSuffix = stringFromUTF8("aBcéX");
    489     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(lowercaseAccent.get()));
    490     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*lowercaseAccent.get()));
    491     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(loweraseAccentProperSuffix.get()));
    492     ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*loweraseAccentProperSuffix.get()));
     480    auto differentLastChar = stringFromUTF8("XÉCbB");
     481    auto differentLastCharProperSuffix = stringFromUTF8("ÉCbb");
     482    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(differentLastChar.ptr()));
     483    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastChar.ptr()));
     484    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(differentLastCharProperSuffix.ptr()));
     485    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*differentLastCharProperSuffix.ptr()));
     486
     487    auto lowercaseAccent = stringFromUTF8("aBcéX");
     488    auto loweraseAccentProperSuffix = stringFromUTF8("aBcéX");
     489    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(lowercaseAccent.ptr()));
     490    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*lowercaseAccent.ptr()));
     491    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(loweraseAccentProperSuffix.ptr()));
     492    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(*loweraseAccentProperSuffix.ptr()));
    493493}
    494494
    495495TEST(WTF, StringImplEndsWithIgnoringASCIICaseWithNull)
    496496{
    497     RefPtr<StringImpl> reference = StringImpl::createFromLiteral("aBcDeFG");
     497    auto reference = StringImpl::createFromLiteral("aBcDeFG");
    498498    ASSERT_FALSE(reference->endsWithIgnoringASCIICase(nullptr));
    499499
    500     RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
     500    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
    501501    ASSERT_FALSE(empty->endsWithIgnoringASCIICase(nullptr));
    502502}
    … …  
    504504TEST(WTF, StringImplEndsWithIgnoringASCIICaseWithEmpty)
    505505{
    506     RefPtr<StringImpl> reference = StringImpl::createFromLiteral("aBcDeFG");
    507     RefPtr<StringImpl> empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
    508     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(empty.get()));
    509     ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*empty.get()));
    510     ASSERT_TRUE(empty->endsWithIgnoringASCIICase(empty.get()));
    511     ASSERT_TRUE(empty->endsWithIgnoringASCIICase(*empty.get()));
    512     ASSERT_FALSE(empty->endsWithIgnoringASCIICase(reference.get()));
    513     ASSERT_FALSE(empty->endsWithIgnoringASCIICase(*reference.get()));
     506    auto reference = StringImpl::createFromLiteral("aBcDeFG");
     507    auto empty = StringImpl::create(reinterpret_cast<const LChar*>(""));
     508    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(empty.ptr()));
     509    ASSERT_TRUE(reference->endsWithIgnoringASCIICase(*empty.ptr()));
     510    ASSERT_TRUE(empty->endsWithIgnoringASCIICase(empty.ptr()));
     511    ASSERT_TRUE(empty->endsWithIgnoringASCIICase(*empty.ptr()));
     512    ASSERT_FALSE(empty->endsWithIgnoringASCIICase(reference.ptr()));
     513    ASSERT_FALSE(empty->endsWithIgnoringASCIICase(*reference.ptr()));
    514514}
    515515
    516516TEST(WTF, StringImplCreateNullSymbol)
    517517{
    518     RefPtr<StringImpl> reference = StringImpl::createNullSymbol();
     518    auto reference = StringImpl::createNullSymbol();
    519519    ASSERT_TRUE(reference->isSymbol());
    520520    ASSERT_TRUE(reference->isNullSymbol());
    521521    ASSERT_FALSE(reference->isAtomic());
    522522    ASSERT_EQ(0u, reference->length());
    523     ASSERT_TRUE(equal(reference.get(), ""));
     523    ASSERT_TRUE(equal(reference.ptr(), ""));
    524524}
    525525
    526526TEST(WTF, StringImplCreateSymbol)
    527527{
    528     RefPtr<StringImpl> original = stringFromUTF8("original");
    529     RefPtr<StringImpl> reference = StringImpl::createSymbol(original);
     528    auto original = stringFromUTF8("original");
     529    auto reference = StringImpl::createSymbol(original);
    530530    ASSERT_TRUE(reference->isSymbol());
    531531    ASSERT_FALSE(reference->isNullSymbol());
    … …  
    534534    ASSERT_FALSE(original->isAtomic());
    535535    ASSERT_EQ(original->length(), reference->length());
    536     ASSERT_TRUE(equal(reference.get(), "original"));
    537 
    538     RefPtr<StringImpl> empty = stringFromUTF8("");
    539     RefPtr<StringImpl> emptyReference = StringImpl::createSymbol(empty);
     536    ASSERT_TRUE(equal(reference.ptr(), "original"));
     537
     538    auto empty = stringFromUTF8("");
     539    auto emptyReference = StringImpl::createSymbol(empty);
    540540    ASSERT_TRUE(emptyReference->isSymbol());
    541541    ASSERT_FALSE(emptyReference->isNullSymbol());
    … …  
    545545    ASSERT_TRUE(empty->isAtomic());
    546546    ASSERT_EQ(empty->length(), emptyReference->length());
    547     ASSERT_TRUE(equal(emptyReference.get(), ""));
     547    ASSERT_TRUE(equal(emptyReference.ptr(), ""));
    548548}
    549549
    550550TEST(WTF, StringImplSymbolToAtomicString)
    551551{
    552     RefPtr<StringImpl> original = stringFromUTF8("original");
    553     RefPtr<StringImpl> reference = StringImpl::createSymbol(original);
     552    auto original = stringFromUTF8("original");
     553    auto reference = StringImpl::createSymbol(original);
    554554    ASSERT_TRUE(reference->isSymbol());
    555555    ASSERT_FALSE(reference->isAtomic());
    556556
    557     RefPtr<StringImpl> atomic = AtomicStringImpl::add(reference.get());
     557    auto atomic = AtomicStringImpl::add(reference.ptr());
    558558    ASSERT_TRUE(atomic->isAtomic());
    559559    ASSERT_FALSE(atomic->isSymbol());
    … …  
    564564TEST(WTF, StringImplNullSymbolToAtomicString)
    565565{
    566     RefPtr<StringImpl> reference = StringImpl::createNullSymbol();
     566    auto reference = StringImpl::createNullSymbol();
    567567    ASSERT_TRUE(reference->isSymbol());
    568568    ASSERT_FALSE(reference->isAtomic());
    569569
    570     RefPtr<StringImpl> atomic = AtomicStringImpl::add(reference.get());
     570    auto atomic = AtomicStringImpl::add(reference.ptr());
    571571    ASSERT_TRUE(atomic->isAtomic());
    572572    ASSERT_FALSE(atomic->isSymbol());
Note: See TracChangeset for help on using the changeset viewer.