Reflow comments in //third_party/WebKit/Source/core/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 55 matching lines @@
 
 static const CSSPropertyID& textDecorationPropertyForEditing() {
   static const CSSPropertyID property =
       RuntimeEnabledFeatures::css3TextDecorationsEnabled()
           ? CSSPropertyTextDecorationLine
           : CSSPropertyTextDecoration;
   return property;
 }
 
 // Editing style properties must be preserved during editing operation.
-// e.g. when a user inserts a new paragraph, all properties listed here must be copied to the new paragraph.
+// e.g. when a user inserts a new paragraph, all properties listed here must be
+// copied to the new paragraph.
 // NOTE: Use either allEditingProperties() or inheritableEditingProperties() to
 // respect runtime enabling of properties.
 static const CSSPropertyID staticEditingProperties[] = {
     CSSPropertyBackgroundColor, CSSPropertyColor, CSSPropertyFontFamily,
     CSSPropertyFontSize, CSSPropertyFontStyle, CSSPropertyFontVariantLigatures,
     CSSPropertyFontVariantCaps, CSSPropertyFontWeight, CSSPropertyLetterSpacing,
     CSSPropertyOrphans, CSSPropertyTextAlign,
     // FIXME: CSSPropertyTextDecoration needs to be removed when CSS3 Text
     // Decoration feature is no longer experimental.
     CSSPropertyTextDecoration, CSSPropertyTextDecorationLine,
@@ skipping 104 matching lines @@
   DEFINE_INLINE_VIRTUAL_TRACE() { visitor->trace(m_identifierValue); }
 
  protected:
   HTMLElementEquivalent(CSSPropertyID);
   HTMLElementEquivalent(CSSPropertyID, const HTMLQualifiedName& tagName);
   HTMLElementEquivalent(CSSPropertyID,
                         CSSValueID primitiveValue,
                         const HTMLQualifiedName& tagName);
   const CSSPropertyID m_propertyID;
   const Member<CSSIdentifierValue> m_identifierValue;
-  const HTMLQualifiedName*
-      m_tagName;  // We can store a pointer because HTML tag names are const global.
+  // We can store a pointer because HTML tag names are const global.
+  const HTMLQualifiedName* m_tagName;
 };
 
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id)
     : m_propertyID(id), m_tagName(0) {}
 
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id,
                                              const HTMLQualifiedName& tagName)
     : m_propertyID(id), m_tagName(&tagName) {}
 
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id,
@@ skipping 82 matching lines @@
   virtual const CSSValue* attributeValueAsCSSValue(Element*) const;
   inline const QualifiedName& attributeName() const { return m_attrName; }
 
   DEFINE_INLINE_VIRTUAL_TRACE() { HTMLElementEquivalent::trace(visitor); }
 
  protected:
   HTMLAttributeEquivalent(CSSPropertyID,
                           const HTMLQualifiedName& tagName,
                           const QualifiedName& attrName);
   HTMLAttributeEquivalent(CSSPropertyID, const QualifiedName& attrName);
-  const QualifiedName&
-      m_attrName;  // We can store a reference because HTML attribute names are const global.
+  // We can store a reference because HTML attribute names are const global.
+  const QualifiedName& m_attrName;
 };
 
 HTMLAttributeEquivalent::HTMLAttributeEquivalent(
     CSSPropertyID id,
     const HTMLQualifiedName& tagName,
     const QualifiedName& attrName)
     : HTMLElementEquivalent(id, tagName), m_attrName(attrName) {}
 
 HTMLAttributeEquivalent::HTMLAttributeEquivalent(CSSPropertyID id,
                                                  const QualifiedName& attrName)
@@ skipping 288 matching lines @@
 
 EditingStyle* EditingStyle::copy() const {
   EditingStyle* copy = EditingStyle::create();
   if (m_mutableStyle)
     copy->m_mutableStyle = m_mutableStyle->mutableCopy();
   copy->m_isMonospaceFont = m_isMonospaceFont;
   copy->m_fontSizeDelta = m_fontSizeDelta;
   return copy;
 }
 
