Allow more characters in element/attribute names and prefixes

https://bugs.webkit.org/show_bug.cgi?id=241419

Reviewed by NOBODY (OOPS!).

Implement relaxed name-validation rules per whatwg/dom#1079, whatwg/html#7991,
and whatwg/html#11453. This aligns DOM API name behavior with HTML parser behavior —
which has always allowed a wider range of characters in element and attribute names.

New validation functions in NameValidation.h/cpp:

- isValidElementName(): For createElement — allows [A-Za-z] start followed by
  any char except null/whitespace/>//, or [:_>=0x80] start with restricted continuation
- isValidAttributeName(): For setAttribute/toggleAttribute/createAttribute —
  no null, whitespace, /, >, or =
- isValidNamespacePrefix(): For *NS methods — no null, whitespace, /, or >
- isValidDoctypeName(): For createDocumentType — no null, whitespace, or >
- isValidXMLName(): Preserves old XML Name production for createProcessingInstruction

* Source/WebCore/Headers.cmake:
* Source/WebCore/Sources.txt:
* Source/WebCore/dom/DOMImplementation.cpp:
(WebCore::DOMImplementation::createDocumentType):
* Source/WebCore/dom/Document.cpp:
(WebCore::isValidHTMLElementName):
(WebCore::Document::createElement):
(WebCore::Document::createProcessingInstruction):
(WebCore::Document::createElementNS):
(WebCore::parseQualifiedName):
(WebCore::Document::parseQualifiedAttributeName):
(WebCore::Document::createAttribute):
(WebCore::Document::createAttributeNS):
* Source/WebCore/dom/Document.h:
* Source/WebCore/dom/Element.cpp:
(WebCore::Element::toggleAttribute):
(WebCore::Element::setAttribute):
(WebCore::Element::parseAttributeName):
* Source/WebCore/dom/NameValidation.cpp: Added.
(WebCore::NameValidation::isValidElementName):
(WebCore::NameValidation::isValidAttributeName):
(WebCore::NameValidation::isValidNamespacePrefix):
(WebCore::NameValidation::isValidDoctypeName):
(WebCore::NameValidation::isValidXMLName):
* Source/WebCore/dom/NameValidation.h: Added.
* Source/WebCore/dom/Node.cpp:
(WebCore::Node::checkSetPrefix):
* Source/WebCore/dom/messageports/WorkerMessagePortChannelProvider.h:
* Source/WebCore/editing/EditorCommand.cpp:
(WebCore::executeFormatBlock):
* Source/WebCore/svg/animation/SVGSMILElement.cpp:
(WebCore::SVGSMILElement::constructAttributeName):

Author: sideshowbarker

Source/WebCore/Headers.cmake

@@ -1438,6 +1438,7 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
     dom/MutationObserver.h
     dom/MutationObserverOptions.h
     dom/NameNodeList.h
+    dom/NameValidation.h
     dom/NamedNodeMap.h
     dom/NativeNodeFilter.h
     dom/Node.h

Source/WebCore/Sources.txt

@@ -1316,6 +1316,7 @@ dom/MutationObserverInterestGroup.cpp
 dom/MutationObserverRegistration.cpp
 dom/MutationRecord.cpp
 dom/NameNodeList.cpp
+dom/NameValidation.cpp
 dom/NamedNodeMap.cpp
 dom/NativeNodeFilter.cpp
 dom/Node.cpp

Source/WebCore/WebCore.xcodeproj/project.pbxproj

