className should be allowed to be a whitespace-only string

third_party/WebKit/Source/core/dom/Element.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Peter Kelly (pmk@post.com)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012, 2013 Apple Inc. All rights reserved.
  *           (C) 2007 Eric Seidel (eric@webkit.org)
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 135 matching lines @@
     DEFINE_STATIC_LOCAL(Persistent<ScrollCustomizationCallbacks>,
         scrollCustomizationCallbacks, (new ScrollCustomizationCallbacks()));
     return *scrollCustomizationCallbacks;
 }
 
 } // namespace
 
 using namespace HTMLNames;
 using namespace XMLNames;
 
+enum class ClassStringContent { Empty, WhiteSpaceOnly, HasClasses };
+
 PassRefPtrWillBeRawPtr<Element> Element::create(const QualifiedName& tagName, Document* document)
 {
     return adoptRefWillBeNoop(new Element(tagName, document, CreateElement));
 }
 
 Element::Element(const QualifiedName& tagName, Document* document, ConstructionType type)
     : ContainerNode(document, type)
     , m_tagName(tagName)
 {
 }
@@ skipping 1056 matching lines @@
 }
 
 inline void Element::attributeChangedFromParserOrByCloning(const QualifiedName& name, const AtomicString& newValue, AttributeModificationReason reason)
 {
     if (name == isAttr)
         CustomElementRegistrationContext::setTypeExtension(this, newValue);
     attributeChanged(name, newValue, reason);
 }
 
 template <typename CharacterType>
-static inline bool classStringHasClassName(const CharacterType* characters, unsigned length)
+static inline ClassStringContent classStringHasClassName(const CharacterType* characters, unsigned length)
 {
     ASSERT(length > 0);
 
     unsigned i = 0;
     do {
         if (isNotHTMLSpace<CharacterType>(characters[i]))
             break;
         ++i;
     } while (i < length);
 
-    return i < length;
+    if (i == length && length == 1)
+        return ClassStringContent::Empty;
+    if (i == length && length > 1)
+        return ClassStringContent::WhiteSpaceOnly;
+
+    return ClassStringContent::HasClasses;
 }
 
-static inline bool classStringHasClassName(const AtomicString& newClassString)
+static inline ClassStringContent classStringHasClassName(const AtomicString& newClassString)
 {
     unsigned length = newClassString.length();
 
     if (!length)
-        return false;
+        return ClassStringContent::Empty;
 
     if (newClassString.is8Bit())
         return classStringHasClassName(newClassString.characters8(), length);
     return classStringHasClassName(newClassString.characters16(), length);
 }
 
 void Element::classAttributeChanged(const AtomicString& newClassString)
 {
     StyleResolver* styleResolver = document().styleResolver();
     bool testShouldInvalidateStyle = inActiveDocument() && styleResolver && styleChangeType() < SubtreeStyleChange;
 
     ASSERT(elementData());
-    if (classStringHasClassName(newClassString)) {
-        const bool shouldFoldCase = document().inQuirksMode();
+    ClassStringContent classStringContentType = classStringHasClassName(newClassString);
+    const bool shouldFoldCase = document().inQuirksMode();
+    if (classStringContentType == ClassStringContent::HasClasses) {
         const SpaceSplitString oldClasses = elementData()->classNames();
         elementData()->setClass(newClassString, shouldFoldCase);
         const SpaceSplitString& newClasses = elementData()->classNames();
         if (testShouldInvalidateStyle)
             document().styleEngine().classChangedForElement(oldClasses, newClasses, *this);
     } else {
         const SpaceSplitString& oldClasses = elementData()->classNames();
         if (testShouldInvalidateStyle)
             document().styleEngine().classChangedForElement(oldClasses, *this);
-        elementData()->clearClass();
+        if (classStringContentType == ClassStringContent::WhiteSpaceOnly)
+            elementData()->setClass(newClassString, shouldFoldCase);
+        else
+            elementData()->clearClass();
     }
 
     if (hasRareData())
         elementRareData()->clearClassListValueForQuirksMode();
 }
 
 bool Element::shouldInvalidateDistributionWhenAttributeChanged(ElementShadow* elementShadow, const QualifiedName& name, const AtomicString& newValue)
 {
     ASSERT(elementShadow);
     const SelectRuleFeatureSet& featureSet = elementShadow->ensureSelectFeatureSet();
 
     if (name == HTMLNames::idAttr) {
         AtomicString oldId = elementData()->idForStyleResolution();
         AtomicString newId = makeIdForStyleResolution(newValue, document().inQuirksMode());
         if (newId != oldId) {
             if (!oldId.isEmpty() && featureSet.hasSelectorForId(oldId))
                 return true;
             if (!newId.isEmpty() && featureSet.hasSelectorForId(newId))
                 return true;
         }
     }
 
     if (name == HTMLNames::classAttr) {
         const AtomicString& newClassString = newValue;
-        if (classStringHasClassName(newClassString)) {
+        if (classStringHasClassName(newClassString) == ClassStringContent::HasClasses) {
             const SpaceSplitString& oldClasses = elementData()->classNames();
             const SpaceSplitString newClasses(newClassString, document().inQuirksMode() ? SpaceSplitString::ShouldFoldCase : SpaceSplitString::ShouldNotFoldCase);
             if (featureSet.checkSelectorsForClassChange(oldClasses, newClasses))
                 return true;
         } else {
             const SpaceSplitString& oldClasses = elementData()->classNames();
             if (featureSet.checkSelectorsForClassChange(oldClasses))
                 return true;
         }
     }
@@ skipping 2253 matching lines @@
 {
 #if ENABLE(OILPAN)
     if (hasRareData())
         visitor->trace(elementRareData());
     visitor->trace(m_elementData);
 #endif
     ContainerNode::trace(visitor);
 }
 
 } // namespace blink