Remove WTF_EXPORT_STRING_API
authorjfbastien@apple.com <jfbastien@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 30 Mar 2018 02:36:03 +0000 (02:36 +0000)
committerjfbastien@apple.com <jfbastien@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 30 Mar 2018 02:36:03 +0000 (02:36 +0000)
https://bugs.webkit.org/show_bug.cgi?id=184168
<rdar://problem/39023253>

Reviewed by Yusuke Suzuki.

Remove WTF_EXPORT_STRING_API as requested by a FIXME, and use
WTF_EXPORT_PRIVATE instead.

* wtf/ExportMacros.h:
* wtf/text/AtomicString.h:
* wtf/text/AtomicStringImpl.h:
* wtf/text/StringImpl.h:
* wtf/text/StringView.h:
* wtf/text/SymbolImpl.h:
* wtf/text/WTFString.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@230090 268f45cc-cd09-0410-ab3c-d52691b4dbfc

Source/WTF/ChangeLog
Source/WTF/wtf/ExportMacros.h
Source/WTF/wtf/text/AtomicString.h
Source/WTF/wtf/text/AtomicStringImpl.h
Source/WTF/wtf/text/StringImpl.h
Source/WTF/wtf/text/StringView.h
Source/WTF/wtf/text/SymbolImpl.h
Source/WTF/wtf/text/WTFString.h

index 20e3df8..1792cb4 100644 (file)
@@ -1,3 +1,22 @@
+2018-03-29  JF Bastien  <jfbastien@apple.com>
+
+        Remove WTF_EXPORT_STRING_API
+        https://bugs.webkit.org/show_bug.cgi?id=184168
+        <rdar://problem/39023253>
+
+        Reviewed by Yusuke Suzuki.
+
+        Remove WTF_EXPORT_STRING_API as requested by a FIXME, and use
+        WTF_EXPORT_PRIVATE instead.
+
+        * wtf/ExportMacros.h:
+        * wtf/text/AtomicString.h:
+        * wtf/text/AtomicStringImpl.h:
+        * wtf/text/StringImpl.h:
+        * wtf/text/StringView.h:
+        * wtf/text/SymbolImpl.h:
+        * wtf/text/WTFString.h:
+
 2018-03-29  Commit Queue  <commit-queue@webkit.org>
 
         Unreviewed, rolling out r230062.
index e4895a4..de63594 100644 (file)
@@ -88,6 +88,5 @@
 
 #endif // USE(EXPORT_MACROS)
 
-// FIXME: We should replace WTF_EXPORTDATA and WTF_EXPORT_STRING_API with WTF_EXPORT_PRIVATE.
+// FIXME: We should replace WTF_EXPORTDATA and with WTF_EXPORT_PRIVATE.
 #define WTF_EXPORTDATA WTF_EXPORT_PRIVATE
-#define WTF_EXPORT_STRING_API WTF_EXPORT_PRIVATE
index c90b1ff..501946c 100644 (file)
@@ -104,11 +104,11 @@ public:
 
     UChar operator[](unsigned int i) const { return m_string[i]; }
 
-    WTF_EXPORT_STRING_API static AtomicString number(int);
-    WTF_EXPORT_STRING_API static AtomicString number(unsigned);
-    WTF_EXPORT_STRING_API static AtomicString number(unsigned long);
-    WTF_EXPORT_STRING_API static AtomicString number(unsigned long long);
-    WTF_EXPORT_STRING_API static AtomicString number(double);
+    WTF_EXPORT_PRIVATE static AtomicString number(int);
+    WTF_EXPORT_PRIVATE static AtomicString number(unsigned);
+    WTF_EXPORT_PRIVATE static AtomicString number(unsigned long);
+    WTF_EXPORT_PRIVATE static AtomicString number(unsigned long long);
+    WTF_EXPORT_PRIVATE static AtomicString number(double);
     // If we need more overloads of the number function, we can add all the others that String has, but these seem to do for now.
 
     bool contains(UChar character) const { return m_string.contains(character); }
@@ -133,8 +133,8 @@ public:
     bool endsWith(UChar character) const { return m_string.endsWith(character); }
     template<unsigned matchLength> bool endsWith(const char (&prefix)[matchLength]) const { return m_string.endsWith<matchLength>(prefix); }
 
-    WTF_EXPORT_STRING_API AtomicString convertToASCIILowercase() const;
-    WTF_EXPORT_STRING_API AtomicString convertToASCIIUppercase() const;
+    WTF_EXPORT_PRIVATE AtomicString convertToASCIILowercase() const;
+    WTF_EXPORT_PRIVATE AtomicString convertToASCIIUppercase() const;
 
     int toInt(bool* ok = 0) const { return m_string.toInt(ok); }
     double toDouble(bool* ok = 0) const { return m_string.toDouble(ok); }
@@ -168,7 +168,7 @@ private:
     enum class CaseConvertType { Upper, Lower };
     template<CaseConvertType> AtomicString convertASCIICase() const;
 
-    WTF_EXPORT_STRING_API static AtomicString fromUTF8Internal(const char*, const char*);
+    WTF_EXPORT_PRIVATE static AtomicString fromUTF8Internal(const char*, const char*);
 
     String m_string;
 };