@@ -4465,6 +4465,7 @@
 		A818721B0977D3C0005826D9 /* NodeList.h in Headers */ = {isa = PBXBuildFile; fileRef = A81872100977D3C0005826D9 /* NodeList.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		A818721C0977D3C0005826D9 /* ContainerNode.h in Headers */ = {isa = PBXBuildFile; fileRef = A81872110977D3C0005826D9 /* ContainerNode.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		A818721E0977D3C0005826D9 /* NameNodeList.h in Headers */ = {isa = PBXBuildFile; fileRef = A81872130977D3C0005826D9 /* NameNodeList.h */; settings = {ATTRIBUTES = (Private, ); }; };
+		5CC59425C83340698819A8EE /* NameValidation.h in Headers */ = {isa = PBXBuildFile; fileRef = 1043649292C14384B5937F8F /* NameValidation.h */; };
 		A81872200977D3C0005826D9 /* ChildNodeList.h in Headers */ = {isa = PBXBuildFile; fileRef = A81872150977D3C0005826D9 /* ChildNodeList.h */; };
 		A81872230977D3C0005826D9 /* NamedNodeMap.h in Headers */ = {isa = PBXBuildFile; fileRef = A81872180977D3C0005826D9 /* NamedNodeMap.h */; settings = {ATTRIBUTES = (Private, ); }; };
 		A8239E0109B3CF8A00B60641 /* Logging.h in Headers */ = {isa = PBXBuildFile; fileRef = A8239DFF09B3CF8A00B60641 /* Logging.h */; settings = {ATTRIBUTES = (Private, ); }; };
@@ -17347,6 +17348,8 @@
 		A81872100977D3C0005826D9 /* NodeList.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = NodeList.h; sourceTree = "<group>"; };
 		A81872110977D3C0005826D9 /* ContainerNode.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ContainerNode.h; sourceTree = "<group>"; };
 		A81872130977D3C0005826D9 /* NameNodeList.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = NameNodeList.h; sourceTree = "<group>"; };
+		A87BC832E99A41359C1D4FA8 /* NameValidation.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = NameValidation.cpp; sourceTree = "<group>"; };
+		1043649292C14384B5937F8F /* NameValidation.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NameValidation.h; sourceTree = "<group>"; };
 		A81872140977D3C0005826D9 /* ContainerNode.cpp */ = {isa = PBXFileReference; fileEncoding = 30; indentWidth = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ContainerNode.cpp; sourceTree = "<group>"; };
 		A81872150977D3C0005826D9 /* ChildNodeList.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ChildNodeList.h; sourceTree = "<group>"; };
 		A81872180977D3C0005826D9 /* NamedNodeMap.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = NamedNodeMap.h; sourceTree = "<group>"; };
@@ -41340,6 +41343,8 @@
 				85ACA9F90A9B631000671E90 /* NamedNodeMap.idl */,
 				A81872190977D3C0005826D9 /* NameNodeList.cpp */,
 				A81872130977D3C0005826D9 /* NameNodeList.h */,
+				A87BC832E99A41359C1D4FA8 /* NameValidation.cpp */,
+				1043649292C14384B5937F8F /* NameValidation.h */,
 				8306EFF01B8BCE7C0031D032 /* NativeNodeFilter.cpp */,
 				83E959E11B8BC22B004D9385 /* NativeNodeFilter.h */,
 				71FF851822A3F81F005D5959 /* NavigatorMaxTouchPoints.idl */,
@@ -45844,6 +45849,7 @@
 				A81872230977D3C0005826D9 /* NamedNodeMap.h in Headers */,
 				A818721E0977D3C0005826D9 /* NameNodeList.h in Headers */,
 				3227A93128BD744C00BC2697 /* Namespace.h in Headers */,
+				5CC59425C83340698819A8EE /* NameValidation.h in Headers */,
 				726D56E3253AE3660002EF90 /* NativeImage.h in Headers */,
 				72854E692B6987B700E0181A /* NativeImageSource.h in Headers */,
 				83B2D1751B8BCD6A00A02E47 /* NativeNodeFilter.h in Headers */,

Source/WebCore/dom/DOMImplementation.cpp

@@ -44,6 +44,7 @@
 #include "MediaDocument.h"
 #include "MediaPlayer.h"
 #include "MediaQueryParser.h"
+#include "NameValidation.h"
 #include "PDFDocument.h"
 #include "ParserContentPolicy.h"
 #include "PluginData.h"
@@ -83,9 +84,8 @@ DOMImplementation::DOMImplementation(Document& document)
 
 ExceptionOr<Ref<DocumentType>> DOMImplementation::createDocumentType(const AtomString& qualifiedName, const String& publicId, const String& systemId)
 {
-    auto parseResult = Document::parseQualifiedName(qualifiedName);
-    if (parseResult.hasException())
-        return parseResult.releaseException();
+    if (!NameValidation::isValidDoctypeName(qualifiedName))
+        return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid doctype name: '"_s, qualifiedName, '\'') };
     return DocumentType::create(protectedDocument(), qualifiedName, publicId, systemId);
 }
 

