Revert 93001 - Apple-style-span class seems unnecessary

Source/WebCore/editing/ApplyStyleCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 43 matching lines @@
 namespace WebCore {
 
 using namespace HTMLNames;
 
 static String& styleSpanClassString()
 {
     DEFINE_STATIC_LOCAL(String, styleSpanClassString, ((AppleStyleSpanClass)));
     return styleSpanClassString;
 }
 
-bool isLegacyAppleStyleSpan(const Node *node)
+bool isStyleSpan(const Node *node)
 {
     if (!node || !node->isHTMLElement())
         return false;
 
     const HTMLElement* elem = static_cast<const HTMLElement*>(node);
     return elem->hasLocalName(spanAttr) && elem->getAttribute(classAttr) == styleSpanClassString();
 }
 
 enum ShouldStyleAttributeBeEmpty { AllowNonEmptyStyleAttribute, StyleAttributeShouldBeEmpty };
 static bool hasNoAttributeOrOnlyStyleAttribute(const StyledElement* element, ShouldStyleAttributeBeEmpty shouldStyleAttributeBeEmpty)
@@ skipping 14 matching lines @@
     return matchedAttributes == map->length();
 }
 
 bool isStyleSpanOrSpanWithOnlyStyleAttribute(const Element* element)
 {
     if (!element || !element->hasTagName(spanTag))
         return false;
     return hasNoAttributeOrOnlyStyleAttribute(toHTMLElement(element), AllowNonEmptyStyleAttribute);
 }
 
-static inline bool isSpanWithoutAttributesOrUnstyledStyleSpan(const Node* node)
+static inline bool isUnstyledStyleSpan(const Node* node)
+{
+    return isStyleSpan(node) && hasNoAttributeOrOnlyStyleAttribute(toHTMLElement(node), StyleAttributeShouldBeEmpty);
+}
+
+static inline bool isSpanWithoutAttributesOrUnstyleStyleSpan(const Node* node)
 {
     if (!node || !node->isHTMLElement() || !node->hasTagName(spanTag))
         return false;
     return hasNoAttributeOrOnlyStyleAttribute(toHTMLElement(node), StyleAttributeShouldBeEmpty);
 }
 
 static bool isEmptyFontTag(const Node *node)
 {
     if (!node || !node->hasTagName(fontTag))
         return false;
 
     const Element *elem = static_cast<const Element *>(node);
     NamedNodeMap *map = elem->attributes(true); // true for read-only
     if (!map)
         return true;
     return map->isEmpty() || (map->length() == 1 && elem->getAttribute(classAttr) == styleSpanClassString());
 }
 
 static PassRefPtr<Element> createFontElement(Document* document)
 {
     RefPtr<Element> fontNode = createHTMLElement(document, fontTag);
+    fontNode->setAttribute(classAttr, styleSpanClassString());
     return fontNode.release();
 }
 
 PassRefPtr<HTMLElement> createStyleSpanElement(Document* document)
 {
     RefPtr<HTMLElement> styleElement = createHTMLElement(document, spanTag);
+    styleElement->setAttribute(classAttr, styleSpanClassString());
     return styleElement.release();
 }
 
 ApplyStyleCommand::ApplyStyleCommand(Document* document, const EditingStyle* style, EditAction editingAction, EPropertyLevel propertyLevel)
     : CompositeEditCommand(document)
     , m_style(style->copy())
     , m_editingAction(editingAction)
     , m_propertyLevel(propertyLevel)
     , m_start(endingSelection().start().downstream())
     , m_end(endingSelection().end().upstream())