index 40da73b..52c68a3 100644 (file)
@@ -29,8 +29,8 @@ class AtomicStringTable;
 
 class AtomicStringImpl : public UniquedStringImpl {
 public:
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> lookUp(const LChar*, unsigned length);
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> lookUp(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> lookUp(const LChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> lookUp(const UChar*, unsigned length);
     static RefPtr<AtomicStringImpl> lookUp(StringImpl* string)
     {
         if (!string || string->isAtomic())
@@ -40,26 +40,26 @@ public:
 
     static void remove(AtomicStringImpl*);
 
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> add(const LChar*);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> add(const LChar*);
     ALWAYS_INLINE static RefPtr<AtomicStringImpl> add(const char* s) { return add(reinterpret_cast<const LChar*>(s)); };
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> add(const LChar*, unsigned length);
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> add(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> add(const LChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> add(const UChar*, unsigned length);
     ALWAYS_INLINE static RefPtr<AtomicStringImpl> add(const char* s, unsigned length) { return add(reinterpret_cast<const LChar*>(s), length); };
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> add(const UChar*);
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> add(StringImpl*, unsigned offset, unsigned length);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> add(const UChar*);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> add(StringImpl*, unsigned offset, unsigned length);
     ALWAYS_INLINE static RefPtr<AtomicStringImpl> add(StringImpl* string)
     {
         if (!string)
             return static_cast<AtomicStringImpl*>(string);
         return add(*string);
     }
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> add(const StaticStringImpl*);
-    WTF_EXPORT_STRING_API static Ref<AtomicStringImpl> addLiteral(const char* characters, unsigned length);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> add(const StaticStringImpl*);
+    WTF_EXPORT_PRIVATE static Ref<AtomicStringImpl> addLiteral(const char* characters, unsigned length);
 
     // Returns null if the input data contains an invalid UTF-8 sequence.
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> addUTF8(const char* start, const char* end);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> addUTF8(const char* start, const char* end);
 #if USE(CF)
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> add(CFStringRef);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> add(CFStringRef);
 #endif
 
     template<typename StringTableProvider>
@@ -71,7 +71,7 @@ public:
     }
 
 #if !ASSERT_DISABLED
-    WTF_EXPORT_STRING_API static bool isInAtomicStringTable(StringImpl*);
+    WTF_EXPORT_PRIVATE static bool isInAtomicStringTable(StringImpl*);
 #endif
 
 private:
@@ -95,10 +95,10 @@ private:
         return addSlowCase(stringTable, string);
     }
 
-    WTF_EXPORT_STRING_API static Ref<AtomicStringImpl> addSlowCase(StringImpl&);
-    WTF_EXPORT_STRING_API static Ref<AtomicStringImpl> addSlowCase(AtomicStringTable&, StringImpl&);
+    WTF_EXPORT_PRIVATE static Ref<AtomicStringImpl> addSlowCase(StringImpl&);
+    WTF_EXPORT_PRIVATE static Ref<AtomicStringImpl> addSlowCase(AtomicStringTable&, StringImpl&);
 
-    WTF_EXPORT_STRING_API static RefPtr<AtomicStringImpl> lookUpSlowCase(StringImpl&);
+    WTF_EXPORT_PRIVATE static RefPtr<AtomicStringImpl> lookUpSlowCase(StringImpl&);
 };
 
 #if !ASSERT_DISABLED
index 7029f19..0a56874 100644 (file)
@@ -218,16 +218,16 @@ private:
     StringImpl(const UChar*, unsigned length, Ref<StringImpl>&&);
 
 public:
-    WTF_EXPORT_STRING_API static void destroy(StringImpl*);
+    WTF_EXPORT_PRIVATE static void destroy(StringImpl*);
 
-    WTF_EXPORT_STRING_API static Ref<StringImpl> create(const UChar*, unsigned length);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> create(const LChar*, unsigned length);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> create8BitIfPossible(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> create(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> create(const LChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> create8BitIfPossible(const UChar*, unsigned length);
     template<size_t inlineCapacity> static Ref<StringImpl> create8BitIfPossible(const Vector<UChar, inlineCapacity>&);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> create8BitIfPossible(const UChar*);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> create8BitIfPossible(const UChar*);
 
     ALWAYS_INLINE static Ref<StringImpl> create(const char* characters, unsigned length) { return create(reinterpret_cast<const LChar*>(characters), length); }
-    WTF_EXPORT_STRING_API static Ref<StringImpl> create(const LChar*);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> create(const LChar*);
     ALWAYS_INLINE static Ref<StringImpl> create(const char* string) { return create(reinterpret_cast<const LChar*>(string)); }
 
     static Ref<StringImpl> createSubstringSharingImpl(StringImpl&, unsigned offset, unsigned length);
@@ -235,13 +235,13 @@ public:
     template<unsigned characterCount> static Ref<StringImpl> createFromLiteral(const char (&)[characterCount]);
 
     // FIXME: Replace calls to these overloads of createFromLiteral to createWithoutCopying instead.
-    WTF_EXPORT_STRING_API static Ref<StringImpl> createFromLiteral(const char*, unsigned length);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> createFromLiteral(const char*);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> createFromLiteral(const char*, unsigned length);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> createFromLiteral(const char*);
 
-    WTF_EXPORT_STRING_API static Ref<StringImpl> createWithoutCopying(const UChar*, unsigned length);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> createWithoutCopying(const LChar*, unsigned length);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> createUninitialized(unsigned length, LChar*&);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> createUninitialized(unsigned length, UChar*&);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> createWithoutCopying(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> createWithoutCopying(const LChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> createUninitialized(unsigned length, LChar*&);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> createUninitialized(unsigned length, UChar*&);
     template<typename CharacterType> static RefPtr<StringImpl> tryCreateUninitialized(unsigned length, CharacterType*&);
 
     // Reallocate the StringImpl. The originalString must be only owned by the Ref,
@@ -261,8 +261,8 @@ public:
     template<typename CharacterType, size_t inlineCapacity, typename OverflowHandler, size_t minCapacity>
     static Ref<StringImpl> adopt(StringVector<CharacterType, inlineCapacity, OverflowHandler, minCapacity>&&);
 
-    WTF_EXPORT_STRING_API static Ref<StringImpl> adopt(StringBuffer<UChar>&&);
-    WTF_EXPORT_STRING_API static Ref<StringImpl> adopt(StringBuffer<LChar>&&);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> adopt(StringBuffer<UChar>&&);
+    WTF_EXPORT_PRIVATE static Ref<StringImpl> adopt(StringBuffer<LChar>&&);
 
     unsigned length() const { return m_length; }
     unsigned mask() const { return m_mask; }
@@ -278,7 +278,7 @@ public:
     size_t cost() const;
     size_t costDuringGC();
 
-    WTF_EXPORT_STRING_API size_t sizeInBytes() const;
+    WTF_EXPORT_PRIVATE size_t sizeInBytes() const;
 
     bool isSymbol() const { return m_hashAndFlags & s_hashFlagStringKindIsSymbol; }
     bool isAtomic() const { return m_hashAndFlags & s_hashFlagStringKindIsAtomic; }
@@ -288,13 +288,13 @@ public:
     bool isSubString() const { return bufferOwnership() == BufferSubstring; }
 #endif
 
-    static WTF_EXPORT_STRING_API CString utf8ForCharacters(const LChar* characters, unsigned length);
-    static WTF_EXPORT_STRING_API CString utf8ForCharacters(const UChar* characters, unsigned length, ConversionMode = LenientConversion);
-    WTF_EXPORT_STRING_API CString utf8ForRange(unsigned offset, unsigned length, ConversionMode = LenientConversion) const;
-    WTF_EXPORT_STRING_API CString utf8(ConversionMode = LenientConversion) const;
+    static WTF_EXPORT_PRIVATE CString utf8ForCharacters(const LChar* characters, unsigned length);
+    static WTF_EXPORT_PRIVATE CString utf8ForCharacters(const UChar* characters, unsigned length, ConversionMode = LenientConversion);
+    WTF_EXPORT_PRIVATE CString utf8ForRange(unsigned offset, unsigned length, ConversionMode = LenientConversion) const;
+    WTF_EXPORT_PRIVATE CString utf8(ConversionMode = LenientConversion) const;
 
 private:
-    static WTF_EXPORT_STRING_API bool utf8Impl(const UChar* characters, unsigned length, char*& buffer, size_t bufferSize, ConversionMode);
+    static WTF_EXPORT_PRIVATE bool utf8Impl(const UChar* characters, unsigned length, char*& buffer, size_t bufferSize, ConversionMode);
     
     // The high bits of 'hash' are always empty, but we prefer to store our flags
     // in the low bits because it makes them slightly more efficient to access.
@@ -370,11 +370,11 @@ public:
     // its own copy of the string.
     Ref<StringImpl> isolatedCopy() const;
 
-    WTF_EXPORT_STRING_API Ref<StringImpl> substring(unsigned position, unsigned length = std::numeric_limits<unsigned>::max());
+    WTF_EXPORT_PRIVATE Ref<StringImpl> substring(unsigned position, unsigned length = std::numeric_limits<unsigned>::max());
 
     UChar at(unsigned) const;
     UChar operator[](unsigned i) const { return at(i); }
-    WTF_EXPORT_STRING_API UChar32 characterStartingAt(unsigned);
+    WTF_EXPORT_PRIVATE UChar32 characterStartingAt(unsigned);
 
     int toIntStrict(bool* ok = 0, int base = 10);
     unsigned toUIntStrict(bool* ok = 0, int base = 10);
@@ -382,7 +382,7 @@ public:
     uint64_t toUInt64Strict(bool* ok = 0, int base = 10);
     intptr_t toIntPtrStrict(bool* ok = 0, int base = 10);
 
-    WTF_EXPORT_STRING_API int toInt(bool* ok = 0); // ignores trailing garbage
+    WTF_EXPORT_PRIVATE int toInt(bool* ok = 0); // ignores trailing garbage
     unsigned toUInt(bool* ok = 0); // ignores trailing garbage
     int64_t toInt64(bool* ok = 0); // ignores trailing garbage
     uint64_t toUInt64(bool* ok = 0); // ignores trailing garbage
@@ -394,18 +394,18 @@ public:
     double toDouble(bool* ok = 0);
     float toFloat(bool* ok = 0);
 
-    WTF_EXPORT_STRING_API Ref<StringImpl> convertToASCIILowercase();
-    WTF_EXPORT_STRING_API Ref<StringImpl> convertToASCIIUppercase();
-    WTF_EXPORT_STRING_API Ref<StringImpl> convertToLowercaseWithoutLocale();
-    WTF_EXPORT_STRING_API Ref<StringImpl> convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit(unsigned);
-    WTF_EXPORT_STRING_API Ref<StringImpl> convertToUppercaseWithoutLocale();
-    WTF_EXPORT_STRING_API Ref<StringImpl> convertToLowercaseWithLocale(const AtomicString& localeIdentifier);
-    WTF_EXPORT_STRING_API Ref<StringImpl> convertToUppercaseWithLocale(const AtomicString& localeIdentifier);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> convertToASCIILowercase();
+    WTF_EXPORT_PRIVATE Ref<StringImpl> convertToASCIIUppercase();
+    WTF_EXPORT_PRIVATE Ref<StringImpl> convertToLowercaseWithoutLocale();
+    WTF_EXPORT_PRIVATE Ref<StringImpl> convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit(unsigned);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> convertToUppercaseWithoutLocale();
+    WTF_EXPORT_PRIVATE Ref<StringImpl> convertToLowercaseWithLocale(const AtomicString& localeIdentifier);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> convertToUppercaseWithLocale(const AtomicString& localeIdentifier);
 
     Ref<StringImpl> foldCase();
 
     Ref<StringImpl> stripWhiteSpace();
-    WTF_EXPORT_STRING_API Ref<StringImpl> simplifyWhiteSpace();
+    WTF_EXPORT_PRIVATE Ref<StringImpl> simplifyWhiteSpace();
     Ref<StringImpl> simplifyWhiteSpace(CodeUnitMatchFunction);
 
     Ref<StringImpl> stripLeadingAndTrailingCharacters(CodeUnitMatchFunction);
@@ -418,53 +418,53 @@ public:
     size_t find(LChar character, unsigned start = 0);
     size_t find(char character, unsigned start = 0);
     size_t find(UChar character, unsigned start = 0);
-    WTF_EXPORT_STRING_API size_t find(CodeUnitMatchFunction, unsigned index = 0);
+    WTF_EXPORT_PRIVATE size_t find(CodeUnitMatchFunction, unsigned index = 0);
     size_t find(const LChar*, unsigned index = 0);
     ALWAYS_INLINE size_t find(const char* string, unsigned index = 0) { return find(reinterpret_cast<const LChar*>(string), index); }
-    WTF_EXPORT_STRING_API size_t find(StringImpl*);
-    WTF_EXPORT_STRING_API size_t find(StringImpl*, unsigned index);
-    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl&) const;
-    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl&, unsigned startOffset) const;
-    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl*) const;
-    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringImpl*, unsigned startOffset) const;
-
-    WTF_EXPORT_STRING_API size_t reverseFind(UChar, unsigned index = std::numeric_limits<unsigned>::max());
-    WTF_EXPORT_STRING_API size_t reverseFind(StringImpl*, unsigned index = std::numeric_limits<unsigned>::max());
-
-    WTF_EXPORT_STRING_API bool startsWith(const StringImpl*) const;
-    WTF_EXPORT_STRING_API bool startsWith(const StringImpl&) const;
-    WTF_EXPORT_STRING_API bool startsWithIgnoringASCIICase(const StringImpl*) const;
-    WTF_EXPORT_STRING_API bool startsWithIgnoringASCIICase(const StringImpl&) const;
-    WTF_EXPORT_STRING_API bool startsWith(UChar) const;
-    WTF_EXPORT_STRING_API bool startsWith(const char*, unsigned matchLength) const;
+    WTF_EXPORT_PRIVATE size_t find(StringImpl*);
+    WTF_EXPORT_PRIVATE size_t find(StringImpl*, unsigned index);
+    WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl&) const;
+    WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl&, unsigned startOffset) const;
+    WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl*) const;
+    WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringImpl*, unsigned startOffset) const;
+
+    WTF_EXPORT_PRIVATE size_t reverseFind(UChar, unsigned index = std::numeric_limits<unsigned>::max());
+    WTF_EXPORT_PRIVATE size_t reverseFind(StringImpl*, unsigned index = std::numeric_limits<unsigned>::max());
+
+    WTF_EXPORT_PRIVATE bool startsWith(const StringImpl*) const;
+    WTF_EXPORT_PRIVATE bool startsWith(const StringImpl&) const;
+    WTF_EXPORT_PRIVATE bool startsWithIgnoringASCIICase(const StringImpl*) const;
+    WTF_EXPORT_PRIVATE bool startsWithIgnoringASCIICase(const StringImpl&) const;
+    WTF_EXPORT_PRIVATE bool startsWith(UChar) const;
+    WTF_EXPORT_PRIVATE bool startsWith(const char*, unsigned matchLength) const;
     template<unsigned matchLength> bool startsWith(const char (&prefix)[matchLength]) const { return startsWith(prefix, matchLength - 1); }