Source/WebCore/dom/Document.cpp

@@ -198,6 +198,7 @@
 #include "MouseEventWithHitTestResults.h"
 #include "MutationEvent.h"
 #include "NameNodeList.h"
+#include "NameValidation.h"
 #include "Navigation.h"
 #include "NavigationActivation.h"
 #include "NavigationDisabler.h"
@@ -517,24 +518,6 @@ static void CallbackForContainIntrinsicSize(const Vector<Ref<ResizeObserverEntry
     }
 }
 
-// https://www.w3.org/TR/xml/#NT-NameStartChar
-// NameStartChar       ::=       ":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
-static inline bool isValidNameStart(char32_t c)
-{
-    return c == ':' || (c >= 'A' && c <= 'Z') || c == '_' || (c >= 'a' && c <= 'z') || (c >= 0x00C0 && c <= 0x00D6)
-        || (c >= 0x00D8 && c <= 0x00F6) || (c >= 0x00F8 && c <= 0x02FF) || (c >= 0x0370 && c <= 0x037D) || (c >= 0x037F && c <= 0x1FFF)
-        || (c >= 0x200C && c <= 0x200D) || (c >= 0x2070 && c <= 0x218F) || (c >= 0x2C00 && c <= 0x2FeF) || (c >= 0x3001 && c <= 0xD7FF)
-        || (c >= 0xF900 && c <= 0xFDCF) || (c >= 0xFDF0 && c <= 0xFFFD) || (c >= 0x10000 && c <= 0xEFFFF);
-}
-
-// https://www.w3.org/TR/xml/#NT-NameChar
-// NameChar       ::=       NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
-static inline bool isValidNamePart(char32_t c)
-{
-    return isValidNameStart(c) || c == '-' || c == '.' || (c >= '0' && c <= '9') || c == 0x00B7
-        || (c >= 0x0300 && c <= 0x036F) || (c >= 0x203F && c <= 0x2040);
-}
-
 static Widget* widgetForElement(Element* focusedElement)
 {
     auto* renderer = focusedElement ? dynamicDowncast<RenderWidget>(focusedElement->renderer()) : nullptr;
@@ -1565,16 +1548,6 @@ static ALWAYS_INLINE Ref<HTMLElement> createUpgradeCandidateElement(Document& do
     return createUpgradeCandidateElement(document, registry, QualifiedName { nullAtom(), localName, xhtmlNamespaceURI });
 }
 
-static inline bool isValidHTMLElementName(const AtomString& localName)
-{
-    return Document::isValidName(localName);
-}
-
-static inline bool isValidHTMLElementName(const QualifiedName& name)
-{
-    return Document::isValidName(name.localName());
-}
-
 template<typename NameType>
 static ExceptionOr<Ref<Element>> createHTMLElementWithNameValidation(Document& document, const NameType& name, CustomElementRegistry* registry)
 {
@@ -1590,7 +1563,7 @@ static ExceptionOr<Ref<Element>> createHTMLElementWithNameValidation(Document& d
             return elementInterface->constructElementWithFallback(document, *registry, name);
     }
 
-    if (!isValidHTMLElementName(name)) [[unlikely]]
+    if (!NameValidation::isValidElementName(name)) [[unlikely]]
         return Exception { ExceptionCode::InvalidCharacterError };
 
     return Ref<Element> { createUpgradeCandidateElement(document, registry, name) };
@@ -1620,7 +1593,7 @@ ExceptionOr<Ref<Element>> Document::createElementForBindings(const AtomString& n
         if (document->isXHTMLDocument())
             return createHTMLElementWithNameValidation(document, name, registry.get());
 
-        if (!document->isValidName(name))
+        if (!NameValidation::isValidElementName(name))
             return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid qualified name: '"_s, name, '\'') };
 
         return createElement(QualifiedName(nullAtom(), name, nullAtom()), false, registry.get());
@@ -1671,8 +1644,8 @@ ExceptionOr<Ref<CDATASection>> Document::createCDATASection(String&& data)
 
 ExceptionOr<Ref<ProcessingInstruction>> Document::createProcessingInstruction(String&& target, String&& data)
 {
-    if (!isValidName(target))
-        return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid qualified name: '"_s, target, '\'') };
+    if (!NameValidation::isValidXMLName(target))
+        return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid processing instruction target: '"_s, target, '\'') };
 
     if (data.contains("?>"_s))
         return Exception { ExceptionCode::InvalidCharacterError };
