Apply vertical-align style of <sub> and <sup> to child elements.

third_party/WebKit/Source/core/editing/EditingStyle.cpp

 /*
  * Copyright (C) 2007, 2008, 2009 Apple Computer, Inc.
  * Copyright (C) 2010, 2011 Google 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
@@ skipping 12 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/editing/EditingStyle.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/css/CSSColorValue.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
+#include "core/css/CSSPrimitiveValueMappings.h"
 #include "core/css/CSSPropertyMetadata.h"
 #include "core/css/CSSRuleList.h"
 #include "core/css/CSSStyleRule.h"
 #include "core/css/CSSValueList.h"
 #include "core/css/CSSValuePool.h"
 #include "core/css/FontSize.h"
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/parser/CSSParser.h"
 #include "core/css/resolver/StyleResolver.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/Node.h"
+#include "core/dom/NodeComputedStyle.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/QualifiedName.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/FrameSelection.h"
 #include "core/editing/Position.h"
 #include "core/editing/commands/ApplyStyleCommand.h"
 #include "core/editing/serializers/HTMLInterchange.h"
 #include "core/frame/LocalFrame.h"
 #include "core/html/HTMLFontElement.h"
@@ skipping 100 matching lines @@
     return CSSComputedStyleDeclaration::create(elem);
 }
 
 static MutableStylePropertySet* getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle);
 enum LegacyFontSizeMode { AlwaysUseLegacyFontSize, UseLegacyFontSizeOnlyIfPixelValuesMatch };
 static int legacyFontSizeFromCSSValue(Document*, CSSPrimitiveValue*, bool, LegacyFontSizeMode);
 static bool isTransparentColorValue(CSSValue*);
 static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
 static bool hasTransparentBackgroundColor(StylePropertySet*);
 static CSSValue* backgroundColorValueInEffect(Node*);
+static bool hasAncestorVerticalAlignStyle(Node&, CSSValueID);
 
 class HTMLElementEquivalent : public GarbageCollected<HTMLElementEquivalent> {
 public:
     static HTMLElementEquivalent* create(CSSPropertyID propertyID, CSSValueID primitiveValue, const HTMLQualifiedName& tagName)
     {
         return new HTMLElementEquivalent(propertyID, primitiveValue, tagName);
     }
 
     virtual bool matches(const Element* element) const { return !m_tagName || element->hasTagName(*m_tagName); }
     virtual bool hasAttribute() const { return false; }
@@ skipping 203 matching lines @@
 {
     extractFontSizeDelta();
 }
 
 EditingStyle::EditingStyle(CSSPropertyID propertyID, const String& value)
     : m_mutableStyle(nullptr)
     , m_isMonospaceFont(false)
     , m_fontSizeDelta(NoFontDelta)
 {
     setProperty(propertyID, value);
+    m_isVerticalAlign = propertyID == CSSPropertyVerticalAlign && (value == "sub" || value == "super");
 }
 
 static Color cssValueToColor(CSSValue* colorValue)
 {
     if (!colorValue || (!colorValue->isColorValue() && !colorValue->isPrimitiveValue()))
         return Color::transparent;
 
     if (colorValue->isColorValue())
         return toCSSColorValue(colorValue)->value();
 
@@ skipping 331 matching lines @@
         difference->removePropertiesInSet(textOnlyProperties, WTF_ARRAY_LENGTH(textOnlyProperties));
 
     if (difference->isEmpty())
         return TrueTriState;
     if (difference->propertyCount() == m_mutableStyle->propertyCount())
         return FalseTriState;
 
     return MixedTriState;
 }
 
+static bool hasAncestorVerticalAlignStyle(Node& node, CSSValueID value)
+{
+    for (Node& runner : NodeTraversal::inclusiveAncestorsOf(node)) {
+        CSSComputedStyleDeclaration* ancestorStyle = CSSComputedStyleDeclaration::create(&runner);
+        if (getIdentifierValue(ancestorStyle, CSSPropertyVerticalAlign) == value)
+            return true;
+    }
+    return false;
+}
+
 TriState EditingStyle::triStateOfStyle(const VisibleSelection& selection) const
 {
     if (selection.isNone())
         return FalseTriState;
 
     if (selection.isCaret())
         return triStateOfStyle(EditingStyle::styleAtSelectionStart(selection));
 
     TriState state = FalseTriState;
     bool nodeIsStart = true;
     for (Node& node : NodeTraversal::startsAt(*selection.start().anchorNode())) {
         if (node.layoutObject() && node.hasEditableStyle()) {
             CSSComputedStyleDeclaration* nodeStyle = CSSComputedStyleDeclaration::create(&node);
             if (nodeStyle) {
+                // If the selected element has <sub> or <sup> ancestor element, apply the corresponding
+                // style(vertical-align) to it so that document.queryCommandState() works with the style.
+                // See bug http://crbug.com/582225.
+                if (m_isVerticalAlign && getIdentifierValue(nodeStyle, CSSPropertyVerticalAlign) == CSSValueBaseline) {
+                    CSSPrimitiveValue* verticalAlign = toCSSPrimitiveValue(m_mutableStyle->getPropertyCSSValue(CSSPropertyVerticalAlign));
+                    if (hasAncestorVerticalAlignStyle(node, verticalAlign->getValueID()))
+                        node.mutableComputedStyle()->setVerticalAlign(verticalAlign->convertTo<EVerticalAlign>());
+                }
+
                 // Pass EditingStyle::DoNotIgnoreTextOnlyProperties without checking if node.isTextNode()
                 // because the node can be an element node. See bug http://crbug.com/584939.
                 TriState nodeState = triStateOfStyle(nodeStyle, EditingStyle::DoNotIgnoreTextOnlyProperties);
                 if (nodeIsStart) {
                     state = nodeState;
                     nodeIsStart = false;
                 } else if (state != nodeState && node.isTextNode()) {
                     state = MixedTriState;
                     break;
                 }
@@ skipping 543 matching lines @@
 
 int EditingStyle::legacyFontSize(Document* document) const
 {
     CSSValue* cssValue = m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize);
     if (!cssValue || !cssValue->isPrimitiveValue())
         return 0;
     return legacyFontSizeFromCSSValue(document, toCSSPrimitiveValue(cssValue),
         m_isMonospaceFont, AlwaysUseLegacyFontSize);
 }
 
-EditingStyle* EditingStyle::styleAtSelectionStart(const VisibleSelection& selection, bool shouldUseBackgroundColorInEffect)
+EditingStyle* EditingStyle::styleAtSelectionStart(const VisibleSelection& selection, bool shouldUseBackgroundColorInEffect, MutableStylePropertySet* styleToCheck)
 {
     if (selection.isNone())
         return nullptr;
 
     Position position = adjustedSelectionStartForStyleComputation(selection);
 
     // If the pos is at the end of a text node, then this node is not fully selected.
     // Move it to the next deep equivalent position to avoid removing the style from this node.
     // e.g. if pos was at Position("hello", 5) in <b>hello<div>world</div></b>, we want Position("world", 0) instead.
     // We only do this for range because caret at Position("hello", 5) in <b>hello</b>world should give you font-weight: bold.
     Node* positionNode = position.computeContainerNode();
     if (selection.isRange() && positionNode && positionNode->isTextNode() && position.computeOffsetInContainerNode() == positionNode->maxCharacterOffset())
         position = nextVisuallyDistinctCandidate(position);
 
     Element* element = associatedElementOf(position);
     if (!element)
         return nullptr;
 
     EditingStyle* style = EditingStyle::create(element, EditingStyle::AllProperties);
     style->mergeTypingStyle(&element->document());
 
+    // If |element| has <sub> or <sup> ancestor element, apply the corresponding
+    // style(vertical-align) to it so that document.queryCommandState() works with the style.
+    // See bug http://crbug.com/582225.
+    CSSValueID valueID = getIdentifierValue(styleToCheck, CSSPropertyVerticalAlign);
+    if (valueID == CSSValueSub || valueID == CSSValueSuper) {
+        CSSComputedStyleDeclaration* elementStyle = CSSComputedStyleDeclaration::create(element);
+        // Find the ancestor that has CSSValueSub or CSSValueSuper as the value of CSS vertical-align property.
+        if (getIdentifierValue(elementStyle, CSSPropertyVerticalAlign) == CSSValueBaseline && hasAncestorVerticalAlignStyle(*element, valueID))
+            style->m_mutableStyle->setProperty(CSSPropertyVerticalAlign, valueID);
+    }
+
     // If background color is transparent, traverse parent nodes until we hit a different value or document root
     // Also, if the selection is a range, ignore the background color at the start of selection,
     // and find the background color of the common ancestor.
     if (shouldUseBackgroundColorInEffect && (selection.isRange() || hasTransparentBackgroundColor(style->m_mutableStyle.get()))) {
         const EphemeralRange range(selection.toNormalizedEphemeralRange());
         if (CSSValue* value = backgroundColorValueInEffect(Range::commonAncestorContainer(range.startPosition().computeContainerNode(), range.endPosition().computeContainerNode())))
             style->setProperty(CSSPropertyBackgroundColor, value->cssText());
     }
 
     return style;
@@ skipping 381 matching lines @@
 {
     for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
         CSSComputedStyleDeclaration* ancestorStyle = CSSComputedStyleDeclaration::create(ancestor);
         if (!hasTransparentBackgroundColor(ancestorStyle))
             return ancestorStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
     }
     return nullptr;
 }
 
 } // namespace blink