-// This is the list of CSS properties that apply specially to block-level elements.
+// This is the list of CSS properties that apply specially to block-level
+// elements.
 static const CSSPropertyID staticBlockProperties[] = {
     CSSPropertyBreakAfter,
     CSSPropertyBreakBefore,
     CSSPropertyBreakInside,
     CSSPropertyOrphans,
     CSSPropertyOverflow,  // This can be also be applied to replaced elements
     CSSPropertyColumnCount,
     CSSPropertyColumnGap,
     CSSPropertyColumnRuleColor,
     CSSPropertyColumnRuleStyle,
@@ skipping 160 matching lines @@
   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() && 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 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()))
             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.
+        // 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 13 matching lines @@
   DCHECK(!conflictingProperties || conflictingProperties->isEmpty());
 
   const StylePropertySet* inlineStyle = element->inlineStyle();
   if (!m_mutableStyle || !inlineStyle)
     return false;
 
   unsigned propertyCount = m_mutableStyle->propertyCount();
   for (unsigned i = 0; i < propertyCount; ++i) {
     CSSPropertyID propertyID = m_mutableStyle->propertyAt(i).id();
 
-    // We don't override whitespace property of a tab span because that would collapse the tab into a space.
+    // We don't override whitespace property of a tab span because that would
+    // collapse the tab into a space.
     if (propertyID == CSSPropertyWhiteSpace && isTabHTMLSpanElement(element))
       continue;
 
     if (propertyID == CSSPropertyWebkitTextDecorationsInEffect &&
         inlineStyle->getPropertyCSSValue(textDecorationPropertyForEditing())) {
       if (!conflictingProperties)
         return true;
       conflictingProperties->append(CSSPropertyTextDecoration);
       // Because text-decoration expands to text-decoration-line when CSS3
       // Text Decoration is enabled, we also state it as conflicting.
@@ skipping 88 matching lines @@
   }
   return false;
 }
 
 static const HeapVector<Member<HTMLAttributeEquivalent>>&
 htmlAttributeEquivalents() {
   DEFINE_STATIC_LOCAL(HeapVector<Member<HTMLAttributeEquivalent>>,
                       HTMLAttributeEquivalents,
                       (new HeapVector<Member<HTMLAttributeEquivalent>>));
   if (!HTMLAttributeEquivalents.size()) {
-    // elementIsStyledSpanOrHTMLEquivalent depends on the fact each HTMLAttriuteEquivalent matches exactly one attribute
-    // of exactly one element except dirAttr.
+    // elementIsStyledSpanOrHTMLEquivalent depends on the fact each
+    // HTMLAttriuteEquivalent matches exactly one attribute of exactly one
+    // element except dirAttr.
     HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(
         CSSPropertyColor, HTMLNames::fontTag, HTMLNames::colorAttr));
     HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(
         CSSPropertyFontFamily, HTMLNames::fontTag, HTMLNames::faceAttr));
     HTMLAttributeEquivalents.append(HTMLFontSizeEquivalent::create());
 
     HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(
         CSSPropertyDirection, HTMLNames::dirAttr));
     HTMLAttributeEquivalents.append(HTMLAttributeEquivalent::create(
         CSSPropertyUnicodeBidi, HTMLNames::dirAttr));