@@ -1765,28 +1738,6 @@ ExceptionOr<Ref<Node>> Document::adoptNode(Node& source)
     return Ref<Node> { source };
 }
 
-bool Document::hasValidNamespaceForElements(const QualifiedName& qName)
-{
-    // These checks are from DOM Core Level 2, createElementNS
-    // http://www.w3.org/TR/DOM-Level-2-Core/core.html#ID-DocCrElNS
-    if (!qName.prefix().isEmpty() && qName.namespaceURI().isNull()) // createElementNS(null, "html:div")
-        return false;
-    if (qName.prefix() == xmlAtom() && qName.namespaceURI() != XMLNames::xmlNamespaceURI) // createElementNS("http://www.example.com", "xml:lang")
-        return false;
-
-    // Required by DOM Level 3 Core and unspecified by DOM Level 2 Core:
-    // http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407/core.html#ID-DocCrElNS
-    // createElementNS("http://www.w3.org/2000/xmlns/", "foo:bar"), createElementNS(null, "xmlns:bar"), createElementNS(null, "xmlns")
-    if (qName.prefix() == xmlnsAtom() || (qName.prefix().isEmpty() && qName.localName() == xmlnsAtom()))
-        return qName.namespaceURI() == XMLNSNames::xmlnsNamespaceURI;
-    return qName.namespaceURI() != XMLNSNames::xmlnsNamespaceURI;
-}
-
-bool Document::hasValidNamespaceForAttributes(const QualifiedName& qName)
-{
-    return hasValidNamespaceForElements(qName);
-}
-
 static Ref<HTMLElement> createFallbackHTMLElement(Document& document, CustomElementRegistry* registry, const QualifiedName& name)
 {
     if (registry) {
@@ -2058,11 +2009,11 @@ ExceptionOr<Ref<Element>> Document::createElementNS(const AtomString& namespaceU
         if (opportunisticallyMatchedBuiltinElement) [[likely]]
             return opportunisticallyMatchedBuiltinElement.releaseNonNull();
 
-        auto parseResult = Document::parseQualifiedName(namespaceURI, qualifiedName);
+        auto parseResult = NameValidation::parseQualifiedElementName(namespaceURI, qualifiedName);
         if (parseResult.hasException())
             return parseResult.releaseException();
         QualifiedName parsedName { parseResult.releaseReturnValue() };
-        if (!Document::hasValidNamespaceForElements(parsedName))
+        if (!NameValidation::hasValidNamespaceForElements(parsedName))
             return Exception { ExceptionCode::NamespaceError };
 
         if (parsedName.namespaceURI() == xhtmlNamespaceURI)
@@ -7520,138 +7471,6 @@ void Document::updateCachedCookiesEnabled()
     });
 }
 
