Rename AtomicString to AtomString
[WebKit.git] / Source / WebCore / html / DOMTokenList.cpp
index cdbc252..7af20a3 100644 (file)
@@ -30,7 +30,7 @@
 #include "SpaceSplitString.h"
 #include <wtf/HashSet.h>
 #include <wtf/SetForScope.h>
-#include <wtf/text/AtomicStringHash.h>
+#include <wtf/text/AtomStringHash.h>
 #include <wtf/text/StringBuilder.h>
 
 namespace WebCore {
@@ -68,7 +68,7 @@ ExceptionOr<void> DOMTokenList::validateTokens(const String* tokens, size_t leng
     return { };
 }
 
-bool DOMTokenList::contains(const AtomicString& token) const
+bool DOMTokenList::contains(const AtomString& token) const
 {
     return tokens().contains(token);
 }
@@ -76,7 +76,7 @@ bool DOMTokenList::contains(const AtomicString& token) const
 inline ExceptionOr<void> DOMTokenList::addInternal(const String* newTokens, size_t length)
 {
     // This is usually called with a single token.
-    Vector<AtomicString, 1> uniqueNewTokens;
+    Vector<AtomString, 1> uniqueNewTokens;
     uniqueNewTokens.reserveInitialCapacity(length);
 
     auto& tokens = this->tokens();
@@ -102,7 +102,7 @@ ExceptionOr<void> DOMTokenList::add(const Vector<String>& tokens)
     return addInternal(tokens.data(), tokens.size());
 }
 
-ExceptionOr<void> DOMTokenList::add(const AtomicString& token)
+ExceptionOr<void> DOMTokenList::add(const AtomString& token)
 {
     return addInternal(&token.string(), 1);
 }
@@ -127,12 +127,12 @@ ExceptionOr<void> DOMTokenList::remove(const Vector<String>& tokens)
     return removeInternal(tokens.data(), tokens.size());
 }
 
-ExceptionOr<void> DOMTokenList::remove(const AtomicString& token)
+ExceptionOr<void> DOMTokenList::remove(const AtomString& token)
 {
     return removeInternal(&token.string(), 1);
 }
 