@@ skipping 20 matching lines @@
   return false;
 }
 
 bool EditingStyle::extractConflictingImplicitStyleOfAttributes(
     HTMLElement* element,
     ShouldPreserveWritingDirection shouldPreserveWritingDirection,
     EditingStyle* extractedStyle,
     Vector<QualifiedName>& conflictingAttributes,
     ShouldExtractMatchingStyle shouldExtractMatchingStyle) const {
   DCHECK(element);
-  // HTMLAttributeEquivalent::addToStyle doesn't support unicode-bidi and direction properties
+  // HTMLAttributeEquivalent::addToStyle doesn't support unicode-bidi and
+  // direction properties
   if (extractedStyle)
     DCHECK_EQ(shouldPreserveWritingDirection, PreserveWritingDirection);
   if (!m_mutableStyle)
     return false;
 
   const HeapVector<Member<HTMLAttributeEquivalent>>& HTMLAttributeEquivalents =
       htmlAttributeEquivalents();
   bool removed = false;
   for (const auto& attribute : HTMLAttributeEquivalents) {
     const HTMLAttributeEquivalent* equivalent = attribute.get();
 
-    // unicode-bidi and direction are pushed down separately so don't push down with other styles.
+    // unicode-bidi and direction are pushed down separately so don't push down
+    // with other styles.
     if (shouldPreserveWritingDirection == PreserveWritingDirection &&
         equivalent->attributeName() == HTMLNames::dirAttr)
       continue;
 
     if (!equivalent->matches(element) ||
         !equivalent->propertyExistsInStyle(m_mutableStyle.get()) ||
         (shouldExtractMatchingStyle == DoNotExtractMatchingStyle &&
          equivalent->valueIsPresentInStyle(element, m_mutableStyle.get())))
       continue;
 
@@ skipping 25 matching lines @@
     size_t i;
     for (i = 0; i < HTMLElementEquivalents.size(); ++i) {
       if (HTMLElementEquivalents[i]->matches(element)) {
         elementIsSpanOrElementEquivalent = true;
         break;
       }
     }
   }
 
   AttributeCollection attributes = element->attributes();
-  if (attributes.isEmpty())
-    return elementIsSpanOrElementEquivalent;  // span, b, etc... without any attributes
+  if (attributes.isEmpty()) {
+    // span, b, etc... without any attributes
+    return elementIsSpanOrElementEquivalent;
+  }
 
   unsigned matchedAttributes = 0;
   const HeapVector<Member<HTMLAttributeEquivalent>>& HTMLAttributeEquivalents =
       htmlAttributeEquivalents();
   for (const auto& equivalent : HTMLAttributeEquivalents) {
     if (equivalent->matches(element) &&
         equivalent->attributeName() != HTMLNames::dirAttr)
       matchedAttributes++;
   }
 
-  if (!elementIsSpanOrElementEquivalent && !matchedAttributes)
-    return false;  // element is not a span, a html element equivalent, or font element.
+  if (!elementIsSpanOrElementEquivalent && !matchedAttributes) {
+    // element is not a span, a html element equivalent, or font element.
+    return false;
+  }
 
   if (element->getAttribute(HTMLNames::classAttr) == AppleStyleSpanClass)
     matchedAttributes++;
 
   if (element->hasAttribute(HTMLNames::styleAttr)) {
     if (const StylePropertySet* style = element->inlineStyle()) {
       unsigned propertyCount = style->propertyCount();
       for (unsigned i = 0; i < propertyCount; ++i) {
         if (!isEditingProperty(style->propertyAt(i).id()))
           return false;
       }
     }
     matchedAttributes++;
   }
 
   // font with color attribute, span with style attribute, etc...
   DCHECK_LE(matchedAttributes, attributes.size());
   return matchedAttributes >= attributes.size();
 }
 
 void EditingStyle::prepareToApplyAt(
     const Position& position,
     ShouldPreserveWritingDirection shouldPreserveWritingDirection) {
   if (!m_mutableStyle)
     return;
 
-  // ReplaceSelectionCommand::handleStyleSpans() requires that this function only removes the editing style.
-  // If this function was modified in the future to delete all redundant properties, then add a boolean value to indicate
+  // ReplaceSelectionCommand::handleStyleSpans() requires that this function
+  // only removes the editing style. If this function was modified in the future
+  // to delete all redundant properties, then add a boolean value to indicate
   // which one of editingStyleAtPosition or computedStyle is called.
   EditingStyle* editingStyleAtPosition =
       EditingStyle::create(position, EditingPropertiesInEffect);
   StylePropertySet* styleAtPosition =
       editingStyleAtPosition->m_mutableStyle.get();
 
   const CSSValue* unicodeBidi = nullptr;
   const CSSValue* direction = nullptr;
   if (shouldPreserveWritingDirection == PreserveWritingDirection) {
     unicodeBidi = m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
@@ skipping 131 matching lines @@
       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.
+  // 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.
+  // 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);
     }
   }
 