-static bool isValidNameNonASCII(std::span<const Latin1Character> characters)
-{
-    if (!isValidNameStart(characters[0]))
-        return false;
-
-    for (size_t i = 1; i < characters.size(); ++i) {
-        if (!isValidNamePart(characters[i]))
-            return false;
-    }
-
-    return true;
-}
-
-static bool isValidNameNonASCII(std::span<const char16_t> characters)
-{
-    for (size_t i = 0; i < characters.size();) {
-        bool first = !i;
-        char32_t c;
-        U16_NEXT(characters, i, characters.size(), c); // Increments i.
-        if (first ? !isValidNameStart(c) : !isValidNamePart(c))
-            return false;
-    }
-
-    return true;
-}
-
-template<typename CharType>
-static inline bool isValidNameASCII(std::span<const CharType> characters)
-{
-    CharType c = characters[0];
-    if (!(isASCIIAlpha(c) || c == ':' || c == '_'))
-        return false;
-
-    for (size_t i = 1; i < characters.size(); ++i) {
-        c = characters[i];
-        if (!(isASCIIAlphanumeric(c) || c == ':' || c == '_' || c == '-' || c == '.'))
-            return false;
-    }
-
-    return true;
-}
-
-static bool isValidNameASCIIWithoutColon(std::span<const Latin1Character> characters)
-{
-    auto c = characters.front();
-    if (!(isASCIIAlpha(c) || c == '_'))
-        return false;
-
-    for (size_t i = 1; i < characters.size(); ++i) {
-        c = characters[i];
-        if (!(isASCIIAlphanumeric(c) || c == '_' || c == '-' || c == '.'))
-            return false;
-    }
-
-    return true;
-}
-
-bool Document::isValidName(const String& name)
-{
-    unsigned length = name.length();
-    if (!length)
-        return false;
-
-    if (name.is8Bit()) {
-        auto characters = name.span8();
-
-        if (isValidNameASCII(characters))
-            return true;
-
-        return isValidNameNonASCII(characters);
-    }
-
-    auto characters = name.span16();
-
-    if (isValidNameASCII(characters))
-        return true;
-
-    return isValidNameNonASCII(characters);
-}
-
-ExceptionOr<std::pair<AtomString, AtomString>> Document::parseQualifiedName(const AtomString& qualifiedName)
-{
-    unsigned length = qualifiedName.length();
-
-    if (!length)
-        return Exception { ExceptionCode::InvalidCharacterError };
-
-    bool nameStart = true;
-    bool sawColon = false;
-    unsigned colonPosition = 0;
-
-    bool isValidLocalName = qualifiedName.is8Bit() && isValidNameASCIIWithoutColon(qualifiedName.span8());
-    if (isValidLocalName) [[likely]]
-        return std::pair<AtomString, AtomString> { { }, { qualifiedName } };
-
-    for (unsigned i = 0; i < length; ) {
-        char32_t c;
-        U16_NEXT(qualifiedName, i, length, c);
-        if (c == ':') {
-            if (sawColon)
-                return Exception { ExceptionCode::InvalidCharacterError, makeString("Unexpected colon in qualified name '"_s, qualifiedName, '\'') };
-            nameStart = true;
-            sawColon = true;
-            colonPosition = i - 1;
-        } else if (nameStart) {
-            if (!isValidNameStart(c))
-                return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid qualified name start in '"_s, qualifiedName, '\'') };
-            nameStart = false;
-        } else {
-            if (!isValidNamePart(c))
-                return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid qualified name part in '"_s, qualifiedName, '\'') };
-        }
-    }
-
-    if (!sawColon)
-        return std::pair<AtomString, AtomString> { { }, { qualifiedName } };
-
-    if (!colonPosition || length - colonPosition <= 1)
-        return Exception { ExceptionCode::InvalidCharacterError, makeString("Namespace in qualified name '"_s, qualifiedName, "' is too short"_s) };
-
-    return std::pair<AtomString, AtomString> { StringView { qualifiedName }.left(colonPosition).toAtomString(), StringView { qualifiedName }.substring(colonPosition + 1).toAtomString() };
-}
-
-ExceptionOr<QualifiedName> Document::parseQualifiedName(const AtomString& namespaceURI, const AtomString& qualifiedName)
-{
-    auto parseResult = parseQualifiedName(qualifiedName);
-    if (parseResult.hasException())
-        return parseResult.releaseException();
-    auto parsedPieces = parseResult.releaseReturnValue();
-    return QualifiedName { parsedPieces.first, parsedPieces.second, namespaceURI };
-}
-
 void Document::setDecoder(RefPtr<TextResourceDecoder>&& decoder)
 {
     m_decoder = WTF::move(decoder);
@@ -8227,18 +8046,18 @@ Ref<ScriptRunner> Document::protectedScriptRunner()
 
 ExceptionOr<Ref<Attr>> Document::createAttribute(const AtomString& localName)
 {
-    if (!isValidName(localName))
-        return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid qualified name: '"_s, localName, '\'') };
+    if (!NameValidation::isValidAttributeName(localName))
+        return Exception { ExceptionCode::InvalidCharacterError, makeString("Invalid attribute name: '"_s, localName, '\'') };
     return Attr::create(*this, QualifiedName { nullAtom(), isHTMLDocument() ? localName.convertToASCIILowercase() : localName, nullAtom() }, emptyAtom());
 }
 
 ExceptionOr<Ref<Attr>> Document::createAttributeNS(const AtomString& namespaceURI, const AtomString& qualifiedName, bool shouldIgnoreNamespaceChecks)
 {
-    auto parseResult = parseQualifiedName(namespaceURI, qualifiedName);
+    auto parseResult = NameValidation::parseQualifiedAttributeName(namespaceURI, qualifiedName);
     if (parseResult.hasException())
         return parseResult.releaseException();
     QualifiedName parsedName { parseResult.releaseReturnValue() };
-    if (!shouldIgnoreNamespaceChecks && !hasValidNamespaceForAttributes(parsedName))
+    if (!shouldIgnoreNamespaceChecks && !NameValidation::hasValidNamespaceForAttributes(parsedName))
         return Exception { ExceptionCode::NamespaceError };
     return Attr::create(*this, parsedName, emptyAtom());
 }