-ExceptionOr<bool> DOMTokenList::toggle(const AtomicString& token, std::optional<bool> force)
+ExceptionOr<bool> DOMTokenList::toggle(const AtomString& token, Optional<bool> force)
 {
     auto result = validateToken(token);
     if (result.hasException())
@@ -141,7 +141,7 @@ ExceptionOr<bool> DOMTokenList::toggle(const AtomicString& token, std::optional<
     auto& tokens = this->tokens();
 
     if (tokens.contains(token)) {
-        if (!force.value_or(false)) {
+        if (!force.valueOr(false)) {
             tokens.removeFirst(token);
             updateAssociatedAttributeFromTokens();
             return false;
@@ -157,33 +157,48 @@ ExceptionOr<bool> DOMTokenList::toggle(const AtomicString& token, std::optional<
     return true;
 }
 
+static inline void replaceInOrderedSet(Vector<AtomString>& tokens, size_t tokenIndex, const AtomString& newToken)
+{
+    ASSERT(tokenIndex != notFound);
+    ASSERT(tokenIndex < tokens.size());
+
+    auto newTokenIndex = tokens.find(newToken);
+    if (newTokenIndex == notFound) {
+        tokens[tokenIndex] = newToken;
+        return;
+    }
+
+    if (newTokenIndex == tokenIndex)
+        return;
+
+    if (newTokenIndex > tokenIndex) {
+        tokens[tokenIndex] = newToken;
+        tokens.remove(newTokenIndex);
+    } else
+        tokens.remove(tokenIndex);
+}
+
 // https://dom.spec.whatwg.org/#dom-domtokenlist-replace
-ExceptionOr<void> DOMTokenList::replace(const AtomicString& item, const AtomicString& replacement)
+ExceptionOr<bool> DOMTokenList::replace(const AtomString& token, const AtomString& newToken)
 {
-    if (item.isEmpty() || replacement.isEmpty())
+    if (token.isEmpty() || newToken.isEmpty())
         return Exception { SyntaxError };
 
-    if (tokenContainsHTMLSpace(item) || tokenContainsHTMLSpace(replacement))
+    if (tokenContainsHTMLSpace(token) || tokenContainsHTMLSpace(newToken))
         return Exception { InvalidCharacterError };
 
     auto& tokens = this->tokens();
 
-    auto matchesItemOrReplacement = [&](auto& token) {
-        return token == item || token == replacement;
-    };
-
-    size_t index = tokens.findMatching(matchesItemOrReplacement);
-    if (index == notFound)
-        return { };
+    auto tokenIndex = tokens.find(token);
+    if (tokenIndex == notFound)
+        return false;
 
-    tokens[index] = replacement;
-    tokens.removeFirstMatching(matchesItemOrReplacement, index + 1);
-    ASSERT(item == replacement || tokens.find(item) == notFound);
-    ASSERT(tokens.reverseFind(replacement) == index);
+    replaceInOrderedSet(tokens, tokenIndex, newToken);
+    ASSERT(token == newToken || tokens.find(token) == notFound);
 
     updateAssociatedAttributeFromTokens();
 
-    return { };
+    return true;
 }
 
 // https://dom.spec.whatwg.org/#concept-domtokenlist-validation
@@ -195,7 +210,7 @@ ExceptionOr<bool> DOMTokenList::supports(StringView token)
 }
 
 // https://dom.spec.whatwg.org/#dom-domtokenlist-value
-const AtomicString& DOMTokenList::value() const
+const AtomString& DOMTokenList::value() const
 {
     return m_element.getAttribute(m_attributeName);
 }
@@ -210,7 +225,7 @@ void DOMTokenList::updateTokensFromAttributeValue(const String& value)
     // Clear tokens but not capacity.
     m_tokens.shrink(0);
 
-    HashSet<AtomicString> addedTokens;
+    HashSet<AtomString> addedTokens;
     // https://dom.spec.whatwg.org/#ordered%20sets
     for (unsigned start = 0; ; ) {
         while (start < value.length() && isHTMLSpace(value[start]))
@@ -221,7 +236,7 @@ void DOMTokenList::updateTokensFromAttributeValue(const String& value)
         while (end < value.length() && !isHTMLSpace(value[end]))
             ++end;
 
-        AtomicString token = value.substring(start, end - start);
+        AtomString token = value.substring(start, end - start);
         if (!addedTokens.contains(token)) {
             m_tokens.append(token);
             addedTokens.add(token);
@@ -234,7 +249,7 @@ void DOMTokenList::updateTokensFromAttributeValue(const String& value)
     m_tokensNeedUpdating = false;
 }
 
-void DOMTokenList::associatedAttributeValueChanged(const AtomicString&)
+void DOMTokenList::associatedAttributeValueChanged(const AtomString&)
 {
     // Do not reset the DOMTokenList value if the attribute value was changed by us.
     if (m_inUpdateAssociatedAttributeFromTokens)
@@ -258,13 +273,13 @@ void DOMTokenList::updateAssociatedAttributeFromTokens()
             builder.append(' ');
         builder.append(token);
     }
-    AtomicString serializedValue = builder.toAtomicString();
+    AtomString serializedValue = builder.toAtomString();
 
     SetForScope<bool> inAttributeUpdate(m_inUpdateAssociatedAttributeFromTokens, true);
     m_element.setAttribute(m_attributeName, serializedValue);
 }
 
-Vector<AtomicString>& DOMTokenList::tokens()
+Vector<AtomString>& DOMTokenList::tokens()
 {
     if (m_tokensNeedUpdating)
         updateTokensFromAttributeValue(m_element.getAttribute(m_attributeName));