@@ skipping 36 matching lines @@
     if ((property.id() == textDecorationPropertyForEditing() ||
          property.id() == CSSPropertyWebkitTextDecorationsInEffect) &&
         property.value().isValueList() && value) {
       if (value->isValueList()) {
         const CSSValueList& result = mergeTextDecorationValues(
             *toCSSValueList(value), toCSSValueList(property.value()));
         m_mutableStyle->setProperty(property.id(), result,
                                     property.isImportant());
         continue;
       }
-      value =
-          nullptr;  // text-decoration: none is equivalent to not having the property
+      // text-decoration: none is equivalent to not having the property
+      value = nullptr;
     }
 
     if (mode == OverrideValues || (mode == DoNotOverrideValues && !value))
       m_mutableStyle->setProperty(property.toCSSProperty());
   }
 }
 
 static MutableStylePropertySet* styleFromMatchedRulesForElement(
     Element* element,
     unsigned rulesToInclude) {
   MutableStylePropertySet* style =
       MutableStylePropertySet::create(HTMLQuirksMode);
   StyleRuleList* matchedRules =
       element->document().ensureStyleResolver().styleRulesForElement(
           element, rulesToInclude);
   if (matchedRules) {
     for (unsigned i = 0; i < matchedRules->size(); ++i)
       style->mergeAndOverrideOnConflict(&matchedRules->at(i)->properties());
   }
   return style;
 }
 
 void EditingStyle::mergeStyleFromRules(Element* element) {
   MutableStylePropertySet* styleFromMatchedRules =
       styleFromMatchedRulesForElement(
           element,
           StyleResolver::AuthorCSSRules | StyleResolver::CrossOriginCSSRules);
-  // Styles from the inline style declaration, held in the variable "style", take precedence
-  // over those from matched rules.
+  // Styles from the inline style declaration, held in the variable "style",
+  // take precedence over those from matched rules.
   if (m_mutableStyle)
     styleFromMatchedRules->mergeAndOverrideOnConflict(m_mutableStyle.get());
 
   clear();
   m_mutableStyle = styleFromMatchedRules;
 }
 
 void EditingStyle::mergeStyleFromRulesForSerialization(Element* element) {
   mergeStyleFromRules(element);
 
-  // The property value, if it's a percentage, may not reflect the actual computed value.
+  // The property value, if it's a percentage, may not reflect the actual
+  // computed value.
   // For example: style="height: 1%; overflow: visible;" in quirksmode
-  // FIXME: There are others like this, see <rdar://problem/5195123> Slashdot copy/paste fidelity problem
+  // FIXME: There are others like this, see <rdar://problem/5195123> Slashdot
+  // copy/paste fidelity problem
   CSSComputedStyleDeclaration* computedStyleForElement =
       CSSComputedStyleDeclaration::create(element);
   MutableStylePropertySet* fromComputedStyle =
       MutableStylePropertySet::create(HTMLQuirksMode);
   {
     unsigned propertyCount = m_mutableStyle->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
       StylePropertySet::PropertyReference property =
           m_mutableStyle->propertyAt(i);
       const CSSValue& value = property.value();
@@ skipping 26 matching lines @@
                                                   ContainerNode* context) {
   DCHECK(element);
   if (!m_mutableStyle)
     return;
 
   // TODO(yosin): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited. see http://crbug.com/590369 for more details.
   element->document().updateStyleAndLayoutIgnorePendingStylesheetsForNode(
       element);
 
-  // 1. Remove style from matched rules because style remain without repeating it in inline style declaration
+  // 1. Remove style from matched rules because style remain without repeating
+  // it in inline style declaration
   MutableStylePropertySet* styleFromMatchedRules =
       styleFromMatchedRulesForElement(element,
                                       StyleResolver::AllButEmptyCSSRules);
   if (styleFromMatchedRules && !styleFromMatchedRules->isEmpty())
     m_mutableStyle =
         getPropertiesNotIn(m_mutableStyle.get(),
                            styleFromMatchedRules->ensureCSSStyleDeclaration());
 
   // 2. Remove style present in context and not overriden by matched rules.
   EditingStyle* computedStyle =
       EditingStyle::create(context, EditingPropertiesInEffect);
   if (computedStyle->m_mutableStyle) {
     if (!computedStyle->m_mutableStyle->getPropertyCSSValue(
             CSSPropertyBackgroundColor))
       computedStyle->m_mutableStyle->setProperty(CSSPropertyBackgroundColor,
                                                  CSSValueTransparent);
 
     removePropertiesInStyle(computedStyle->m_mutableStyle.get(),
                             styleFromMatchedRules);
     m_mutableStyle = getPropertiesNotIn(
         m_mutableStyle.get(),
         computedStyle->m_mutableStyle->ensureCSSStyleDeclaration());
   }
 
-  // 3. If this element is a span and has display: inline or float: none, remove them unless they are overriden by rules.
-  // These rules are added by serialization code to wrap text nodes.
+  // 3. If this element is a span and has display: inline or float: none, remove
+  // them unless they are overriden by rules. These rules are added by
+  // serialization code to wrap text nodes.
   if (isStyleSpanOrSpanWithOnlyStyleAttribute(element)) {
     if (!styleFromMatchedRules->getPropertyCSSValue(CSSPropertyDisplay) &&
         getIdentifierValue(m_mutableStyle.get(), CSSPropertyDisplay) ==
             CSSValueInline)
       m_mutableStyle->removeProperty(CSSPropertyDisplay);
     if (!styleFromMatchedRules->getPropertyCSSValue(CSSPropertyFloat) &&
         getIdentifierValue(m_mutableStyle.get(), CSSPropertyFloat) ==
             CSSValueNone)
       m_mutableStyle->removeProperty(CSSPropertyFloat);
   }
@@ skipping 70 matching lines @@
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited. see http://crbug.com/590369 for more details.
   document.updateStyleAndLayoutIgnorePendingStylesheets();
 
   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.
+  // 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.
+  // 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.
+    // 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 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());
   }
@@ skipping 52 matching lines @@
   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.
+  // 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);
@@ skipping 18 matching lines @@
     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.
+    // 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());
-  // We shouldn't have both text-decoration and -webkit-text-decorations-in-effect because that wouldn't make sense.
+  // We shouldn't have both text-decoration and
+  // -webkit-text-decorations-in-effect because that wouldn't make sense.
   DCHECK(!textDecorationsInEffect || !textDecoration);
   if (textDecorationsInEffect) {
     style->setProperty(textDecorationPropertyForEditing(),
                        textDecorationsInEffect->cssText());
     style->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);
     textDecoration = textDecorationsInEffect;
   }
 