-    WTF_EXPORT_STRING_API bool hasInfixStartingAt(const StringImpl&, unsigned startOffset) const;
-
-    WTF_EXPORT_STRING_API bool endsWith(StringImpl*);
-    WTF_EXPORT_STRING_API bool endsWith(StringImpl&);
-    WTF_EXPORT_STRING_API bool endsWithIgnoringASCIICase(const StringImpl*) const;
-    WTF_EXPORT_STRING_API bool endsWithIgnoringASCIICase(const StringImpl&) const;
-    WTF_EXPORT_STRING_API bool endsWith(UChar) const;
-    WTF_EXPORT_STRING_API bool endsWith(const char*, unsigned matchLength) const;
+    WTF_EXPORT_PRIVATE bool hasInfixStartingAt(const StringImpl&, unsigned startOffset) const;
+
+    WTF_EXPORT_PRIVATE bool endsWith(StringImpl*);
+    WTF_EXPORT_PRIVATE bool endsWith(StringImpl&);
+    WTF_EXPORT_PRIVATE bool endsWithIgnoringASCIICase(const StringImpl*) const;
+    WTF_EXPORT_PRIVATE bool endsWithIgnoringASCIICase(const StringImpl&) const;
+    WTF_EXPORT_PRIVATE bool endsWith(UChar) const;
+    WTF_EXPORT_PRIVATE bool endsWith(const char*, unsigned matchLength) const;
     template<unsigned matchLength> bool endsWith(const char (&prefix)[matchLength]) const { return endsWith(prefix, matchLength - 1); }