@@ skipping 255 matching lines @@
         if (value) {
             inlineStyleDecl->removeProperty(CSSPropertyFontSize, true);
             currentFontSize = computedFontSize(node);
         }
         if (currentFontSize != desiredFontSize) {
             inlineStyleDecl->setProperty(CSSPropertyFontSize, String::number(desiredFontSize) + "px", false, false);
             setNodeAttribute(element.get(), styleAttr, inlineStyleDecl->cssText());
         }
         if (inlineStyleDecl->isEmpty()) {
             removeNodeAttribute(element.get(), styleAttr);
-            if (isSpanWithoutAttributesOrUnstyledStyleSpan(element.get()))
+            // FIXME: should this be isSpanWithoutAttributesOrUnstyleStyleSpan?  Need a test.
+            if (isUnstyledStyleSpan(element.get()))
                 unstyledSpans.append(element.release());
         }
     }
 
     size_t size = unstyledSpans.size();
     for (size_t i = 0; i < size; ++i)
         removeNodePreservingChildren(unstyledSpans[i].get());
 }
 
 static Node* dummySpanAncestorForNode(const Node* node)
 {
-    while (node && (!node->isElementNode() || !isStyleSpanOrSpanWithOnlyStyleAttribute(toElement(node))))
+    while (node && !isStyleSpan(node))
         node = node->parentNode();
     
     return node ? node->parentNode() : 0;
 }
 
 void ApplyStyleCommand::cleanupUnstyledAppleStyleSpans(Node* dummySpanAncestor)
 {
     if (!dummySpanAncestor)
         return;
 
     // Dummy spans are created when text node is split, so that style information
     // can be propagated, which can result in more splitting. If a dummy span gets
     // cloned/split, the new node is always a sibling of it. Therefore, we scan
     // all the children of the dummy's parent
     Node* next;
     for (Node* node = dummySpanAncestor->firstChild(); node; node = next) {
         next = node->nextSibling();
-        if (isSpanWithoutAttributesOrUnstyledStyleSpan(node))
+        if (isUnstyledStyleSpan(node))
             removeNodePreservingChildren(node);
         node = next;
     }
 }
 
 HTMLElement* ApplyStyleCommand::splitAncestorsWithUnicodeBidi(Node* node, bool before, WritingDirection allowedDirection)
 {
     // We are allowed to leave the highest ancestor with unicode-bidi unsplit if it is unicode-bidi: embed and direction: allowedDirection.
     // In that case, we return the unsplit ancestor. Otherwise, we return 0.
     Node* block = enclosingBlock(node);
@@ skipping 66 matching lines @@
         // otherwise it sets the property in the inline style declaration.
         if (element->hasAttribute(dirAttr)) {
             // FIXME: If this is a BDO element, we should probably just remove it if it has no
             // other attributes, like we (should) do with B and I elements.
             removeNodeAttribute(element, dirAttr);
         } else {
             RefPtr<CSSMutableStyleDeclaration> inlineStyle = element->getInlineStyleDecl()->copy();
             inlineStyle->setProperty(CSSPropertyUnicodeBidi, CSSValueNormal);
             inlineStyle->removeProperty(CSSPropertyDirection);
             setNodeAttribute(element, styleAttr, inlineStyle->cssText());
-            if (isSpanWithoutAttributesOrUnstyledStyleSpan(element))
+            // FIXME: should this be isSpanWithoutAttributesOrUnstyleStyleSpan?  Need a test.
+            if (isUnstyledStyleSpan(element))
                 removeNodePreservingChildren(element);
         }
     }
 }
 
 static Node* highestEmbeddingAncestor(Node* startNode, Node* enclosingNode)
 {
     for (Node* n = startNode; n && n != enclosingNode; n = n->parentNode()) {
         if (n->isHTMLElement() && getIdentifierValue(computedStyle(n).get(), CSSPropertyUnicodeBidi) == CSSValueEmbed)
             return n;
@@ skipping 336 matching lines @@
 
     // unicode-bidi and direction are pushed down separately so don't push down with other styles
     Vector<QualifiedName> attributes;
     if (!style->extractConflictingImplicitStyleOfAttributes(element, extractedStyle ? EditingStyle::PreserveWritingDirection : EditingStyle::DoNotPreserveWritingDirection,
         extractedStyle, attributes, mode == RemoveAlways ? EditingStyle::ExtractMatchingStyle : EditingStyle::DoNotExtractMatchingStyle))
         return false;
 
     for (size_t i = 0; i < attributes.size(); i++)
         removeNodeAttribute(element, attributes[i]);
 
-    if (isEmptyFontTag(element) || isSpanWithoutAttributesOrUnstyledStyleSpan(element))
+    if (isEmptyFontTag(element) || isSpanWithoutAttributesOrUnstyleStyleSpan(element))
         removeNodePreservingChildren(element);
 
     return true;
 }
 
 bool ApplyStyleCommand::removeCSSStyle(EditingStyle* style, HTMLElement* element, InlineStyleRemovalMode mode, EditingStyle* extractedStyle)
 {
     ASSERT(style);
     ASSERT(element);
 
     if (mode == RemoveNone)
         return style->conflictsWithInlineStyleOfElement(element);
 
     Vector<CSSPropertyID> properties;
     if (!style->conflictsWithInlineStyleOfElement(element, extractedStyle, properties))
         return false;
 
     CSSMutableStyleDeclaration* inlineStyle = element->inlineStyleDecl();
     ASSERT(inlineStyle);
     // FIXME: We should use a mass-removal function here but we don't have an undoable one yet.
     for (size_t i = 0; i < properties.size(); i++)
         removeCSSProperty(element, properties[i]);
 
     // No need to serialize <foo style=""> if we just removed the last css property
     if (inlineStyle->isEmpty())
         removeNodeAttribute(element, styleAttr);
 
-    if (isSpanWithoutAttributesOrUnstyledStyleSpan(element))
+    if (isSpanWithoutAttributesOrUnstyleStyleSpan(element))
         removeNodePreservingChildren(element);
 
     return true;
 }
 
 HTMLElement* ApplyStyleCommand::highestAncestorWithConflictingInlineStyle(EditingStyle* style, Node* node)
 {
     if (!node)
         return 0;
 
@@ skipping 573 matching lines @@
         }
         else {
             child = child->nextSibling();
         }
     }
 
     updateStartEnd(newStart, newEnd);
 }
 
 }