-  // If text-decoration is set to "none", remove the property because we don't want to add redundant "text-decoration: none".
+  // If text-decoration is set to "none", remove the property because we don't
+  // want to add redundant "text-decoration: none".
   if (textDecoration && !textDecoration->isValueList())
     style->removeProperty(textDecorationPropertyForEditing());
 }
 
 StyleChange::StyleChange(EditingStyle* style, const Position& position)
     : m_applyBold(false),
       m_applyItalic(false),
       m_applyUnderline(false),
       m_applyLineThrough(false),
       m_applySubscript(false),
       m_applySuperscript(false) {
   Document* document = position.document();
   if (!style || !style->style() || !document || !document->frame() ||
       !associatedElementOf(position))
     return;
 
   CSSComputedStyleDeclaration* computedStyle = ensureComputedStyle(position);
   // FIXME: take care of background-color in effect
   MutableStylePropertySet* mutableStyle =
       getPropertiesNotIn(style->style(), computedStyle);
   DCHECK(mutableStyle);
 
   reconcileTextDecorationProperties(mutableStyle);
   if (!document->frame()->editor().shouldStyleWithCSS())
     extractTextStyles(document, mutableStyle, computedStyle->isMonospaceFont());
 
-  // Changing the whitespace style in a tab span would collapse the tab into a space.
+  // Changing the whitespace style in a tab span would collapse the tab into a
+  // space.
   if (isTabHTMLSpanElementTextNode(position.anchorNode()) ||
       isTabHTMLSpanElement((position.anchorNode())))
     mutableStyle->removeProperty(CSSPropertyWhiteSpace);
 
-  // If unicode-bidi is present in mutableStyle and direction is not, then add direction to mutableStyle.
+  // If unicode-bidi is present in mutableStyle and direction is not, then add
+  // direction to mutableStyle.
   // FIXME: Shouldn't this be done in getPropertiesNotIn?
   if (mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi) &&
       !style->style()->getPropertyCSSValue(CSSPropertyDirection))
     mutableStyle->setProperty(
         CSSPropertyDirection,
         style->style()->getPropertyValue(CSSPropertyDirection));
 
   // Save the result for later
   m_cssStyle = mutableStyle->asText().stripWhiteSpace();
 }
@@ skipping 20 matching lines @@
     style->removeProperty(CSSPropertyFontWeight);
     m_applyBold = true;
   }
 
   int fontStyle = getIdentifierValue(style, CSSPropertyFontStyle);
   if (fontStyle == CSSValueItalic || fontStyle == CSSValueOblique) {
     style->removeProperty(CSSPropertyFontStyle);
     m_applyItalic = true;
   }
 