-    WTF_EXPORT_STRING_API bool hasInfixEndingAt(const StringImpl&, unsigned endOffset) const;
+    WTF_EXPORT_PRIVATE bool hasInfixEndingAt(const StringImpl&, unsigned endOffset) const;
 
-    WTF_EXPORT_STRING_API Ref<StringImpl> replace(UChar, UChar);
-    WTF_EXPORT_STRING_API Ref<StringImpl> replace(UChar, StringImpl*);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> replace(UChar, UChar);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> replace(UChar, StringImpl*);
     ALWAYS_INLINE Ref<StringImpl> replace(UChar pattern, const char* replacement, unsigned replacementLength) { return replace(pattern, reinterpret_cast<const LChar*>(replacement), replacementLength); }
-    WTF_EXPORT_STRING_API Ref<StringImpl> replace(UChar, const LChar*, unsigned replacementLength);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> replace(UChar, const LChar*, unsigned replacementLength);
     Ref<StringImpl> replace(UChar, const UChar*, unsigned replacementLength);
-    WTF_EXPORT_STRING_API Ref<StringImpl> replace(StringImpl*, StringImpl*);
-    WTF_EXPORT_STRING_API Ref<StringImpl> replace(unsigned index, unsigned length, StringImpl*);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> replace(StringImpl*, StringImpl*);
+    WTF_EXPORT_PRIVATE Ref<StringImpl> replace(unsigned index, unsigned length, StringImpl*);
 
-    WTF_EXPORT_STRING_API UCharDirection defaultWritingDirection(bool* hasStrongDirectionality = nullptr);
+    WTF_EXPORT_PRIVATE UCharDirection defaultWritingDirection(bool* hasStrongDirectionality = nullptr);
 
 #if USE(CF)
     RetainPtr<CFStringRef> createCFString();
 #endif
 
 #ifdef __OBJC__
-    WTF_EXPORT_STRING_API operator NSString *();
+    WTF_EXPORT_PRIVATE operator NSString *();
 #endif
 
 #if STRING_STATS
@@ -537,25 +537,25 @@ template<> struct ValueCheck<StringImpl*> {
 
 #endif
 
-WTF_EXPORT_STRING_API bool equal(const StringImpl*, const StringImpl*);
-WTF_EXPORT_STRING_API bool equal(const StringImpl*, const LChar*);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const StringImpl*);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const LChar*);
 inline bool equal(const StringImpl* a, const char* b) { return equal(a, reinterpret_cast<const LChar*>(b)); }
-WTF_EXPORT_STRING_API bool equal(const StringImpl*, const LChar*, unsigned);
-WTF_EXPORT_STRING_API bool equal(const StringImpl*, const UChar*, unsigned);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const LChar*, unsigned);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const UChar*, unsigned);
 inline bool equal(const StringImpl* a, const char* b, unsigned length) { return equal(a, reinterpret_cast<const LChar*>(b), length); }
 inline bool equal(const LChar* a, StringImpl* b) { return equal(b, a); }
 inline bool equal(const char* a, StringImpl* b) { return equal(b, reinterpret_cast<const LChar*>(a)); }
-WTF_EXPORT_STRING_API bool equal(const StringImpl& a, const StringImpl& b);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl& a, const StringImpl& b);
 
-WTF_EXPORT_STRING_API bool equalIgnoringNullity(StringImpl*, StringImpl*);
-WTF_EXPORT_STRING_API bool equalIgnoringNullity(const UChar*, size_t length, StringImpl*);
+WTF_EXPORT_PRIVATE bool equalIgnoringNullity(StringImpl*, StringImpl*);
+WTF_EXPORT_PRIVATE bool equalIgnoringNullity(const UChar*, size_t length, StringImpl*);
 
 bool equalIgnoringASCIICase(const StringImpl&, const StringImpl&);
-WTF_EXPORT_STRING_API bool equalIgnoringASCIICase(const StringImpl*, const StringImpl*);
+WTF_EXPORT_PRIVATE bool equalIgnoringASCIICase(const StringImpl*, const StringImpl*);
 bool equalIgnoringASCIICase(const StringImpl&, const char*);
 bool equalIgnoringASCIICase(const StringImpl*, const char*);
 
-WTF_EXPORT_STRING_API bool equalIgnoringASCIICaseNonNull(const StringImpl*, const StringImpl*);
+WTF_EXPORT_PRIVATE bool equalIgnoringASCIICaseNonNull(const StringImpl*, const StringImpl*);
 
 template<unsigned length> bool equalLettersIgnoringASCIICase(const StringImpl&, const char (&lowercaseLetters)[length]);
 template<unsigned length> bool equalLettersIgnoringASCIICase(const StringImpl*, const char (&lowercaseLetters)[length]);
index d382ce3..f2601d5 100644 (file)
@@ -97,16 +97,16 @@ public:
 
 #if USE(CF)
     // This function converts null strings to empty strings.
-    WTF_EXPORT_STRING_API RetainPtr<CFStringRef> createCFStringWithoutCopying() const;
+    WTF_EXPORT_PRIVATE RetainPtr<CFStringRef> createCFStringWithoutCopying() const;
 #endif
 
 #ifdef __OBJC__
     // These functions convert null strings to empty strings.
-    WTF_EXPORT_STRING_API RetainPtr<NSString> createNSString() const;
-    WTF_EXPORT_STRING_API RetainPtr<NSString> createNSStringWithoutCopying() const;
+    WTF_EXPORT_PRIVATE RetainPtr<NSString> createNSString() const;
+    WTF_EXPORT_PRIVATE RetainPtr<NSString> createNSStringWithoutCopying() const;
 #endif
 
-    WTF_EXPORT_STRING_API CString utf8(ConversionMode = LenientConversion) const;
+    WTF_EXPORT_PRIVATE CString utf8(ConversionMode = LenientConversion) const;
 
     class UpconvertedCharacters;
     UpconvertedCharacters upconvertedCharacters() const;
@@ -127,22 +127,22 @@ public:
     size_t find(UChar, unsigned start = 0) const;
     size_t find(CodeUnitMatchFunction, unsigned start = 0) const;
 
-    WTF_EXPORT_STRING_API size_t find(StringView, unsigned start) const;
+    WTF_EXPORT_PRIVATE size_t find(StringView, unsigned start) const;
 
     size_t reverseFind(UChar, unsigned index = UINT_MAX) const;
 
