Changeset 246636 in webkit


Ignore:
Timestamp:
Jun 20, 2019 9:21:50 AM (5 years ago)
Author:
Darin Adler
Message:

Tidy up the remaining bits of the AtomicString to AtomString rename
https://bugs.webkit.org/show_bug.cgi?id=198990

Reviewed by Michael Catanzaro.

Source/JavaScriptCore:

  • dfg/DFGSpeculativeJIT.cpp:

(JSC::DFG::SpeculativeJIT::speculateStringIdentAndLoadStorage): Use flagIsAtom.

  • dfg/DFGSpeculativeJIT32_64.cpp:

(JSC::DFG::SpeculativeJIT::compile): Ditto.

  • dfg/DFGSpeculativeJIT64.cpp:

(JSC::DFG::SpeculativeJIT::compile): Ditto.

  • ftl/FTLLowerDFGToB3.cpp:

(JSC::FTL::DFG::LowerDFGToB3::compileHasOwnProperty): Ditto.
(JSC::FTL::DFG::LowerDFGToB3::speculateStringIdent): Ditto.

Source/WebCore:

  • bindings/scripts/test/JS/JSTestObj.cpp: Updated names.
  • bindings/scripts/test/TestObj.idl: Ditto.
  • css/makeprop.pl: Updated comment.
  • css/makevalues.pl: Ditto.
  • html/FormController.cpp:

(WebCore::FormKeyGenerator::formKey): Ditto.

Source/WTF:

  • wtf/text/AtomString.cpp: Fix a comment.
  • wtf/text/AtomString.h: Tweak formatting a bit. Use nullptr instead of 0.

Removed "using AtomicString = AtomString".

  • wtf/text/AtomStringImpl.cpp:

(WTF::CStringTranslator::translate): Use setIsAtom instead of setIsAtomic.
(WTF::UCharBufferTranslator::translate): Ditto.
(WTF::HashAndUTF8CharactersTranslator::translate): Ditto.
(WTF::SubstringTranslator::translate): Ditto.
(WTF::LCharBufferTranslator::translate): Ditto.
(WTF::BufferFromStaticDataTranslator::translate): Ditto.
(WTF::AtomStringImpl::addSlowCase): Ditto.
(WTF::AtomStringImpl::lookUpSlowCase): Updated assertion message.

  • wtf/text/AtomStringImpl.h: Tweaked the implementation of add.

Updated comments to say AtomString.

  • wtf/text/AtomStringTable.cpp:

(WTF::AtomStringTable::~AtomStringTable): Use setIsAtom.

  • wtf/text/StringImpl.h: Updated name of StringAtomic and

s_hashFlagStringKindIsAtom. Renamed to flagIsAtom and setIsAtom.

  • wtf/text/WTFString.cpp:

(WTF::String::isSafeToSendToAnotherThread const): Updated comment.

Tools:

  • Scripts/do-webcore-rename: Removed already-done renames.
  • TestWebKitAPI/Tests/WTF/StringImpl.cpp: Rename one use of "atomic".

LayoutTests:

  • js/dopey-rope-with-16-bit-propertyname-expected.txt: Rename to AtomString.
  • js/dopey-rope-with-16-bit-propertyname.html: Ditto.