-  // Assuming reconcileTextDecorationProperties has been called, there should not be -webkit-text-decorations-in-effect
-  // Furthermore, text-decoration: none has been trimmed so that text-decoration property is always a CSSValueList.
+  // Assuming reconcileTextDecorationProperties has been called, there should
+  // not be -webkit-text-decorations-in-effect
+  // Furthermore, text-decoration: none has been trimmed so that text-decoration
+  // property is always a CSSValueList.
   const CSSValue* textDecoration =
       style->getPropertyCSSValue(textDecorationPropertyForEditing());
   if (textDecoration && textDecoration->isValueList()) {
     DEFINE_STATIC_LOCAL(CSSIdentifierValue, underline,
                         (CSSIdentifierValue::create(CSSValueUnderline)));
     DEFINE_STATIC_LOCAL(CSSIdentifierValue, lineThrough,
                         (CSSIdentifierValue::create(CSSValueLineThrough)));
     CSSValueList* newTextDecoration = toCSSValueList(textDecoration)->copy();
     if (newTextDecoration->removeAll(underline))
       m_applyUnderline = true;
@@ skipping 16 matching lines @@
       m_applySuperscript = true;
       break;
   }
 
   if (style->getPropertyCSSValue(CSSPropertyColor)) {
     m_applyFontColor = getFontColor(style).serialized();
     style->removeProperty(CSSPropertyColor);
   }
 
   m_applyFontFace = style->getPropertyValue(CSSPropertyFontFamily);
-  // Remove double quotes for Outlook 2007 compatibility. See https://bugs.webkit.org/show_bug.cgi?id=79448
+  // Remove double quotes for Outlook 2007 compatibility. See
+  // https://bugs.webkit.org/show_bug.cgi?id=79448
   m_applyFontFace.replace('"', "");
   style->removeProperty(CSSPropertyFontFamily);
 
   if (const CSSValue* fontSize =
           style->getPropertyCSSValue(CSSPropertyFontSize)) {
     if (!fontSize->isPrimitiveValue() && !fontSize->isIdentifierValue()) {
-      style->removeProperty(
-          CSSPropertyFontSize);  // Can't make sense of the number. Put no font size.
+      // Can't make sense of the number. Put no font size.
+      style->removeProperty(CSSPropertyFontSize);
     } else if (int legacyFontSize = legacyFontSizeFromCSSValue(
                    document, fontSize, isMonospaceFont,
                    UseLegacyFontSizeOnlyIfPixelValuesMatch)) {
       m_applyFontSize = String::number(legacyFontSize);
       style->removeProperty(CSSPropertyFontSize);
     }
   }
 }
 
 static void diffTextDecorations(MutableStylePropertySet* style,
@@ skipping 11 matching lines @@
   for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)
     newTextDecoration->removeAll(valuesInRefTextDecoration->item(i));
 
   setTextDecorationProperty(style, newTextDecoration, propertyID);
 }
 
 static bool fontWeightIsBold(const CSSValue* fontWeight) {
   if (!fontWeight->isIdentifierValue())
     return false;
 
-  // Because b tag can only bold text, there are only two states in plain html: bold and not bold.
-  // Collapse all other values to either one of these two states for editing purposes.
+  // Because b tag can only bold text, there are only two states in plain html:
+  // bold and not bold. Collapse all other values to either one of these two
+  // states for editing purposes.
   switch (toCSSIdentifierValue(fontWeight)->getValueID()) {
     case CSSValue100:
     case CSSValue200:
     case CSSValue300:
     case CSSValue400:
     case CSSValue500:
     case CSSValueNormal:
       return false;
     case CSSValueBold:
     case CSSValue600:
@@ skipping 91 matching lines @@
     if (CSSPrimitiveValue::unitTypeToLengthUnitType(
             primitiveValue.typeWithCalcResolved(), lengthType) &&
         lengthType == CSSPrimitiveValue::UnitTypePixels) {
       double conversion =
           CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(
               primitiveValue.typeWithCalcResolved());
       int pixelFontSize =
           clampTo<int>(primitiveValue.getDoubleValue() * conversion);
       int legacyFontSize =
           FontSize::legacyFontSize(document, pixelFontSize, isMonospaceFont);
-      // Use legacy font size only if pixel value matches exactly to that of legacy font size.
+      // Use legacy font size only if pixel value matches exactly to that of
+      // legacy font size.
       if (mode == AlwaysUseLegacyFontSize ||
           FontSize::fontSizeForKeyword(document, legacyFontSize,
                                        isMonospaceFont) == pixelFontSize)
         return legacyFontSize;
 
       return 0;
     }
   }
 
   if (value->isIdentifierValue()) {
@@ skipping 32 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