-    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringView&) const;
-    WTF_EXPORT_STRING_API size_t findIgnoringASCIICase(const StringView&, unsigned startOffset) const;
+    WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringView&) const;
+    WTF_EXPORT_PRIVATE size_t findIgnoringASCIICase(const StringView&, unsigned startOffset) const;
 
     bool contains(UChar) const;
-    WTF_EXPORT_STRING_API bool containsIgnoringASCIICase(const StringView&) const;
-    WTF_EXPORT_STRING_API bool containsIgnoringASCIICase(const StringView&, unsigned startOffset) const;
+    WTF_EXPORT_PRIVATE bool containsIgnoringASCIICase(const StringView&) const;
+    WTF_EXPORT_PRIVATE bool containsIgnoringASCIICase(const StringView&, unsigned startOffset) const;
 
-    WTF_EXPORT_STRING_API bool startsWith(const StringView&) const;
-    WTF_EXPORT_STRING_API bool startsWithIgnoringASCIICase(const StringView&) const;
+    WTF_EXPORT_PRIVATE bool startsWith(const StringView&) const;
+    WTF_EXPORT_PRIVATE bool startsWithIgnoringASCIICase(const StringView&) const;
 
-    WTF_EXPORT_STRING_API bool endsWith(const StringView&) const;
-    WTF_EXPORT_STRING_API bool endsWithIgnoringASCIICase(const StringView&) const;
+    WTF_EXPORT_PRIVATE bool endsWith(const StringView&) const;
+    WTF_EXPORT_PRIVATE bool endsWithIgnoringASCIICase(const StringView&) const;
 
     int toInt() const;
     int toInt(bool& isValid) const;
@@ -166,9 +166,9 @@ private:
     StringView stripLeadingAndTrailingMatchedCharacters(const CharacterType*, const MatchedCharacterPredicate&);
 
 #if CHECK_STRINGVIEW_LIFETIME
-    WTF_EXPORT_STRING_API bool underlyingStringIsValid() const;
-    WTF_EXPORT_STRING_API void setUnderlyingString(const StringImpl*);
-    WTF_EXPORT_STRING_API void setUnderlyingString(const StringView&);
+    WTF_EXPORT_PRIVATE bool underlyingStringIsValid() const;
+    WTF_EXPORT_PRIVATE void setUnderlyingString(const StringImpl*);
+    WTF_EXPORT_PRIVATE void setUnderlyingString(const StringView&);
 #else
     bool underlyingStringIsValid() const { return true; }
     void setUnderlyingString(const StringImpl*) { }
index d4c3f66..25455c4 100644 (file)
@@ -50,8 +50,8 @@ public:
 
     RegisteredSymbolImpl* asRegisteredSymbolImpl();
 