Location:
trunk
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • trunk/LayoutTests/ChangeLog

    r246631 r246636  
     12019-06-18  Darin Adler  <darin@apple.com>
     2
     3        Tidy up the remaining bits of the AtomicString to AtomString rename
     4        https://bugs.webkit.org/show_bug.cgi?id=198990
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        * js/dopey-rope-with-16-bit-propertyname-expected.txt: Rename to AtomString.
     9        * js/dopey-rope-with-16-bit-propertyname.html: Ditto.
     10
    1112019-06-19  Myles C. Maxfield  <mmaxfield@apple.com>
    212
  • trunk/LayoutTests/js/dopey-rope-with-16-bit-propertyname-expected.txt

    r172727 r246636  
    1 Test that a 16-bit AtomicString containing only 8-bit characters doesn't confuse the JIT into thinking it's an 8-bit AtomicString.
     1Test that a 16-bit AtomString containing only 8-bit characters doesn't confuse the JIT into thinking it's an 8-bit AtomString.
    22
    33On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
  • trunk/LayoutTests/js/dopey-rope-with-16-bit-propertyname.html

    r172727 r246636  
    88<script>
    99
    10 description("Test that a 16-bit AtomicString containing only 8-bit characters doesn't confuse the JIT into thinking it's an 8-bit AtomicString.");
     10description("Test that a 16-bit AtomString containing only 8-bit characters doesn't confuse the JIT into thinking it's an 8-bit AtomString.");
    1111
    1212o = {};
     
    1515var test16bit = stringWithEmoji.substring(0, 4);
    1616
    17 o[test16bit] = "this makes it an AtomicString";
     17o[test16bit] = "this makes it an AtomString";
    1818
    1919globalRope = "";
  • trunk/Source/JavaScriptCore/ChangeLog

    r246620 r246636  
     12019-06-18  Darin Adler  <darin@apple.com>
     2
     3        Tidy up the remaining bits of the AtomicString to AtomString rename
     4        https://bugs.webkit.org/show_bug.cgi?id=198990
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        * dfg/DFGSpeculativeJIT.cpp:
     9        (JSC::DFG::SpeculativeJIT::speculateStringIdentAndLoadStorage): Use flagIsAtom.
     10        * dfg/DFGSpeculativeJIT32_64.cpp:
     11        (JSC::DFG::SpeculativeJIT::compile): Ditto.
     12        * dfg/DFGSpeculativeJIT64.cpp:
     13        (JSC::DFG::SpeculativeJIT::compile): Ditto.
     14        * ftl/FTLLowerDFGToB3.cpp:
     15        (JSC::FTL::DFG::LowerDFGToB3::compileHasOwnProperty): Ditto.
     16        (JSC::FTL::DFG::LowerDFGToB3::speculateStringIdent): Ditto.
     17
    1182019-06-19  Alexey Shvayka  <shvaikalesh@gmail.com>
    219
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT.cpp

    r246563 r246636  
    1028210282            MacroAssembler::Zero,
    1028310283            MacroAssembler::Address(storage, StringImpl::flagsOffset()),
    10284             MacroAssembler::TrustedImm32(StringImpl::flagIsAtomic())));
     10284            MacroAssembler::TrustedImm32(StringImpl::flagIsAtom())));
    1028510285   
    1028610286    m_interpreter.filter(edge, SpecStringIdent | ~SpecString);
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT32_64.cpp

    r246490 r246636  
    39003900            slowPath.append(m_jit.branchTest32(
    39013901                MacroAssembler::Zero, MacroAssembler::Address(implGPR, StringImpl::flagsOffset()),
    3902                 MacroAssembler::TrustedImm32(StringImpl::flagIsAtomic())));
     3902                MacroAssembler::TrustedImm32(StringImpl::flagIsAtom())));
    39033903            break;
    39043904        }
     
    39103910            slowPath.append(m_jit.branchTest32(
    39113911                MacroAssembler::Zero, MacroAssembler::Address(implGPR, StringImpl::flagsOffset()),
    3912                 MacroAssembler::TrustedImm32(StringImpl::flagIsAtomic())));
     3912                MacroAssembler::TrustedImm32(StringImpl::flagIsAtom())));
    39133913            auto hasUniquedImpl = m_jit.jump();
    39143914
  • trunk/Source/JavaScriptCore/dfg/DFGSpeculativeJIT64.cpp

    r246490 r246636  
    44674467            slowPath.append(m_jit.branchTest32(
    44684468                MacroAssembler::Zero, MacroAssembler::Address(implGPR, StringImpl::flagsOffset()),
    4469                 MacroAssembler::TrustedImm32(StringImpl::flagIsAtomic())));
     4469                MacroAssembler::TrustedImm32(StringImpl::flagIsAtom())));
    44704470            break;
    44714471        }
     
    44774477            slowPath.append(m_jit.branchTest32(
    44784478                MacroAssembler::Zero, MacroAssembler::Address(implGPR, StringImpl::flagsOffset()),
    4479                 MacroAssembler::TrustedImm32(StringImpl::flagIsAtomic())));
     4479                MacroAssembler::TrustedImm32(StringImpl::flagIsAtom())));
    44804480            auto hasUniquedImpl = m_jit.jump();
    44814481
  • trunk/Source/JavaScriptCore/ftl/FTLLowerDFGToB3.cpp

    r246563 r246636  
    1046410464            lastNext = m_out.appendTo(isNonEmptyString, isAtomString);
    1046510465            uniquedStringImpl = m_out.loadPtr(keyAsValue, m_heaps.JSString_value);
    10466             LValue isNotAtomic = m_out.testIsZero32(m_out.load32(uniquedStringImpl, m_heaps.StringImpl_hashAndFlags), m_out.constInt32(StringImpl::flagIsAtomic()));
     10466            LValue isNotAtomic = m_out.testIsZero32(m_out.load32(uniquedStringImpl, m_heaps.StringImpl_hashAndFlags), m_out.constInt32(StringImpl::flagIsAtom()));
    1046710467            m_out.branch(isNotAtomic, rarely(slowCase), usually(isAtomString));
    1046810468
     
    1049610496            LValue implFromString = m_out.loadPtr(keyAsValue, m_heaps.JSString_value);
    1049710497            ValueFromBlock stringResult = m_out.anchor(implFromString);
    10498             LValue isNotAtomic = m_out.testIsZero32(m_out.load32(implFromString, m_heaps.StringImpl_hashAndFlags), m_out.constInt32(StringImpl::flagIsAtomic()));
     10498            LValue isNotAtomic = m_out.testIsZero32(m_out.load32(implFromString, m_heaps.StringImpl_hashAndFlags), m_out.constInt32(StringImpl::flagIsAtom()));
    1049910499            m_out.branch(isNotAtomic, rarely(slowCase), usually(hasUniquedStringImpl));
    1050010500
     
    1642216422            m_out.testIsZero32(
    1642316423                m_out.load32(stringImpl, m_heaps.StringImpl_hashAndFlags),
    16424                 m_out.constInt32(StringImpl::flagIsAtomic())));
     16424                m_out.constInt32(StringImpl::flagIsAtom())));
    1642516425        m_interpreter.filter(edge, SpecStringIdent | ~SpecString);
    1642616426    }
  • trunk/Source/WTF/ChangeLog

    r246632 r246636  
     12019-06-18  Darin Adler  <darin@apple.com>
     2
     3        Tidy up the remaining bits of the AtomicString to AtomString rename
     4        https://bugs.webkit.org/show_bug.cgi?id=198990
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        * wtf/text/AtomString.cpp: Fix a comment.
     9        * wtf/text/AtomString.h: Tweak formatting a bit. Use nullptr instead of 0.
     10        Removed "using AtomicString = AtomString".
     11        * wtf/text/AtomStringImpl.cpp:
     12        (WTF::CStringTranslator::translate): Use setIsAtom instead of setIsAtomic.
     13        (WTF::UCharBufferTranslator::translate): Ditto.
     14        (WTF::HashAndUTF8CharactersTranslator::translate): Ditto.
     15        (WTF::SubstringTranslator::translate): Ditto.
     16        (WTF::LCharBufferTranslator::translate): Ditto.
     17        (WTF::BufferFromStaticDataTranslator::translate): Ditto.
     18        (WTF::AtomStringImpl::addSlowCase): Ditto.
     19        (WTF::AtomStringImpl::lookUpSlowCase): Updated assertion message.
     20
     21        * wtf/text/AtomStringImpl.h: Tweaked the implementation of add.
     22        Updated comments to say AtomString.
     23
     24        * wtf/text/AtomStringTable.cpp:
     25        (WTF::AtomStringTable::~AtomStringTable): Use setIsAtom.
     26
     27        * wtf/text/StringImpl.h: Updated name of StringAtomic and
     28        s_hashFlagStringKindIsAtom. Renamed to flagIsAtom and setIsAtom.
     29
     30        * wtf/text/WTFString.cpp:
     31        (WTF::String::isSafeToSendToAnotherThread const): Updated comment.
     32
    1332019-06-20  Carlos Garcia Campos  <cgarcia@igalia.com>
    234
  • trunk/Source/WTF/wtf/text/AtomString.cpp

    r246490 r246636  
    4040
    4141    // Convert short strings without allocating a new StringImpl, since
    42     // there's a good chance these strings are already in the atomic
     42    // there's a good chance these strings are already in the atom
    4343    // string table and so no memory allocation will be required.
    4444    unsigned length;
  • trunk/Source/WTF/wtf/text/AtomString.h

    r246490 r246636  
    11/*
    2  * Copyright (C) 2004-2017 Apple Inc. All rights reserved.
     2 * Copyright (C) 2004-2019 Apple Inc. All rights reserved.
    33 *
    44 * This library is free software; you can redistribute it and/or
     
    9191    const String& string() const { return m_string; };
    9292
    93     AtomStringImpl* impl() const { return static_cast<AtomStringImpl *>(m_string.impl()); }
     93    // FIXME: What guarantees this isn't a SymbolImpl rather than an AtomStringImpl?
     94    AtomStringImpl* impl() const { return static_cast<AtomStringImpl*>(m_string.impl()); }
    9495
    9596    bool is8Bit() const { return m_string.is8Bit(); }
     
    133134    WTF_EXPORT_PRIVATE AtomString convertToASCIIUppercase() const;
    134135
    135     int toInt(bool* ok = 0) const { return m_string.toInt(ok); }
    136     double toDouble(bool* ok = 0) const { return m_string.toDouble(ok); }
    137     float toFloat(bool* ok = 0) const { return m_string.toFloat(ok); }
     136    int toInt(bool* ok = nullptr) const { return m_string.toInt(ok); }
     137    double toDouble(bool* ok = nullptr) const { return m_string.toDouble(ok); }
     138    float toFloat(bool* ok = nullptr) const { return m_string.toFloat(ok); }
    138139    bool percentage(int& p) const { return m_string.percentage(p); }
    139140
     
    146147
    147148#ifdef __OBJC__
    148     AtomString(NSString*);
    149     operator NSString*() const { return m_string; }
     149    AtomString(NSString *);
     150    operator NSString *() const { return m_string; }
    150151#endif
    151152
     
    178179};
    179180
    180 using AtomicString = AtomString;
    181 
    182 static_assert(sizeof(AtomString) == sizeof(String), "AtomString and String must be same size!");
     181static_assert(sizeof(AtomString) == sizeof(String), "AtomString and String must be the same size!");
    183182
    184183inline bool operator==(const AtomString& a, const AtomString& b) { return a.impl() == b.impl(); }
     
    282281#ifdef __OBJC__
    283282
    284 inline AtomString::AtomString(NSString* string)
     283inline AtomString::AtomString(NSString *string)
    285284    : m_string(AtomStringImpl::add((__bridge CFStringRef)string))
    286285{
     
    289288#endif
    290289
    291 // Define external global variables for the commonly used atomic strings.
     290// Define external global variables for the commonly used atom strings.
    292291// These are only usable from the main thread.
    293292extern WTF_EXPORT_PRIVATE LazyNeverDestroyed<AtomString> nullAtomData;
     
    361360
    362361using WTF::AtomString;
    363 using WTF::AtomicString;
    364362using WTF::nullAtom;
    365363using WTF::emptyAtom;
  • trunk/Source/WTF/wtf/text/AtomStringImpl.cpp

    r246490 r246636  
    109109        location = &StringImpl::create(characters).leakRef();
    110110        location->setHash(hash);
    111         location->setIsAtomic(true);
     111        location->setIsAtom(true);
    112112    }
    113113};
     
    160160        location = &StringImpl::create8BitIfPossible(buf.characters, buf.length).leakRef();
    161161        location->setHash(hash);
    162         location->setIsAtomic(true);
     162        location->setIsAtom(true);
    163163    }
    164164};
     
    228228        location = &newString.leakRef();
    229229        location->setHash(hash);
    230         location->setIsAtomic(true);
     230        location->setIsAtom(true);
    231231    }
    232232};
     
    271271        location = &StringImpl::createSubstringSharingImpl(*buffer.baseString, buffer.start, buffer.length).leakRef();
    272272        location->setHash(hash);
    273         location->setIsAtomic(true);
     273        location->setIsAtom(true);
    274274    }
    275275};
     
    336336        location = &StringImpl::create(buf.characters, buf.length).leakRef();
    337337        location->setHash(hash);
    338         location->setIsAtomic(true);
     338        location->setIsAtom(true);
    339339    }
    340340};
     
    357357        location = &StringImpl::createWithoutCopying(buf.characters, buf.length).leakRef();
    358358        location->setHash(hash);
    359         location->setIsAtomic(true);
     359        location->setIsAtom(true);
    360360    }
    361361};
     
    438438        return addSymbol(string);
    439439
    440     ASSERT_WITH_MESSAGE(!string.isAtom(), "AtomStringImpl should not hit the slow case if the string is already atomic.");
     440    ASSERT_WITH_MESSAGE(!string.isAtom(), "AtomStringImpl should not hit the slow case if the string is already an atom.");
    441441
    442442    AtomStringTableLocker locker;
     
    445445    if (addResult.isNewEntry) {
    446446        ASSERT(*addResult.iterator == &string);
    447         string.setIsAtomic(true);
     447        string.setIsAtom(true);
    448448    }
    449449
     
    468468    }
    469469
    470     ASSERT_WITH_MESSAGE(!string.isAtom(), "AtomStringImpl should not hit the slow case if the string is already atomic.");
     470    ASSERT_WITH_MESSAGE(!string.isAtom(), "AtomStringImpl should not hit the slow case if the string is already an atom.");
    471471
    472472    AtomStringTableLocker locker;
     
    475475    if (addResult.isNewEntry) {
    476476        ASSERT(*addResult.iterator == &string);
    477         string.setIsAtomic(true);
     477        string.setIsAtom(true);
    478478    }
    479479
     
    487487    auto& atomStringTable = stringTable();
    488488    auto iterator = atomStringTable.find(string);
    489     ASSERT_WITH_MESSAGE(iterator != atomStringTable.end(), "The string being removed is atomic in the string table of an other thread!");
     489    ASSERT_WITH_MESSAGE(iterator != atomStringTable.end(), "The string being removed is an atom in the string table of an other thread!");
    490490    ASSERT(string == *iterator);
    491491    atomStringTable.remove(iterator);
     
    494494RefPtr<AtomStringImpl> AtomStringImpl::lookUpSlowCase(StringImpl& string)
    495495{
    496     ASSERT_WITH_MESSAGE(!string.isAtom(), "AtomicStringImpls should return from the fast case.");
     496    ASSERT_WITH_MESSAGE(!string.isAtom(), "AtomStringImpl objects should return from the fast case.");
    497497
    498498    if (!string.length())
  • trunk/Source/WTF/wtf/text/AtomStringImpl.h

    r246490 r246636  
    11/*
    2  * Copyright (C) 2006 Apple Inc.
     2 * Copyright (C) 2006-2019 Apple Inc. All rights reserved.
    33 *
    44 * This library is free software; you can redistribute it and/or
     
    5050    {
    5151        if (!string)
    52             return static_cast<AtomStringImpl*>(string);
     52            return nullptr;
    5353        return add(*string);
    5454    }
     
    8181    {
    8282        if (string.isAtom()) {
    83             ASSERT_WITH_MESSAGE(!string.length() || isInAtomStringTable(&string), "The atomic string comes from an other thread!");
     83            ASSERT_WITH_MESSAGE(!string.length() || isInAtomStringTable(&string), "The atom string comes from an other thread!");
    8484            return static_cast<AtomStringImpl&>(string);
    8585        }
     
    9090    {
    9191        if (string.isAtom()) {
    92             ASSERT_WITH_MESSAGE(!string.length() || isInAtomStringTable(&string), "The atomic string comes from an other thread!");
     92            ASSERT_WITH_MESSAGE(!string.length() || isInAtomStringTable(&string), "The atom string comes from an other thread!");
    9393            return static_cast<AtomStringImpl&>(string);
    9494        }
     
    103103
    104104#if !ASSERT_DISABLED
    105 // AtomicStringImpls created from StaticStringImpl will ASSERT
    106 // in the generic ValueCheck<T>::checkConsistency
    107 // as they are not allocated by fastMalloc.
    108 // We don't currently have any way to detect that case
    109 // so we ignore the consistency check for all AtomicStringImpls*.
    110 template<> struct
    111 ValueCheck<AtomStringImpl*> {
     105
     106// AtomStringImpls created from StaticStringImpl will ASSERT in the generic ValueCheck<T>::checkConsistency,
     107// as they are not allocated by fastMalloc. We don't currently have any way to detect that case, so we don't
     108// do any consistency check for AtomStringImpl*.
     109
     110template<> struct ValueCheck<AtomStringImpl*> {
    112111    static void checkConsistency(const AtomStringImpl*) { }
    113112};
    114113
    115 template<> struct
    116 ValueCheck<const AtomStringImpl*> {
     114template<> struct ValueCheck<const AtomStringImpl*> {
    117115    static void checkConsistency(const AtomStringImpl*) { }
    118116};
     117
    119118#endif
    120119
  • trunk/Source/WTF/wtf/text/AtomStringTable.cpp

    r246490 r246636  
    3333{
    3434    for (auto* string : m_table)
    35         string->setIsAtomic(false);
     35        string->setIsAtom(false);
    3636}
    3737
  • trunk/Source/WTF/wtf/text/StringImpl.cpp

    r246490 r246636  
    103103#endif
    104104
    105 StringImpl::StaticStringImpl StringImpl::s_atomicEmptyString("", StringImpl::StringAtomic);
     105StringImpl::StaticStringImpl StringImpl::s_emptyAtomString("", StringImpl::StringAtom);
    106106
    107107StringImpl::~StringImpl()
  • trunk/Source/WTF/wtf/text/StringImpl.h

    r246490 r246636  
    198198    static constexpr const unsigned s_flagStringKindCount = 4;
    199199
    200     static constexpr const unsigned s_hashFlagStringKindIsAtomic = 1u << (s_flagStringKindCount);
     200    static constexpr const unsigned s_hashFlagStringKindIsAtom = 1u << (s_flagStringKindCount);
    201201    static constexpr const unsigned s_hashFlagStringKindIsSymbol = 1u << (s_flagStringKindCount + 1);
    202     static constexpr const unsigned s_hashMaskStringKind = s_hashFlagStringKindIsAtomic | s_hashFlagStringKindIsSymbol;
     202    static constexpr const unsigned s_hashMaskStringKind = s_hashFlagStringKindIsAtom | s_hashFlagStringKindIsSymbol;
    203203    static constexpr const unsigned s_hashFlagDidReportCost = 1u << 3;
    204204    static constexpr const unsigned s_hashFlag8BitBuffer = 1u << 2;
     
    207207    enum StringKind {
    208208        StringNormal = 0u, // non-symbol, non-atomic
    209         StringAtomic = s_hashFlagStringKindIsAtomic, // non-symbol, atomic
     209        StringAtom = s_hashFlagStringKindIsAtom, // non-symbol, atomic
    210210        StringSymbol = s_hashFlagStringKindIsSymbol, // symbol, non-atomic
    211211    };
     
    266266    static unsigned flagsOffset() { return OBJECT_OFFSETOF(StringImpl, m_hashAndFlags); }
    267267    static constexpr unsigned flagIs8Bit() { return s_hashFlag8BitBuffer; }
    268     static constexpr unsigned flagIsAtomic() { return s_hashFlagStringKindIsAtomic; }
     268    static constexpr unsigned flagIsAtom() { return s_hashFlagStringKindIsAtom; }
    269269    static constexpr unsigned flagIsSymbol() { return s_hashFlagStringKindIsSymbol; }
    270270    static constexpr unsigned maskStringKind() { return s_hashMaskStringKind; }
     
    293293
    294294    bool isSymbol() const { return m_hashAndFlags & s_hashFlagStringKindIsSymbol; }
    295     bool isAtom() const { return m_hashAndFlags & s_hashFlagStringKindIsAtomic; }
    296     void setIsAtomic(bool);
     295    bool isAtom() const { return m_hashAndFlags & s_hashFlagStringKindIsAtom; }
     296    void setIsAtom(bool);
    297297   
    298298    bool isExternal() const { return bufferOwnership() == BufferExternal; }
     
    360360        //       be a finite set of StaticStringImpls, their cost can be aggregated into a single
    361361        //       system cost if needed.
    362         //    b. setIsAtomic() is never called on a StaticStringImpl.
    363         //       setIsAtomic() asserts !isStatic().
     362        //    b. setIsAtom() is never called on a StaticStringImpl.
     363        //       setIsAtom() asserts !isStatic().
    364364        //    c. setHash() is never called on a StaticStringImpl.
    365365        //       StaticStringImpl's constructor sets the hash on construction.
     
    372372    };
    373373
    374     WTF_EXPORT_PRIVATE static StaticStringImpl s_atomicEmptyString;
    375     ALWAYS_INLINE static StringImpl* empty() { return reinterpret_cast<StringImpl*>(&s_atomicEmptyString); }
     374    WTF_EXPORT_PRIVATE static StaticStringImpl s_emptyAtomString;
     375    ALWAYS_INLINE static StringImpl* empty() { return reinterpret_cast<StringImpl*>(&s_emptyAtomString); }
    376376
    377377    // FIXME: Does this really belong in StringImpl?
     
    10321032}
    10331033
    1034 inline void StringImpl::setIsAtomic(bool isAtom)
     1034inline void StringImpl::setIsAtom(bool isAtom)
    10351035{
    10361036    ASSERT(!isStatic());
    10371037    ASSERT(!isSymbol());
    10381038    if (isAtom)
    1039         m_hashAndFlags |= s_hashFlagStringKindIsAtomic;
     1039        m_hashAndFlags |= s_hashFlagStringKindIsAtom;
    10401040    else
    1041         m_hashAndFlags &= ~s_hashFlagStringKindIsAtomic;
     1041        m_hashAndFlags &= ~s_hashFlagStringKindIsAtom;
    10421042}
    10431043
  • trunk/Source/WTF/wtf/text/WTFString.cpp

    r246490 r246636  
    11/*
    22 * (C) 1999 Lars Knoll (knoll@kde.org)
    3  * Copyright (C) 2004-2017 Apple Inc. All rights reserved.
     3 * Copyright (C) 2004-2019 Apple Inc. All rights reserved.
    44 * Copyright (C) 2007-2009 Torch Mobile, Inc.
    55 *
     
    649649bool String::isSafeToSendToAnotherThread() const
    650650{
    651     // AtomicStrings are not safe to send between threads as ~StringImpl()
     651    // AtomStrings are not safe to send between threads, as ~StringImpl()
    652652    // will try to remove them from the wrong AtomStringTable.
    653653    return isEmpty() || (m_impl->hasOneRef() && !m_impl->isAtom());
  • trunk/Source/WebCore/ChangeLog

    r246634 r246636  
     12019-06-18  Darin Adler  <darin@apple.com>
     2
     3        Tidy up the remaining bits of the AtomicString to AtomString rename
     4        https://bugs.webkit.org/show_bug.cgi?id=198990
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        * bindings/scripts/test/JS/JSTestObj.cpp: Updated names.
     9        * bindings/scripts/test/TestObj.idl: Ditto.
     10
     11        * css/makeprop.pl: Updated comment.
     12        * css/makevalues.pl: Ditto.
     13        * html/FormController.cpp:
     14        (WebCore::FormKeyGenerator::formKey): Ditto.
     15
    1162019-06-20  Zalan Bujtas  <zalan@apple.com>
    217
  • trunk/Source/WebCore/bindings/scripts/test/JS/JSTestObj.cpp

    r246490 r246636  
    14871487JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalString(JSC::ExecState*);
    14881488JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUSVString(JSC::ExecState*);
    1489 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicString(JSC::ExecState*);
     1489JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomString(JSC::ExecState*);
    14901490JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue(JSC::ExecState*);
    1491 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue(JSC::ExecState*);
     1491JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomStringAndDefaultValue(JSC::ExecState*);
    14921492JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull(JSC::ExecState*);
    14931493JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined(JSC::ExecState*);
    1494 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull(JSC::ExecState*);
     1494JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsNull(JSC::ExecState*);
    14951495JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString(JSC::ExecState*);
    14961496JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalUSVStringIsEmptyString(JSC::ExecState*);
    1497 JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString(JSC::ExecState*);
     1497JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsEmptyString(JSC::ExecState*);
    14981498JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN(JSC::ExecState*);
    14991499JSC::EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN(JSC::ExecState*);
     
    22042204    { "methodWithOptionalString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalString), (intptr_t) (0) } },
    22052205    { "methodWithOptionalUSVString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUSVString), (intptr_t) (0) } },
    2206     { "methodWithOptionalAtomicString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicString), (intptr_t) (0) } },
     2206    { "methodWithOptionalAtomString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomString), (intptr_t) (0) } },
    22072207    { "methodWithOptionalStringAndDefaultValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringAndDefaultValue), (intptr_t) (0) } },
    2208     { "methodWithOptionalAtomicStringAndDefaultValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue), (intptr_t) (0) } },
     2208    { "methodWithOptionalAtomStringAndDefaultValue", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomStringAndDefaultValue), (intptr_t) (0) } },
    22092209    { "methodWithOptionalStringIsNull", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsNull), (intptr_t) (0) } },
    22102210    { "methodWithOptionalStringIsUndefined", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsUndefined), (intptr_t) (0) } },
    2211     { "methodWithOptionalAtomicStringIsNull", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull), (intptr_t) (0) } },
     2211    { "methodWithOptionalAtomStringIsNull", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsNull), (intptr_t) (0) } },
    22122212    { "methodWithOptionalStringIsEmptyString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalStringIsEmptyString), (intptr_t) (0) } },
    22132213    { "methodWithOptionalUSVStringIsEmptyString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalUSVStringIsEmptyString), (intptr_t) (0) } },
    2214     { "methodWithOptionalAtomicStringIsEmptyString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString), (intptr_t) (0) } },
     2214    { "methodWithOptionalAtomStringIsEmptyString", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsEmptyString), (intptr_t) (0) } },
    22152215    { "methodWithOptionalDoubleIsNaN", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalDoubleIsNaN), (intptr_t) (0) } },
    22162216    { "methodWithOptionalFloatIsNaN", static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { (intptr_t)static_cast<RawNativeFunction>(jsTestObjPrototypeFunctionMethodWithOptionalFloatIsNaN), (intptr_t) (0) } },
     
    64496449}
    64506450
    6451 static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
     6451static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomStringBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
    64526452{
    64536453    UNUSED_PARAM(state);
     
    64566456    auto str = state->argument(0).isUndefined() ? nullAtom() : convert<IDLAtomStringAdaptor<IDLDOMString>>(*state, state->uncheckedArgument(0));
    64576457    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    6458     impl.methodWithOptionalAtomicString(WTFMove(str));
    6459     return JSValue::encode(jsUndefined());
    6460 }
    6461 
    6462 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicString(ExecState* state)
    6463 {
    6464     return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringBody>(*state, "methodWithOptionalAtomicString");
     6458    impl.methodWithOptionalAtomString(WTFMove(str));
     6459    return JSValue::encode(jsUndefined());
     6460}
     6461
     6462EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomString(ExecState* state)
     6463{
     6464    return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomStringBody>(*state, "methodWithOptionalAtomString");
    64656465}
    64666466
     
    64816481}
    64826482
    6483 static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValueBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
     6483static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomStringAndDefaultValueBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
    64846484{
    64856485    UNUSED_PARAM(state);
     
    64886488    auto str = state->argument(0).isUndefined() ? AtomString("foo", AtomString::ConstructFromLiteral) : convert<IDLAtomStringAdaptor<IDLDOMString>>(*state, state->uncheckedArgument(0));
    64896489    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    6490     impl.methodWithOptionalAtomicStringAndDefaultValue(WTFMove(str));
    6491     return JSValue::encode(jsUndefined());
    6492 }
    6493 
    6494 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValue(ExecState* state)
    6495 {
    6496     return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringAndDefaultValueBody>(*state, "methodWithOptionalAtomicStringAndDefaultValue");
     6490    impl.methodWithOptionalAtomStringAndDefaultValue(WTFMove(str));
     6491    return JSValue::encode(jsUndefined());
     6492}
     6493
     6494EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomStringAndDefaultValue(ExecState* state)
     6495{
     6496    return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomStringAndDefaultValueBody>(*state, "methodWithOptionalAtomStringAndDefaultValue");
    64976497}
    64986498
     
    65296529}
    65306530
    6531 static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNullBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
     6531static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsNullBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
    65326532{
    65336533    UNUSED_PARAM(state);
     
    65366536    auto str = state->argument(0).isUndefined() ? nullAtom() : convert<IDLAtomStringAdaptor<IDLDOMString>>(*state, state->uncheckedArgument(0));
    65376537    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    6538     impl.methodWithOptionalAtomicStringIsNull(WTFMove(str));
    6539     return JSValue::encode(jsUndefined());
    6540 }
    6541 
    6542 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNull(ExecState* state)
    6543 {
    6544     return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsNullBody>(*state, "methodWithOptionalAtomicStringIsNull");
     6538    impl.methodWithOptionalAtomStringIsNull(WTFMove(str));
     6539    return JSValue::encode(jsUndefined());
     6540}
     6541
     6542EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsNull(ExecState* state)
     6543{
     6544    return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsNullBody>(*state, "methodWithOptionalAtomStringIsNull");
    65456545}
    65466546
     
    65776577}
    65786578
    6579 static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyStringBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
     6579static inline JSC::EncodedJSValue jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsEmptyStringBody(JSC::ExecState* state, typename IDLOperation<JSTestObj>::ClassParameter castedThis, JSC::ThrowScope& throwScope)
    65806580{
    65816581    UNUSED_PARAM(state);
     
    65846584    auto str = state->argument(0).isUndefined() ? emptyAtom() : convert<IDLAtomStringAdaptor<IDLDOMString>>(*state, state->uncheckedArgument(0));
    65856585    RETURN_IF_EXCEPTION(throwScope, encodedJSValue());
    6586     impl.methodWithOptionalAtomicStringIsEmptyString(WTFMove(str));
    6587     return JSValue::encode(jsUndefined());
    6588 }
    6589 
    6590 EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyString(ExecState* state)
    6591 {
    6592     return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomicStringIsEmptyStringBody>(*state, "methodWithOptionalAtomicStringIsEmptyString");
     6586    impl.methodWithOptionalAtomStringIsEmptyString(WTFMove(str));
     6587    return JSValue::encode(jsUndefined());
     6588}
     6589
     6590EncodedJSValue JSC_HOST_CALL jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsEmptyString(ExecState* state)
     6591{
     6592    return IDLOperation<JSTestObj>::call<jsTestObjPrototypeFunctionMethodWithOptionalAtomStringIsEmptyStringBody>(*state, "methodWithOptionalAtomStringIsEmptyString");
    65936593}
    65946594
  • trunk/Source/WebCore/bindings/scripts/test/TestObj.idl

    r246490 r246636  
    221221    void    methodWithOptionalString(optional DOMString str);
    222222    void    methodWithOptionalUSVString(optional USVString str);
    223     void    methodWithOptionalAtomicString(optional [AtomString] DOMString str);
     223    void    methodWithOptionalAtomString(optional [AtomString] DOMString str);
    224224    void    methodWithOptionalStringAndDefaultValue(optional DOMString str = "foo");
    225     void    methodWithOptionalAtomicStringAndDefaultValue(optional [AtomString] DOMString str = "foo");
     225    void    methodWithOptionalAtomStringAndDefaultValue(optional [AtomString] DOMString str = "foo");
    226226    void    methodWithOptionalStringIsNull(optional DOMString str = null);
    227227    void    methodWithOptionalStringIsUndefined(optional DOMString str = "undefined");
    228     void    methodWithOptionalAtomicStringIsNull(optional [AtomString] DOMString str = null);
     228    void    methodWithOptionalAtomStringIsNull(optional [AtomString] DOMString str = null);
    229229    void    methodWithOptionalStringIsEmptyString(optional DOMString str = "");
    230230    void    methodWithOptionalUSVStringIsEmptyString(optional USVString str = "");
    231     void    methodWithOptionalAtomicStringIsEmptyString(optional [AtomString] DOMString str = "");
     231    void    methodWithOptionalAtomStringIsEmptyString(optional [AtomString] DOMString str = "");
    232232    void    methodWithOptionalDoubleIsNaN(optional unrestricted double number = NaN);
    233233    void    methodWithOptionalFloatIsNaN(optional unrestricted float number = NaN);
  • trunk/Source/WebCore/css/makeprop.pl

    r246490 r246636  
    370370String getPropertyNameString(CSSPropertyID id)
    371371{
    372     // We share the StringImpl with the AtomicStrings.
     372    // We share the StringImpl with the AtomStrings.
    373373    return getPropertyNameAtomString(id).string();
    374374}
  • trunk/Source/WebCore/css/makevalues.pl

    r246490 r246636  
    146146String getValueNameString(CSSValueID id)
    147147{
    148     // We share the StringImpl with the AtomicStrings.
     148    // We share the StringImpl with the AtomStrings.
    149149    return getValueNameAtomString(id).string();
    150150}
  • trunk/Source/WebCore/html/FormController.cpp

    r246490 r246636  
    327327        auto signature = formSignature(*form);
    328328        auto nextIndex = m_formSignatureToNextIndexMap.add(signature, 0).iterator->value++;
    329         // FIXME: Would be nice to have makeAtomicString to use here.
     329        // FIXME: Would be nice to have makeAtomString to use to optimize the case where the string already exists.
    330330        return makeString(signature, " #", nextIndex);
    331331    }).iterator->value;
  • trunk/Tools/ChangeLog

    r246632 r246636  
     12019-06-18  Darin Adler  <darin@apple.com>
     2
     3        Tidy up the remaining bits of the AtomicString to AtomString rename
     4        https://bugs.webkit.org/show_bug.cgi?id=198990
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        * Scripts/do-webcore-rename: Removed already-done renames.
     9        * TestWebKitAPI/Tests/WTF/StringImpl.cpp: Rename one use of "atomic".
     10
    1112019-06-20  Carlos Garcia Campos  <cgarcia@igalia.com>
    212
  • trunk/Tools/Scripts/do-webcore-rename

    r246490 r246636  
    103103my %renames = (
    104104    # Renames go here in the form of:
    105     "AtomicString" => "AtomString",
    106     "AtomicStringCreationFromLiteral" => "AtomStringCreationFromLiteral",
    107     "AtomicStringCreationFromLiteralUniqueness" => "AtomStringCreationFromLiteralUniqueness",
    108     "AtomicStringExistingHash" => "AtomStringExistingHash",
    109     "AtomicStringFromLiteralCannotOverflow" => "AtomStringFromLiteralCannotOverflow",
    110     "AtomicStringFromLiteralNotEmpty" => "AtomStringFromLiteralNotEmpty",
    111     "AtomicStringHash" => "AtomStringHash",
    112     "AtomicStringImpl" => "AtomStringImpl",
    113     "AtomicStringImplCF" => "AtomStringImplCF",
    114     "AtomicStringNumberDouble" => "AtomStringNumberDouble",
    115     "AtomicStringTable" => "AtomStringTable",
    116     "AtomicStringTable" => "AtomStringTable",
    117     "AtomicStringTableLocker" => "AtomStringTableLocker",
    118     "AtomicString_h" => "AtomString_h",
    119     "IDLAtomicStringAdaptor" => "IDLAtomStringAdaptor",
    120     "IDLRequiresExistingAtomicStringAdaptor" => "IDLRequiresExistingAtomStringAdaptor",
    121     "RequiresExistingAtomicString" => "RequiresExistingAtomString",
    122     "StringImplNullSymbolToAtomicString" => "StringImplNullSymbolToAtomString",
    123     "StringImplStaticToAtomicString" => "StringImplStaticToAtomString",
    124     "StringImplSymbolToAtomicString" => "StringImplSymbolToAtomString",
    125     "ToAtomicString" => "ToAtomString",
    126     "ToAtomicStringOnEmpty" => "ToAtomStringOnEmpty",
    127     "TokenAtomicStringInitializer" => "TokenAtomStringInitializer",
    128     "WTFAtomicStringPrinter" => "WTFAtomStringPrinter",
    129     "WTFAtomicString_SummaryProvider" => "WTFAtomString_SummaryProvider",
    130     "atomicString" => "atomString",
    131     "atomicString1" => "atomString1",
    132     "atomicString2" => "atomString2",
    133     "atomicStringTable" => "atomStringTable",
    134     "atomicStringWithTemplate" => "atomStringWithTemplate",
    135     "atomicStrings" => "atomStrings",
    136     "checkCurrentAtomicStringTable" => "checkCurrentAtomStringTable",
    137     "existingAtomicString" => "existingAtomString",
    138     "existingEntryAtomicStringTable" => "existingEntryAtomStringTable",
    139     "getPropertyNameAtomicString" => "getPropertyNameAtomString",
    140     "getValueNameAtomicString" => "getValueNameAtomString",
    141     "isAtomic" => "isAtom",
    142     "isAtomicString" => "isAtomString",
    143     "isInAtomicStringTable" => "isInAtomStringTable",
    144     "m_atomicStringTable" => "m_atomStringTable",
    145     "m_currentAtomicStringTable" => "m_currentAtomStringTable",
    146     "m_defaultAtomicStringTable" => "m_defaultAtomStringTable",
    147     "m_entryAtomicStringTable" => "m_entryAtomStringTable",
    148     "oldAtomicStringTable" => "oldAtomStringTable",
    149     "propertyNameToAtomicString" => "propertyNameToAtomString",
    150     "resolveRopeToAtomicString" => "resolveRopeToAtomString",
    151     "resolveRopeToExistingAtomicString" => "resolveRopeToExistingAtomString",
    152     "setCurrentAtomicStringTable" => "setCurrentAtomStringTable",
    153     "shouldUseAtomicString" => "shouldUseAtomString",
    154     "testAtomicStringNumber" => "testAtomStringNumber",
    155     "toAtomicString" => "toAtomString",
    156     "toExistingAtomicString" => "toExistingAtomString",
    157     "useAtomicString" => "useAtomString",
     105    "flagIsAtomic" => "flagIsAtom",
    158106);
    159107
    160108my %renamesContemplatedForTheFuture = (
    161     "setDOMException" => "propagateException",
    162     "setDOMExceptionSlow" => "propagateExceptionSlowPath",
    163 
    164     "PassRefPtr" => "DeprecatedPassRefPtr",
    165 
    166109    "HTMLPlugInImageElement" => "HTMLEmbeddedObjectElement",
    167110    "isPlugInImageElement" => "isEmbeddedObjectElement",
     
    174117    "ErrorInstance" => "JSError",
    175118
    176     "TreeShared" => "TreeRefCounted",
    177 
    178119    "StringImpl" => "SharedString",
    179120
     
    187128    "runtime_object" => "BridgedObject",
    188129    "objc_runtime" => "ObjCBridge",
    189 
    190     "WTF_UNICODE_H" => "Unicode_h",
    191     "WTF_UNICODE_ICU_H" => "UnicodeICU_h",
    192     "UnicodeIcu" => "UnicodeICU",
    193130
    194131    "LegacyWebArchive" => "WebArchive",
  • trunk/Tools/TestWebKitAPI/Tests/WTF/StringImpl.cpp

    r246490 r246636  
    790790
    791791
    792 TEST(WTF, ExternalStringAtomic)
     792TEST(WTF, ExternalStringAtom)
    793793{
    794794    constexpr LChar buffer[] = "hello";
Note: See TracChangeset for help on using the changeset viewer.