Rename the methods in EditingStyleUtilities class and make them used in editing

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 365 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 197 matching lines @@
       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 895 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