Introduce EditingStyleUtilities.{cpp,h}

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 30 matching lines @@
 #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/EditingStyleUtilities.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"
 #include "core/html/HTMLSpanElement.h"
 #include "core/layout/LayoutBox.h"
@@ skipping 97 matching lines @@
     StylePropertySet* styleWithRedundantProperties,
     CSSStyleDeclaration* baseStyle);
 enum LegacyFontSizeMode {
   AlwaysUseLegacyFontSize,
   UseLegacyFontSizeOnlyIfPixelValuesMatch
 };
 static int legacyFontSizeFromCSSValue(Document*,
                                       const CSSValue*,
                                       bool,
                                       LegacyFontSizeMode);
-static bool isTransparentColorValue(const CSSValue*);
-static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
-static bool hasTransparentBackgroundColor(StylePropertySet*);
-static const 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 {
@@ skipping 243 matching lines @@
   return cssValueToColor(
       style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor));
 }
 
 static inline Color getBackgroundColor(StylePropertySet* style) {
   return cssValueToColor(
       style->getPropertyCSSValue(CSSPropertyBackgroundColor));
 }
 
 static inline Color backgroundColorInEffect(Node* node) {
-  return cssValueToColor(backgroundColorValueInEffect(node));
+  return cssValueToColor(
+      EditingStyleUtilities::backgroundColorValueInEffect(node));
 }
 
 static int textAlignResolvingStartAndEnd(int textAlign, int direction) {
   switch (textAlign) {
     case CSSValueCenter:
     case CSSValueWebkitCenter:
       return CSSValueCenter;
     case CSSValueJustify:
       return CSSValueJustify;
     case CSSValueLeft:
@@ skipping 24 matching lines @@
     node = node->parentNode();
 
   CSSComputedStyleDeclaration* computedStyleAtPosition =
       CSSComputedStyleDeclaration::create(node);
   m_mutableStyle =
       propertiesToInclude == AllProperties && computedStyleAtPosition
           ? computedStyleAtPosition->copyProperties()
           : editingStyleFromComputedStyle(computedStyleAtPosition);
 
   if (propertiesToInclude == EditingPropertiesInEffect) {
-    if (const CSSValue* value = backgroundColorValueInEffect(node))
+    if (const CSSValue* value =
+            EditingStyleUtilities::backgroundColorValueInEffect(node))
       m_mutableStyle->setProperty(CSSPropertyBackgroundColor, value->cssText());
     if (const CSSValue* value = computedStyleAtPosition->getPropertyCSSValue(
             CSSPropertyWebkitTextDecorationsInEffect))
       m_mutableStyle->setProperty(CSSPropertyTextDecoration, value->cssText());
   }
 
   if (node && node->ensureComputedStyle()) {
     const ComputedStyle* computedStyle = node->ensureComputedStyle();
     removeInheritedColorsIfNeeded(computedStyle);
     replaceFontSizeByKeywordIfPossible(computedStyle, computedStyleAtPosition);
@@ skipping 72 matching lines @@
 bool EditingStyle::textDirection(WritingDirection& writingDirection) const {
   if (!m_mutableStyle)
     return false;
 
   const CSSValue* unicodeBidi =
       m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
   if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
     return false;
 
   CSSValueID unicodeBidiValue = toCSSIdentifierValue(unicodeBidi)->getValueID();
-  if (isEmbedOrIsolate(unicodeBidiValue)) {
+  if (EditingStyleUtilities::isEmbedOrIsolate(unicodeBidiValue)) {
     const CSSValue* direction =
         m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
     if (!direction || !direction->isIdentifierValue())
       return false;
 
     writingDirection =
         toCSSIdentifierValue(direction)->getValueID() == CSSValueLtr
             ? LeftToRightWritingDirection
             : RightToLeftWritingDirection;
 
@@ skipping 182 matching lines @@
                                       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));
+  if (selection.isCaret()) {
+    return triStateOfStyle(
+        EditingStyleUtilities::createStyleAtSelectionStart(selection));
+  }
 
   TriState state = FalseTriState;
   bool nodeIsStart = true;
   for (Node& node : NodeTraversal::startsAt(*selection.start().anchorNode())) {
     if (node.layoutObject() && hasEditableStyle(node)) {
       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) {
           const CSSIdentifierValue* verticalAlign = toCSSIdentifierValue(
               m_mutableStyle->getPropertyCSSValue(CSSPropertyVerticalAlign));
-          if (hasAncestorVerticalAlignStyle(node, verticalAlign->getValueID()))
+          if (EditingStyleUtilities::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) {
@@ skipping 302 matching lines @@
 
   m_mutableStyle->removeEquivalentProperties(styleAtPosition);
 
   if (textAlignResolvingStartAndEnd(m_mutableStyle.get()) ==
       textAlignResolvingStartAndEnd(styleAtPosition))
     m_mutableStyle->removeProperty(CSSPropertyTextAlign);
 
   if (getFontColor(m_mutableStyle.get()) == getFontColor(styleAtPosition))
     m_mutableStyle->removeProperty(CSSPropertyColor);
 
-  if (hasTransparentBackgroundColor(m_mutableStyle.get()) ||
+  if (EditingStyleUtilities::hasTransparentBackgroundColor(
+          m_mutableStyle.get()) ||
       cssValueToColor(
           m_mutableStyle->getPropertyCSSValue(CSSPropertyBackgroundColor)) ==
           backgroundColorInEffect(position.computeContainerNode()))
     m_mutableStyle->removeProperty(CSSPropertyBackgroundColor);
 
   if (unicodeBidi && unicodeBidi->isIdentifierValue()) {
     m_mutableStyle->setProperty(
         CSSPropertyUnicodeBidi,
         toCSSIdentifierValue(unicodeBidi)->getValueID());
     if (direction && direction->isIdentifierValue()) {
@@ skipping 95 matching lines @@
       htmlAttributeEquivalents();
   for (const auto& attribute : attributeEquivalents) {
     if (attribute->attributeName() == HTMLNames::dirAttr)
       continue;  // We don't want to include directionality
     if (elementMatchesAndPropertyIsNotInInlineStyleDecl(
             attribute.get(), element, mode, m_mutableStyle.get()))
       attribute->addToStyle(element, this);
   }
 }
 
-EditingStyle* EditingStyle::wrappingStyleForAnnotatedSerialization(
-    ContainerNode* context) {
-  EditingStyle* wrappingStyle =
-      EditingStyle::create(context, EditingStyle::EditingPropertiesInEffect);
-
-  // Styles that Mail blockquotes contribute should only be placed on the Mail
-  // blockquote, to help us differentiate those styles from ones that the user
-  // has applied. This helps us get the color of content pasted into
-  // blockquotes right.
-  wrappingStyle->removeStyleAddedByElement(toHTMLElement(enclosingNodeOfType(
-      firstPositionInOrBeforeNode(context), isMailHTMLBlockquoteElement,
-      CanCrossEditingBoundary)));
-
-  // Call collapseTextDecorationProperties first or otherwise it'll copy the
-  // value over from in-effect to text-decorations.
-  wrappingStyle->collapseTextDecorationProperties();
-
-  return wrappingStyle;
-}
-
-EditingStyle* EditingStyle::wrappingStyleForSerialization(
-    ContainerNode* context) {
-  DCHECK(context);
-  EditingStyle* wrappingStyle = EditingStyle::create();
-
-  // When not annotating for interchange, we only preserve inline style
-  // declarations.
-  for (Node& node : NodeTraversal::inclusiveAncestorsOf(*context)) {
-    if (node.isDocumentNode())
-      break;
-    if (node.isStyledElement() && !isMailHTMLBlockquoteElement(&node)) {
-      wrappingStyle->mergeInlineAndImplicitStyleOfElement(
-          toElement(&node), EditingStyle::DoNotOverrideValues,
-          EditingStyle::EditingPropertiesInEffect);
-    }
-  }
-
-  return wrappingStyle;
-}
 
 static const CSSValueList& mergeTextDecorationValues(
     const CSSValueList& mergedValue,
     const CSSValueList& valueToMerge) {
   DEFINE_STATIC_LOCAL(CSSIdentifierValue, underline,
                       (CSSIdentifierValue::create(CSSValueUnderline)));
   DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough,
                       (CSSIdentifierValue::create(CSSValueLineThrough)));
   CSSValueList& result = *mergedValue.copy();
   if (valueToMerge.hasValue(underline) && !mergedValue.hasValue(underline))
@@ skipping 217 matching lines @@
 int EditingStyle::legacyFontSize(Document* document) const {
   const CSSValue* cssValue =
       m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize);
   if (!cssValue ||
       !(cssValue->isPrimitiveValue() || cssValue->isIdentifierValue()))
     return 0;
   return legacyFontSizeFromCSSValue(document, cssValue, m_isMonospaceFont,
                                     AlwaysUseLegacyFontSize);
 }
 
-EditingStyle* EditingStyle::styleAtSelectionStart(
-    const VisibleSelection& selection,
-    bool shouldUseBackgroundColorInEffect,
-    MutableStylePropertySet* styleToCheck) {
-  if (selection.isNone())
-    return nullptr;
-
-  Document& document = *selection.start().document();
-
-  DCHECK(!document.needsLayoutTreeUpdate());
-  DocumentLifecycle::DisallowTransitionScope disallowTransition(
-      document.lifecycle());
-
-  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 (const CSSValue* value =
-            backgroundColorValueInEffect(Range::commonAncestorContainer(
-                range.startPosition().computeContainerNode(),
-                range.endPosition().computeContainerNode())))
-      style->setProperty(CSSPropertyBackgroundColor, value->cssText());
-  }
-
-  return style;
-}
-
-static bool isUnicodeBidiNestedOrMultipleEmbeddings(CSSValueID valueID) {
-  return valueID == CSSValueEmbed || valueID == CSSValueBidiOverride ||
-         valueID == CSSValueWebkitIsolate ||
-         valueID == CSSValueWebkitIsolateOverride ||
-         valueID == CSSValueWebkitPlaintext || valueID == CSSValueIsolate ||
-         valueID == CSSValueIsolateOverride || valueID == CSSValuePlaintext;
-}
-
-WritingDirection EditingStyle::textDirectionForSelection(
-    const VisibleSelection& selection,
-    EditingStyle* typingStyle,
-    bool& hasNestedOrMultipleEmbeddings) {
-  hasNestedOrMultipleEmbeddings = true;
-
-  if (selection.isNone())
-    return NaturalWritingDirection;
-
-  Position position = mostForwardCaretPosition(selection.start());
-
-  Node* node = position.anchorNode();
-  if (!node)
-    return NaturalWritingDirection;
-
-  Position end;
-  if (selection.isRange()) {
-    end = mostBackwardCaretPosition(selection.end());
-
-    DCHECK(end.document());
-    const EphemeralRange caretRange(position.parentAnchoredEquivalent(),
-                                    end.parentAnchoredEquivalent());
-    for (Node& n : caretRange.nodes()) {
-      if (!n.isStyledElement())
-        continue;
-
-      CSSComputedStyleDeclaration* style =
-          CSSComputedStyleDeclaration::create(&n);
-      const CSSValue* unicodeBidi =
-          style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
-      if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
-        continue;
-
-      CSSValueID unicodeBidiValue =
-          toCSSIdentifierValue(unicodeBidi)->getValueID();
-      if (isUnicodeBidiNestedOrMultipleEmbeddings(unicodeBidiValue))
-        return NaturalWritingDirection;
-    }
-  }
-
-  if (selection.isCaret()) {
-    WritingDirection direction;
-    if (typingStyle && typingStyle->textDirection(direction)) {
-      hasNestedOrMultipleEmbeddings = false;
-      return direction;
-    }
-    node = selection.visibleStart().deepEquivalent().anchorNode();
-  }
-  DCHECK(node);
-
-  // The selection is either a caret with no typing attributes or a range in
-  // which no embedding is added, so just use the start position to decide.
-  Node* block = enclosingBlock(node);
-  WritingDirection foundDirection = NaturalWritingDirection;
-
-  for (Node& runner : NodeTraversal::inclusiveAncestorsOf(*node)) {
-    if (runner == block)
-      break;
-    if (!runner.isStyledElement())
-      continue;
-
-    Element* element = &toElement(runner);
-    CSSComputedStyleDeclaration* style =
-        CSSComputedStyleDeclaration::create(element);
-    const CSSValue* unicodeBidi =
-        style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
-    if (!unicodeBidi || !unicodeBidi->isIdentifierValue())
-      continue;
-
-    CSSValueID unicodeBidiValue =
-        toCSSIdentifierValue(unicodeBidi)->getValueID();
-    if (unicodeBidiValue == CSSValueNormal)
-      continue;
-
-    if (unicodeBidiValue == CSSValueBidiOverride)
-      return NaturalWritingDirection;
-
-    DCHECK(isEmbedOrIsolate(unicodeBidiValue)) << unicodeBidiValue;
-    const CSSValue* direction =
-        style->getPropertyCSSValue(CSSPropertyDirection);
-    if (!direction || !direction->isIdentifierValue())
-      continue;
-
-    int directionValue = toCSSIdentifierValue(direction)->getValueID();
-    if (directionValue != CSSValueLtr && directionValue != CSSValueRtl)
-      continue;
-
-    if (foundDirection != NaturalWritingDirection)
-      return NaturalWritingDirection;
-
-    // In the range case, make sure that the embedding element persists until
-    // the end of the range.
-    if (selection.isRange() && !end.anchorNode()->isDescendantOf(element))
-      return NaturalWritingDirection;
-
-    foundDirection = directionValue == CSSValueLtr
-                         ? LeftToRightWritingDirection
-                         : RightToLeftWritingDirection;
-  }
-  hasNestedOrMultipleEmbeddings = false;
-  return foundDirection;
-}
-
 DEFINE_TRACE(EditingStyle) {
   visitor->trace(m_mutableStyle);
 }
 
 static void reconcileTextDecorationProperties(MutableStylePropertySet* style) {
   const CSSValue* textDecorationsInEffect =
       style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
   const CSSValue* textDecoration =
       style->getPropertyCSSValue(textDecorationPropertyForEditing());
   // "LayoutTests/editing/execCommand/insert-list-and-strikethrough.html" makes
@@ skipping 290 matching lines @@
   if (value->isIdentifierValue()) {
     const CSSIdentifierValue& identifierValue = toCSSIdentifierValue(*value);
     if (CSSValueXSmall <= identifierValue.getValueID() &&
         identifierValue.getValueID() <= CSSValueWebkitXxxLarge)
       return identifierValue.getValueID() - CSSValueXSmall + 1;
   }
 
   return 0;
 }
 
-bool isTransparentColorValue(const CSSValue* cssValue) {
-  if (!cssValue)
-    return true;
-  if (cssValue->isColorValue())
-    return !toCSSColorValue(cssValue)->value().alpha();
-  if (!cssValue->isIdentifierValue())
-    return false;
-  return toCSSIdentifierValue(cssValue)->getValueID() == CSSValueTransparent;
-}
-
-bool hasTransparentBackgroundColor(CSSStyleDeclaration* style) {
-  const CSSValue* cssValue =
-      style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor);
-  return isTransparentColorValue(cssValue);
-}
-
-bool hasTransparentBackgroundColor(StylePropertySet* style) {
-  const CSSValue* cssValue =
-      style->getPropertyCSSValue(CSSPropertyBackgroundColor);
-  return isTransparentColorValue(cssValue);
-}
-
-const CSSValue* backgroundColorValueInEffect(Node* node) {
-  for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
-    CSSComputedStyleDeclaration* ancestorStyle =
-        CSSComputedStyleDeclaration::create(ancestor);
-    if (!hasTransparentBackgroundColor(ancestorStyle))
-      return ancestorStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
-  }
-  return nullptr;
-}
-
 }  // namespace blink