-    WTF_EXPORT_STRING_API static Ref<SymbolImpl> createNullSymbol();
-    WTF_EXPORT_STRING_API static Ref<SymbolImpl> create(StringImpl& rep);
+    WTF_EXPORT_PRIVATE static Ref<SymbolImpl> createNullSymbol();
+    WTF_EXPORT_PRIVATE static Ref<SymbolImpl> create(StringImpl& rep);
 
     class StaticSymbolImpl : private StringImplShape {
         WTF_MAKE_NONCOPYABLE(StaticSymbolImpl);
@@ -126,8 +126,8 @@ static_assert(sizeof(SymbolImpl) == sizeof(SymbolImpl::StaticSymbolImpl), "");
 
 class PrivateSymbolImpl : public SymbolImpl {
 public:
-    WTF_EXPORT_STRING_API static Ref<PrivateSymbolImpl> createNullSymbol();
-    WTF_EXPORT_STRING_API static Ref<PrivateSymbolImpl> create(StringImpl& rep);
+    WTF_EXPORT_PRIVATE static Ref<PrivateSymbolImpl> createNullSymbol();
+    WTF_EXPORT_PRIVATE static Ref<PrivateSymbolImpl> create(StringImpl& rep);
 
 private:
     PrivateSymbolImpl(const LChar* characters, unsigned length, Ref<StringImpl>&& base)
index a5af0aa..b487d0a 100644 (file)
@@ -40,37 +40,37 @@ class ASCIILiteral;
 
 // Declarations of string operations
 
-WTF_EXPORT_STRING_API int charactersToIntStrict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
-WTF_EXPORT_STRING_API int charactersToIntStrict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
-WTF_EXPORT_STRING_API unsigned charactersToUIntStrict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
-WTF_EXPORT_STRING_API unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
+WTF_EXPORT_PRIVATE int charactersToIntStrict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
+WTF_EXPORT_PRIVATE int charactersToIntStrict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
+WTF_EXPORT_PRIVATE unsigned charactersToUIntStrict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
+WTF_EXPORT_PRIVATE unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
 int64_t charactersToInt64Strict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
 int64_t charactersToInt64Strict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
-WTF_EXPORT_STRING_API uint64_t charactersToUInt64Strict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
-WTF_EXPORT_STRING_API uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
+WTF_EXPORT_PRIVATE uint64_t charactersToUInt64Strict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
+WTF_EXPORT_PRIVATE uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
 intptr_t charactersToIntPtrStrict(const LChar*, size_t, bool* ok = nullptr, int base = 10);
 intptr_t charactersToIntPtrStrict(const UChar*, size_t, bool* ok = nullptr, int base = 10);
 
-WTF_EXPORT_STRING_API int charactersToInt(const LChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
-WTF_EXPORT_STRING_API int charactersToInt(const UChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
+WTF_EXPORT_PRIVATE int charactersToInt(const LChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
+WTF_EXPORT_PRIVATE int charactersToInt(const UChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 unsigned charactersToUInt(const LChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 unsigned charactersToUInt(const UChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 int64_t charactersToInt64(const LChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 int64_t charactersToInt64(const UChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 uint64_t charactersToUInt64(const LChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
-WTF_EXPORT_STRING_API uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
+WTF_EXPORT_PRIVATE uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 intptr_t charactersToIntPtr(const LChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 intptr_t charactersToIntPtr(const UChar*, size_t, bool* ok = nullptr); // ignores trailing garbage
 
 // FIXME: Like the strict functions above, these give false for "ok" when there is trailing garbage.
 // Like the non-strict functions above, these return the value when there is trailing garbage.
 // It would be better if these were more consistent with the above functions instead.
-WTF_EXPORT_STRING_API double charactersToDouble(const LChar*, size_t, bool* ok = nullptr);
-WTF_EXPORT_STRING_API double charactersToDouble(const UChar*, size_t, bool* ok = nullptr);
-WTF_EXPORT_STRING_API float charactersToFloat(const LChar*, size_t, bool* ok = nullptr);
-WTF_EXPORT_STRING_API float charactersToFloat(const UChar*, size_t, bool* ok = nullptr);
-WTF_EXPORT_STRING_API float charactersToFloat(const LChar*, size_t, size_t& parsedLength);
-WTF_EXPORT_STRING_API float charactersToFloat(const UChar*, size_t, size_t& parsedLength);
+WTF_EXPORT_PRIVATE double charactersToDouble(const LChar*, size_t, bool* ok = nullptr);
+WTF_EXPORT_PRIVATE double charactersToDouble(const UChar*, size_t, bool* ok = nullptr);
+WTF_EXPORT_PRIVATE float charactersToFloat(const LChar*, size_t, bool* ok = nullptr);
+WTF_EXPORT_PRIVATE float charactersToFloat(const UChar*, size_t, bool* ok = nullptr);
+WTF_EXPORT_PRIVATE float charactersToFloat(const LChar*, size_t, size_t& parsedLength);
+WTF_EXPORT_PRIVATE float charactersToFloat(const UChar*, size_t, size_t& parsedLength);
 
 template<bool isSpecialCharacter(UChar), typename CharacterType> bool isAllSpecialCharacters(const CharacterType*, size_t);
 
@@ -82,7 +82,7 @@ public:
     String() = default;
 
     // Construct a string with UTF-16 data.
-    WTF_EXPORT_STRING_API String(const UChar* characters, unsigned length);
+    WTF_EXPORT_PRIVATE String(const UChar* characters, unsigned length);
 
     // Construct a string by copying the contents of a vector.  To avoid
     // copying, consider using String::adopt instead.
@@ -96,15 +96,15 @@ public:
     explicit String(const Vector<UChar, inlineCapacity, OverflowHandler>&);
 
     // Construct a string with UTF-16 data, from a null-terminated source.
-    WTF_EXPORT_STRING_API String(const UChar*);
+    WTF_EXPORT_PRIVATE String(const UChar*);
 
     // Construct a string with latin1 data.
-    WTF_EXPORT_STRING_API String(const LChar* characters, unsigned length);
-    WTF_EXPORT_STRING_API String(const char* characters, unsigned length);
+    WTF_EXPORT_PRIVATE String(const LChar* characters, unsigned length);
+    WTF_EXPORT_PRIVATE String(const char* characters, unsigned length);
 
     // Construct a string with latin1 data, from a null-terminated source.
-    WTF_EXPORT_STRING_API String(const LChar* characters);
-    WTF_EXPORT_STRING_API String(const char* characters);
+    WTF_EXPORT_PRIVATE String(const LChar* characters);
+    WTF_EXPORT_PRIVATE String(const char* characters);
 
     // Construct a string referencing an existing StringImpl.
     String(StringImpl&);
@@ -119,7 +119,7 @@ public:
     String(StaticStringImpl*);
 
     // Construct a string from a constant string literal.
-    WTF_EXPORT_STRING_API String(ASCIILiteral);
+    WTF_EXPORT_PRIVATE String(ASCIILiteral);
 
     // Construct a string from a constant string literal.
     // This constructor is the "big" version, as it put the length in the function call and generate bigger code.
@@ -160,27 +160,27 @@ public:
 
     unsigned sizeInBytes() const { return m_impl ? m_impl->length() * (is8Bit() ? sizeof(LChar) : sizeof(UChar)) : 0; }
 
-    WTF_EXPORT_STRING_API CString ascii() const;
-    WTF_EXPORT_STRING_API CString latin1() const;
+    WTF_EXPORT_PRIVATE CString ascii() const;
+    WTF_EXPORT_PRIVATE CString latin1() const;
 
-    WTF_EXPORT_STRING_API CString utf8(ConversionMode) const;
-    WTF_EXPORT_STRING_API CString utf8() const;
+    WTF_EXPORT_PRIVATE CString utf8(ConversionMode) const;
+    WTF_EXPORT_PRIVATE CString utf8() const;
 
     UChar characterAt(unsigned index) const;
     UChar operator[](unsigned index) const { return characterAt(index); }
 
-    WTF_EXPORT_STRING_API static String number(int);
-    WTF_EXPORT_STRING_API static String number(unsigned);
-    WTF_EXPORT_STRING_API static String number(long);
-    WTF_EXPORT_STRING_API static String number(unsigned long);
-    WTF_EXPORT_STRING_API static String number(long long);
-    WTF_EXPORT_STRING_API static String number(unsigned long long);
+    WTF_EXPORT_PRIVATE static String number(int);
+    WTF_EXPORT_PRIVATE static String number(unsigned);
+    WTF_EXPORT_PRIVATE static String number(long);
+    WTF_EXPORT_PRIVATE static String number(unsigned long);
+    WTF_EXPORT_PRIVATE static String number(long long);
+    WTF_EXPORT_PRIVATE static String number(unsigned long long);
 
-    WTF_EXPORT_STRING_API static String number(double, unsigned precision = 6, TrailingZerosTruncatingPolicy = TruncateTrailingZeros);
+    WTF_EXPORT_PRIVATE static String number(double, unsigned precision = 6, TrailingZerosTruncatingPolicy = TruncateTrailingZeros);
 
     // Number to String conversion following the ECMAScript definition.
-    WTF_EXPORT_STRING_API static String numberToStringECMAScript(double);
-    WTF_EXPORT_STRING_API static String numberToStringFixedWidth(double, unsigned decimalPlaces);
+    WTF_EXPORT_PRIVATE static String numberToStringECMAScript(double);
+    WTF_EXPORT_PRIVATE static String numberToStringFixedWidth(double, unsigned decimalPlaces);
 
     // Find a single character or string, also with match function & latin1 forms.
     size_t find(UChar character, unsigned start = 0) const { return m_impl ? m_impl->find(character, start) : notFound; }
@@ -197,9 +197,9 @@ public:
     size_t reverseFind(UChar character, unsigned start = std::numeric_limits<unsigned>::max()) const { return m_impl ? m_impl->reverseFind(character, start) : notFound; }
     size_t reverseFind(const String& string, unsigned start = std::numeric_limits<unsigned>::max()) const { return m_impl ? m_impl->reverseFind(string.impl(), start) : notFound; }
 
-    WTF_EXPORT_STRING_API Vector<UChar> charactersWithNullTermination() const;
+    WTF_EXPORT_PRIVATE Vector<UChar> charactersWithNullTermination() const;
 
-    WTF_EXPORT_STRING_API UChar32 characterStartingAt(unsigned) const;
+    WTF_EXPORT_PRIVATE UChar32 characterStartingAt(unsigned) const;
 
     bool contains(UChar character) const { return find(character) != notFound; }
     bool contains(const LChar* string) const { return find(string) != notFound; }
@@ -220,13 +220,13 @@ public:
     template<unsigned matchLength> bool endsWith(const char (&prefix)[matchLength]) const { return m_impl ? m_impl->endsWith<matchLength>(prefix) : !matchLength; }
     bool hasInfixEndingAt(const String& suffix, unsigned endOffset) const { return m_impl && suffix.impl() && m_impl->hasInfixEndingAt(*suffix.impl(), endOffset); }
 
-    WTF_EXPORT_STRING_API void append(const String&);
-    WTF_EXPORT_STRING_API void append(LChar);
+    WTF_EXPORT_PRIVATE void append(const String&);
+    WTF_EXPORT_PRIVATE void append(LChar);
     void append(char character) { append(static_cast<LChar>(character)); };
-    WTF_EXPORT_STRING_API void append(UChar);
-    WTF_EXPORT_STRING_API void append(const LChar*, unsigned length);
-    WTF_EXPORT_STRING_API void append(const UChar*, unsigned length);
-    WTF_EXPORT_STRING_API void insert(const String&, unsigned position);
+    WTF_EXPORT_PRIVATE void append(UChar);
+    WTF_EXPORT_PRIVATE void append(const LChar*, unsigned length);
+    WTF_EXPORT_PRIVATE void append(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE void insert(const String&, unsigned position);
 
     String& replace(UChar target, UChar replacement);
     String& replace(UChar target, const String& replacement);
@@ -234,79 +234,79 @@ public:
     String& replace(unsigned start, unsigned length, const String& replacement);
     template<unsigned characterCount> String& replaceWithLiteral(UChar target, const char (&replacement)[characterCount]);
 
-    WTF_EXPORT_STRING_API void truncate(unsigned length);
-    WTF_EXPORT_STRING_API void remove(unsigned position, unsigned length = 1);
+    WTF_EXPORT_PRIVATE void truncate(unsigned length);
+    WTF_EXPORT_PRIVATE void remove(unsigned position, unsigned length = 1);
 
-    WTF_EXPORT_STRING_API String substring(unsigned position, unsigned length = std::numeric_limits<unsigned>::max()) const;
-    WTF_EXPORT_STRING_API String substringSharingImpl(unsigned position, unsigned length = std::numeric_limits<unsigned>::max()) const;
+    WTF_EXPORT_PRIVATE String substring(unsigned position, unsigned length = std::numeric_limits<unsigned>::max()) const;
+    WTF_EXPORT_PRIVATE String substringSharingImpl(unsigned position, unsigned length = std::numeric_limits<unsigned>::max()) const;
     String left(unsigned length) const { return substring(0, length); }
     String right(unsigned length) const { return substring(this->length() - length, length); }
 
-    WTF_EXPORT_STRING_API String convertToASCIILowercase() const;
-    WTF_EXPORT_STRING_API String convertToASCIIUppercase() const;
-    WTF_EXPORT_STRING_API String convertToLowercaseWithoutLocale() const;
-    WTF_EXPORT_STRING_API String convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit(unsigned) const;
-    WTF_EXPORT_STRING_API String convertToUppercaseWithoutLocale() const;
-    WTF_EXPORT_STRING_API String convertToLowercaseWithLocale(const AtomicString& localeIdentifier) const;
-    WTF_EXPORT_STRING_API String convertToUppercaseWithLocale(const AtomicString& localeIdentifier) const;
+    WTF_EXPORT_PRIVATE String convertToASCIILowercase() const;
+    WTF_EXPORT_PRIVATE String convertToASCIIUppercase() const;
+    WTF_EXPORT_PRIVATE String convertToLowercaseWithoutLocale() const;
+    WTF_EXPORT_PRIVATE String convertToLowercaseWithoutLocaleStartingAtFailingIndex8Bit(unsigned) const;
+    WTF_EXPORT_PRIVATE String convertToUppercaseWithoutLocale() const;
+    WTF_EXPORT_PRIVATE String convertToLowercaseWithLocale(const AtomicString& localeIdentifier) const;
+    WTF_EXPORT_PRIVATE String convertToUppercaseWithLocale(const AtomicString& localeIdentifier) const;
 
-    WTF_EXPORT_STRING_API String stripWhiteSpace() const;
-    WTF_EXPORT_STRING_API String simplifyWhiteSpace() const;
-    WTF_EXPORT_STRING_API String simplifyWhiteSpace(CodeUnitMatchFunction) const;
+    WTF_EXPORT_PRIVATE String stripWhiteSpace() const;
+    WTF_EXPORT_PRIVATE String simplifyWhiteSpace() const;
+    WTF_EXPORT_PRIVATE String simplifyWhiteSpace(CodeUnitMatchFunction) const;
 
-    WTF_EXPORT_STRING_API String stripLeadingAndTrailingCharacters(CodeUnitMatchFunction) const;
-    WTF_EXPORT_STRING_API String removeCharacters(CodeUnitMatchFunction) const;
+    WTF_EXPORT_PRIVATE String stripLeadingAndTrailingCharacters(CodeUnitMatchFunction) const;
+    WTF_EXPORT_PRIVATE String removeCharacters(CodeUnitMatchFunction) const;
 
     // Returns the string with case folded for case insensitive comparison.
     // Use convertToASCIILowercase instead if ASCII case insensitive comparison is desired.
-    WTF_EXPORT_STRING_API String foldCase() const;
+    WTF_EXPORT_PRIVATE String foldCase() const;
 
-    WTF_EXPORT_STRING_API static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
-    WTF_EXPORT_STRING_API static String formatWithArguments(const char *, va_list) WTF_ATTRIBUTE_PRINTF(1, 0);
+    WTF_EXPORT_PRIVATE static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
+    WTF_EXPORT_PRIVATE static String formatWithArguments(const char *, va_list) WTF_ATTRIBUTE_PRINTF(1, 0);
 
     // Returns an uninitialized string. The characters needs to be written
     // into the buffer returned in data before the returned string is used.
     static String createUninitialized(unsigned length, UChar*& data) { return StringImpl::createUninitialized(length, data); }
     static String createUninitialized(unsigned length, LChar*& data) { return StringImpl::createUninitialized(length, data); }
 
-    WTF_EXPORT_STRING_API void split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const;
+    WTF_EXPORT_PRIVATE void split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const;
     void split(const String& separator, Vector<String>& result) const { split(separator, false, result); }
 
     using SplitFunctor = WTF::Function<void(const StringView&)>;
-    WTF_EXPORT_STRING_API void split(UChar separator, bool allowEmptyEntries, const SplitFunctor&) const;
-    WTF_EXPORT_STRING_API void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const;
+    WTF_EXPORT_PRIVATE void split(UChar separator, bool allowEmptyEntries, const SplitFunctor&) const;
+    WTF_EXPORT_PRIVATE void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const;
     void split(UChar separator, Vector<String>& result) const { split(separator, false, result); }
     Vector<String> split(UChar separator) const;
     Vector<String> split(const String& separator) const;
 
-    WTF_EXPORT_STRING_API int toIntStrict(bool* ok = nullptr, int base = 10) const;
-    WTF_EXPORT_STRING_API unsigned toUIntStrict(bool* ok = nullptr, int base = 10) const;
-    WTF_EXPORT_STRING_API int64_t toInt64Strict(bool* ok = nullptr, int base = 10) const;
-    WTF_EXPORT_STRING_API uint64_t toUInt64Strict(bool* ok = nullptr, int base = 10) const;
-    WTF_EXPORT_STRING_API intptr_t toIntPtrStrict(bool* ok = nullptr, int base = 10) const;
+    WTF_EXPORT_PRIVATE int toIntStrict(bool* ok = nullptr, int base = 10) const;
+    WTF_EXPORT_PRIVATE unsigned toUIntStrict(bool* ok = nullptr, int base = 10) const;
+    WTF_EXPORT_PRIVATE int64_t toInt64Strict(bool* ok = nullptr, int base = 10) const;
+    WTF_EXPORT_PRIVATE uint64_t toUInt64Strict(bool* ok = nullptr, int base = 10) const;
+    WTF_EXPORT_PRIVATE intptr_t toIntPtrStrict(bool* ok = nullptr, int base = 10) const;
 
-    WTF_EXPORT_STRING_API int toInt(bool* ok = nullptr) const;
-    WTF_EXPORT_STRING_API unsigned toUInt(bool* ok = nullptr) const;
-    WTF_EXPORT_STRING_API int64_t toInt64(bool* ok = nullptr) const;
-    WTF_EXPORT_STRING_API uint64_t toUInt64(bool* ok = nullptr) const;
-    WTF_EXPORT_STRING_API intptr_t toIntPtr(bool* ok = nullptr) const;
+    WTF_EXPORT_PRIVATE int toInt(bool* ok = nullptr) const;
+    WTF_EXPORT_PRIVATE unsigned toUInt(bool* ok = nullptr) const;
+    WTF_EXPORT_PRIVATE int64_t toInt64(bool* ok = nullptr) const;
+    WTF_EXPORT_PRIVATE uint64_t toUInt64(bool* ok = nullptr) const;
+    WTF_EXPORT_PRIVATE intptr_t toIntPtr(bool* ok = nullptr) const;
 
     // FIXME: Like the strict functions above, these give false for "ok" when there is trailing garbage.
     // Like the non-strict functions above, these return the value when there is trailing garbage.
     // It would be better if these were more consistent with the above functions instead.
-    WTF_EXPORT_STRING_API double toDouble(bool* ok = nullptr) const;
-    WTF_EXPORT_STRING_API float toFloat(bool* ok = nullptr) const;
+    WTF_EXPORT_PRIVATE double toDouble(bool* ok = nullptr) const;
+    WTF_EXPORT_PRIVATE float toFloat(bool* ok = nullptr) const;
 
     bool percentage(int& percentage) const;
 
 #if COMPILER_SUPPORTS(CXX_REFERENCE_QUALIFIED_FUNCTIONS)
-    WTF_EXPORT_STRING_API String isolatedCopy() const &;
-    WTF_EXPORT_STRING_API String isolatedCopy() &&;
+    WTF_EXPORT_PRIVATE String isolatedCopy() const &;
+    WTF_EXPORT_PRIVATE String isolatedCopy() &&;
 #else
-    WTF_EXPORT_STRING_API String isolatedCopy() const;
+    WTF_EXPORT_PRIVATE String isolatedCopy() const;
 #endif
 
-    WTF_EXPORT_STRING_API bool isSafeToSendToAnotherThread() const;
+    WTF_EXPORT_PRIVATE bool isSafeToSendToAnotherThread() const;
 
     // Prevent Strings from being implicitly convertable to bool as it will be ambiguous on any platform that
     // allows implicit conversion to another pointer type (e.g., Mac allows implicit conversion to NSString *).
@@ -316,12 +316,12 @@ public:
     operator UnspecifiedBoolTypeB() const;
 
 #if USE(CF)
-    WTF_EXPORT_STRING_API String(CFStringRef);
-    WTF_EXPORT_STRING_API RetainPtr<CFStringRef> createCFString() const;
+    WTF_EXPORT_PRIVATE String(CFStringRef);
+    WTF_EXPORT_PRIVATE RetainPtr<CFStringRef> createCFString() const;
 #endif
 
 #ifdef __OBJC__
-    WTF_EXPORT_STRING_API String(NSString *);
+    WTF_EXPORT_PRIVATE String(NSString *);
 
     // This conversion converts the null string to an empty NSString rather than to nil.
     // Given Cocoa idioms, this is a more useful default. Clients that need to preserve the
@@ -329,22 +329,22 @@ public:
     operator NSString *() const;
 #endif
 
-    WTF_EXPORT_STRING_API static String make8BitFrom16BitSource(const UChar*, size_t);
+    WTF_EXPORT_PRIVATE static String make8BitFrom16BitSource(const UChar*, size_t);
     template<size_t inlineCapacity> static String make8BitFrom16BitSource(const Vector<UChar, inlineCapacity>&);
 
-    WTF_EXPORT_STRING_API static String make16BitFrom8BitSource(const LChar*, size_t);
+    WTF_EXPORT_PRIVATE static String make16BitFrom8BitSource(const LChar*, size_t);
 
     // String::fromUTF8 will return a null string if
     // the input data contains invalid UTF-8 sequences.
-    WTF_EXPORT_STRING_API static String fromUTF8(const LChar*, size_t);
-    WTF_EXPORT_STRING_API static String fromUTF8(const LChar*);
+    WTF_EXPORT_PRIVATE static String fromUTF8(const LChar*, size_t);
+    WTF_EXPORT_PRIVATE static String fromUTF8(const LChar*);
     static String fromUTF8(const char* characters, size_t length) { return fromUTF8(reinterpret_cast<const LChar*>(characters), length); };
     static String fromUTF8(const char* string) { return fromUTF8(reinterpret_cast<const LChar*>(string)); };
-    WTF_EXPORT_STRING_API static String fromUTF8(const CString&);
+    WTF_EXPORT_PRIVATE static String fromUTF8(const CString&);
     static String fromUTF8(const Vector<LChar>& characters);
 
     // Tries to convert the passed in string to UTF-8, but will fall back to Latin-1 if the string is not valid UTF-8.
-    WTF_EXPORT_STRING_API static String fromUTF8WithLatin1Fallback(const LChar*, size_t);
+    WTF_EXPORT_PRIVATE static String fromUTF8WithLatin1Fallback(const LChar*, size_t);
     static String fromUTF8WithLatin1Fallback(const char* characters, size_t length) { return fromUTF8WithLatin1Fallback(reinterpret_cast<const LChar*>(characters), length); };
 
     // Determines the writing direction using the Unicode Bidi Algorithm rules P2 and P3.
@@ -362,7 +362,7 @@ public:
     unsigned existingHash() const { return isNull() ? 0 : impl()->existingHash(); }
 
 #ifndef NDEBUG
-    WTF_EXPORT_STRING_API void show() const;
+    WTF_EXPORT_PRIVATE void show() const;
 #endif
 
     // Turns this String empty if the StringImpl is not referenced by anyone else.
@@ -417,13 +417,13 @@ NSString * nsStringNilIfEmpty(const String&);
 
 #endif
 
-WTF_EXPORT_STRING_API int codePointCompare(const String&, const String&);
+WTF_EXPORT_PRIVATE int codePointCompare(const String&, const String&);
 bool codePointCompareLessThan(const String&, const String&);
 
 template<typename CharacterType> void appendNumber(Vector<CharacterType>&, unsigned char number);
 
 // Shared global empty string.
-WTF_EXPORT_STRING_API const String& emptyString();
+WTF_EXPORT_PRIVATE const String& emptyString();
 
 template<typename> struct DefaultHash;
 template<> struct DefaultHash<String> { using Hash = StringHash; };