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 1211 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 bool classStringHasClassName(const CharacterType* characters, unsigned length, bool& isWhiteSpaceOnly)

[tkent, 2015/10/08 23:20:12]

We should introduce an enum, and this function should return it.

e.g.

enum class ClassStringContent {
    Empty,
    WhiteSpaceOnly,
    HasClasses
};

template <typename CharacterType>
static inline ClassStringContent analyzeClassString(const CharacterType*
characters, unsigned length) ...

 {
     ASSERT(length > 0);
 
+    isWhiteSpaceOnly = false;
     unsigned i = 0;
     do {
         if (isNotHTMLSpace<CharacterType>(characters[i]))
             break;
         ++i;
     } while (i < length);
 
+    if (i == length)
+        isWhiteSpaceOnly = true;
+
     return i < length;
 }
 
-static inline bool classStringHasClassName(const AtomicString& newClassString)
+static inline bool classStringHasClassName(const AtomicString& newClassString, bool& isWhiteSpaceOnly)
 {
     unsigned length = newClassString.length();
 
     if (!length)
         return false;
 
     if (newClassString.is8Bit())
-        return classStringHasClassName(newClassString.characters8(), length);
-    return classStringHasClassName(newClassString.characters16(), length);
+        return classStringHasClassName(newClassString.characters8(), length, isWhiteSpaceOnly);
+    return classStringHasClassName(newClassString.characters16(), length, isWhiteSpaceOnly);
 }
 
 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();
+
+    bool isWhiteSpaceOnlyClassname;

[tkent, 2015/10/08 23:20:12]

This variable needs to be initialized, or classStringHasClassName() should set
false in i!=length case.

+    const bool shouldFoldCase = document().inQuirksMode();
+    if (classStringHasClassName(newClassString, isWhiteSpaceOnlyClassname)) {
         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 (isWhiteSpaceOnlyClassname)
+            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)) {
+        bool isWhiteSpaceOnlyClassname;
+        if (classStringHasClassName(newClassString, isWhiteSpaceOnlyClassname)) {
             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