Source/WebCore/dom/Document.h

@@ -1238,20 +1238,6 @@ class Document
     void setSiteForCookies(const URL& url) { m_siteForCookies = url; }
     bool isSameSiteForCookies(const URL&) const;
 
-    // The following implements the rule from HTML 4 for what valid names are.
-    // To get this right for all the XML cases, we probably have to improve this or move it
-    // and make it sensitive to the type of document.
-    static bool isValidName(const String&);
-
-    // The following breaks a qualified name into a prefix and a local name.
-    // It also does a validity check, and returns an error if the qualified name is invalid.
-    static ExceptionOr<std::pair<AtomString, AtomString>> parseQualifiedName(const AtomString& qualifiedName);
-    static ExceptionOr<QualifiedName> parseQualifiedName(const AtomString& namespaceURI, const AtomString& qualifiedName);
-
-    // Checks to make sure prefix and namespace do not conflict (per DOM Core 3)
-    static bool hasValidNamespaceForElements(const QualifiedName&);
-    static bool hasValidNamespaceForAttributes(const QualifiedName&);
-
     // This is the "HTML body element" as defined by CSSOM View spec, the first body child of the
     // document element. See http://dev.w3.org/csswg/cssom-view/#the-html-body-element.
     WEBCORE_EXPORT HTMLBodyElement* body() const;