Make CSSComputedStyledeclaration::getPropertyCSSValue return const

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 142 matching lines @@
 static CSSComputedStyleDeclaration* ensureComputedStyle(const Position& position)
 {
     Element* elem = associatedElementOf(position);
     if (!elem)
         return nullptr;
     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 int legacyFontSizeFromCSSValue(Document*, const CSSPrimitiveValue*, bool, LegacyFontSizeMode);
+static bool isTransparentColorValue(const CSSValue*);
 static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
 static bool hasTransparentBackgroundColor(StylePropertySet*);
-static CSSValue* backgroundColorValueInEffect(Node*);
+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 { return !m_tagName || element->hasTagName(*m_tagName); }
@@ skipping 28 matching lines @@
 HTMLElementEquivalent::HTMLElementEquivalent(CSSPropertyID id, CSSValueID primitiveValue, const HTMLQualifiedName& tagName)
     : m_propertyID(id)
     , m_primitiveValue(CSSPrimitiveValue::createIdentifier(primitiveValue))
     , m_tagName(&tagName)
 {
     DCHECK_NE(primitiveValue, CSSValueInvalid);
 }
 
 bool HTMLElementEquivalent::valueIsPresentInStyle(HTMLElement* element, StylePropertySet* style) const
 {
-    CSSValue* value = style->getPropertyCSSValue(m_propertyID);
+    const CSSValue* value = style->getPropertyCSSValue(m_propertyID);
     return matches(element) && value && value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == m_primitiveValue->getValueID();
 }
 
 void HTMLElementEquivalent::addToStyle(Element*, EditingStyle* style) const
 {
     style->setProperty(m_propertyID, m_primitiveValue->cssText());
 }
 
 class HTMLTextDecorationEquivalent final : public HTMLElementEquivalent {
 public:
@@ skipping 17 matching lines @@
 }
 
 bool HTMLTextDecorationEquivalent::propertyExistsInStyle(const StylePropertySet* style) const
 {
     return style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect)
         || style->getPropertyCSSValue(textDecorationPropertyForEditing());
 }
 
 bool HTMLTextDecorationEquivalent::valueIsPresentInStyle(HTMLElement* element, StylePropertySet* style) const
 {
-    CSSValue* styleValue = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
+    const CSSValue* styleValue = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
     if (!styleValue)
         styleValue = style->getPropertyCSSValue(textDecorationPropertyForEditing());
     return matches(element) && styleValue && styleValue->isValueList() && toCSSValueList(styleValue)->hasValue(*m_primitiveValue);
 }
 
 class HTMLAttributeEquivalent : public HTMLElementEquivalent {
 public:
     static HTMLAttributeEquivalent* create(CSSPropertyID propertyID, const HTMLQualifiedName& tagName, const QualifiedName& attrName)
     {
         return new HTMLAttributeEquivalent(propertyID, tagName, attrName);
@@ skipping 26 matching lines @@
 
 HTMLAttributeEquivalent::HTMLAttributeEquivalent(CSSPropertyID id, const QualifiedName& attrName)
     : HTMLElementEquivalent(id)
     , m_attrName(attrName)
 {
 }
 
 bool HTMLAttributeEquivalent::valueIsPresentInStyle(HTMLElement* element, StylePropertySet* style) const
 {
     CSSValue* value = attributeValueAsCSSValue(element);
-    CSSValue* styleValue = style->getPropertyCSSValue(m_propertyID);
+    const CSSValue* styleValue = style->getPropertyCSSValue(m_propertyID);
 
     return compareCSSValuePtr(value, styleValue);
 }
 
 void HTMLAttributeEquivalent::addToStyle(Element* element, EditingStyle* style) const
 {
     if (CSSValue* value = attributeValueAsCSSValue(element))
         style->setProperty(m_propertyID, value->cssText());
 }
 
@@ skipping 73 matching lines @@
 
 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)
+static Color cssValueToColor(const CSSValue* colorValue)
 {
     if (!colorValue || (!colorValue->isColorValue() && !colorValue->isPrimitiveValue()))
         return Color::transparent;
 
     if (colorValue->isColorValue())
         return toCSSColorValue(colorValue)->value();
 
     Color color = 0;
     // FIXME: Why ignore the return value?
     CSSParser::parseColor(color, colorValue->cssText());
@@ skipping 57 matching lines @@
 {
     if (isTabHTMLSpanElementTextNode(node))
         node = tabSpanElement(node)->parentNode();
     else if (isTabHTMLSpanElement(node))
         node = node->parentNode();
 
     CSSComputedStyleDeclaration* computedStyleAtPosition = CSSComputedStyleDeclaration::create(node);
     m_mutableStyle = propertiesToInclude == AllProperties && computedStyleAtPosition ? computedStyleAtPosition->copyProperties() : editingStyleFromComputedStyle(computedStyleAtPosition);
 
     if (propertiesToInclude == EditingPropertiesInEffect) {
-        if (CSSValue* value = backgroundColorValueInEffect(node))
+        if (const CSSValue* value = backgroundColorValueInEffect(node))
             m_mutableStyle->setProperty(CSSPropertyBackgroundColor, value->cssText());
-        if (CSSValue* value = computedStyleAtPosition->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect))
+        if (const CSSValue* value = computedStyleAtPosition->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect))
             m_mutableStyle->setProperty(CSSPropertyTextDecoration, value->cssText());
     }
 
     if (node && node->ensureComputedStyle()) {
         const ComputedStyle* computedStyle = node->ensureComputedStyle();
         removeTextFillAndStrokeColorsIfNeeded(computedStyle);
         replaceFontSizeByKeywordIfPossible(computedStyle, computedStyleAtPosition);
     }
 
     m_isMonospaceFont = computedStyleAtPosition->isMonospaceFont();
@@ skipping 31 matching lines @@
     if (!m_mutableStyle)
         return;
 
     if (m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize)) {
         // Explicit font size overrides any delta.
         m_mutableStyle->removeProperty(CSSPropertyWebkitFontSizeDelta);
         return;
     }
 
     // Get the adjustment amount out of the style.
-    CSSValue* value = m_mutableStyle->getPropertyCSSValue(CSSPropertyWebkitFontSizeDelta);
+    const CSSValue* value = m_mutableStyle->getPropertyCSSValue(CSSPropertyWebkitFontSizeDelta);
     if (!value || !value->isPrimitiveValue())
         return;
 
-    CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
+    const CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     // Only PX handled now. If we handle more types in the future, perhaps
     // a switch statement here would be more appropriate.
     if (!primitiveValue->isPx())
         return;
 
     m_fontSizeDelta = primitiveValue->getFloatValue();
     m_mutableStyle->removeProperty(CSSPropertyWebkitFontSizeDelta);
 }
 
 bool EditingStyle::isEmpty() const
 {
     return (!m_mutableStyle || m_mutableStyle->isEmpty()) && m_fontSizeDelta == NoFontDelta;
 }
 
 bool EditingStyle::textDirection(WritingDirection& writingDirection) const
 {
     if (!m_mutableStyle)
         return false;
 
-    CSSValue* unicodeBidi = m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+    const CSSValue* unicodeBidi = m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
     if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
         return false;
 
     CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
     if (isEmbedOrIsolate(unicodeBidiValue)) {
-        CSSValue* direction = m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
+        const CSSValue* direction = m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
         if (!direction || !direction->isPrimitiveValue())
             return false;
 
         writingDirection = toCSSPrimitiveValue(direction)->getValueID() == CSSValueLtr ? LeftToRightWritingDirection : RightToLeftWritingDirection;
 
         return true;
     }
 
     if (unicodeBidiValue == CSSValueNormal) {
         writingDirection = NaturalWritingDirection;
@@ skipping 120 matching lines @@
     unsigned propertyCount = nodeStyle->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i)
         m_mutableStyle->removeProperty(nodeStyle->propertyAt(i).id());
 }
 
 void EditingStyle::collapseTextDecorationProperties()
 {
     if (!m_mutableStyle)
         return;
 
-    CSSValue* textDecorationsInEffect = m_mutableStyle->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
+    const CSSValue* textDecorationsInEffect = m_mutableStyle->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
     if (!textDecorationsInEffect)
         return;
 
     if (textDecorationsInEffect->isValueList())
         m_mutableStyle->setProperty(textDecorationPropertyForEditing(), textDecorationsInEffect->cssText(), m_mutableStyle->propertyIsImportant(textDecorationPropertyForEditing()));
     else
         m_mutableStyle->removeProperty(textDecorationPropertyForEditing());
     m_mutableStyle->removeProperty(CSSPropertyWebkitTextDecorationsInEffect);
 }
 
@@ skipping 52 matching lines @@
     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));
+                    const 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;
@@ skipping 225 matching lines @@
 {
     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
     // which one of editingStyleAtPosition or computedStyle is called.
     EditingStyle* editingStyleAtPosition = EditingStyle::create(position, EditingPropertiesInEffect);
     StylePropertySet* styleAtPosition = editingStyleAtPosition->m_mutableStyle.get();
 
-    CSSValue* unicodeBidi = nullptr;
-    CSSValue* direction = nullptr;
+    const CSSValue* unicodeBidi = nullptr;
+    const CSSValue* direction = nullptr;
     if (shouldPreserveWritingDirection == PreserveWritingDirection) {
         unicodeBidi = m_mutableStyle->getPropertyCSSValue(CSSPropertyUnicodeBidi);
         direction = m_mutableStyle->getPropertyCSSValue(CSSPropertyDirection);
     }
 
     m_mutableStyle->removeEquivalentProperties(styleAtPosition);
 
     if (textAlignResolvingStartAndEnd(m_mutableStyle.get()) == textAlignResolvingStartAndEnd(styleAtPosition))
         m_mutableStyle->removeProperty(CSSPropertyTextAlign);
 
@@ skipping 118 matching lines @@
             break;
         if (node.isStyledElement() && !isMailHTMLBlockquoteElement(&node)) {
             wrappingStyle->mergeInlineAndImplicitStyleOfElement(toElement(&node), EditingStyle::DoNotOverrideValues,
                 EditingStyle::EditingPropertiesInEffect);
         }
     }
 
     return wrappingStyle;
 }
 
-static void mergeTextDecorationValues(CSSValueList* mergedValue, const CSSValueList* valueToMerge)
+static CSSValueList* mergeTextDecorationValues(const CSSValueList* mergedValue, const CSSValueList* valueToMerge)
 {
     DEFINE_STATIC_LOCAL(CSSPrimitiveValue, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
     DEFINE_STATIC_LOCAL(CSSPrimitiveValue, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
+    CSSValueList* result = mergedValue->copy();
     if (valueToMerge->hasValue(underline) && !mergedValue->hasValue(underline))
-        mergedValue->append(&underline);
+        result->append(&underline);
 
     if (valueToMerge->hasValue(lineThrough) && !mergedValue->hasValue(lineThrough))
-        mergedValue->append(&lineThrough);
+        result->append(&lineThrough);
+
+    return result;
 }
 
 void EditingStyle::mergeStyle(const StylePropertySet* style, CSSPropertyOverrideMode mode)
 {
     if (!style)
         return;
 
     if (!m_mutableStyle) {
         m_mutableStyle = style->mutableCopy();
         return;
     }
 
     unsigned propertyCount = style->propertyCount();
     for (unsigned i = 0; i < propertyCount; ++i) {
         StylePropertySet::PropertyReference property = style->propertyAt(i);
-        CSSValue* value = m_mutableStyle->getPropertyCSSValue(property.id());
+        const CSSValue* value = m_mutableStyle->getPropertyCSSValue(property.id());
 
         // text decorations never override values
         if ((property.id() == textDecorationPropertyForEditing() || property.id() == CSSPropertyWebkitTextDecorationsInEffect) && property.value()->isValueList() && value) {
             if (value->isValueList()) {
-                mergeTextDecorationValues(toCSSValueList(value), toCSSValueList(property.value()));
+                CSSValueList* result = mergeTextDecorationValues(toCSSValueList(value), toCSSValueList(property.value()));
+                m_mutableStyle->setProperty(property.id(), result, property.isImportant());

[sashab, 2016/06/06 05:50:32]

This is the only behavior change that needs real review (this and the change to
mergeTextDecorationValues above)

                 continue;
             }
             value = nullptr; // text-decoration: none is equivalent to not having the property
         }
 
         if (mode == OverrideValues || (mode == DoNotOverrideValues && !value))
             m_mutableStyle->setProperty(property.id(), property.value()->cssText(), property.isImportant());
     }
 }
 
@@ skipping 31 matching lines @@
     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);
             CSSValue* value = property.value();
             if (!value->isPrimitiveValue())
                 continue;
             if (toCSSPrimitiveValue(value)->isPercentage()) {
-                if (CSSValue* computedPropertyValue = computedStyleForElement->getPropertyCSSValue(property.id()))
+                if (const CSSValue* computedPropertyValue = computedStyleForElement->getPropertyCSSValue(property.id()))
                     fromComputedStyle->addRespectingCascade(CSSProperty(property.id(), computedPropertyValue));
             }
         }
     }
     m_mutableStyle->mergeAndOverrideOnConflict(fromComputedStyle);
 }
 
 static void removePropertiesInStyle(MutableStylePropertySet* styleToRemovePropertiesFrom, StylePropertySet* style)
 {
     unsigned propertyCount = style->propertyCount();
@@ skipping 73 matching lines @@
 void EditingStyle::forceInline()
 {
     if (!m_mutableStyle)
         m_mutableStyle = MutableStylePropertySet::create(HTMLQuirksMode);
     const bool propertyIsImportant = true;
     m_mutableStyle->setProperty(CSSPropertyDisplay, CSSValueInline, propertyIsImportant);
 }
 
 int EditingStyle::legacyFontSize(Document* document) const
 {
-    CSSValue* cssValue = m_mutableStyle->getPropertyCSSValue(CSSPropertyFontSize);
+    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, MutableStylePropertySet* styleToCheck)
 {
     if (selection.isNone())
         return nullptr;
@@ skipping 24 matching lines @@
         // 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())))
+        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
@@ skipping 17 matching lines @@
     if (selection.isRange()) {
         end = mostBackwardCaretPosition(selection.end());
 
         DCHECK(end.document());
         Node* pastLast = Range::create(*end.document(), position.parentAnchoredEquivalent(), end.parentAnchoredEquivalent())->pastLastNode();
         for (Node* n = node; n && n != pastLast; n = NodeTraversal::next(*n)) {
             if (!n->isStyledElement())
                 continue;
 
             CSSComputedStyleDeclaration* style = CSSComputedStyleDeclaration::create(n);
-            CSSValue* unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+            const CSSValue* unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
             if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
                 continue;
 
             CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
             if (isUnicodeBidiNestedOrMultipleEmbeddings(unicodeBidiValue))
                 return NaturalWritingDirection;
         }
     }
 
     if (selection.isCaret()) {
@@ skipping 12 matching lines @@
     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);
-        CSSValue* unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
+        const CSSValue* unicodeBidi = style->getPropertyCSSValue(CSSPropertyUnicodeBidi);
         if (!unicodeBidi || !unicodeBidi->isPrimitiveValue())
             continue;
 
         CSSValueID unicodeBidiValue = toCSSPrimitiveValue(unicodeBidi)->getValueID();
         if (unicodeBidiValue == CSSValueNormal)
             continue;
 
         if (unicodeBidiValue == CSSValueBidiOverride)
             return NaturalWritingDirection;
 
         DCHECK(isEmbedOrIsolate(unicodeBidiValue)) << unicodeBidiValue;
-        CSSValue* direction = style->getPropertyCSSValue(CSSPropertyDirection);
+        const CSSValue* direction = style->getPropertyCSSValue(CSSPropertyDirection);
         if (!direction || !direction->isPrimitiveValue())
             continue;
 
         int directionValue = toCSSPrimitiveValue(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)
 {
-    CSSValue* textDecorationsInEffect = style->getPropertyCSSValue(CSSPropertyWebkitTextDecorationsInEffect);
-    CSSValue* textDecoration = style->getPropertyCSSValue(textDecorationPropertyForEditing());
+    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.
     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 (textDecoration && !textDecoration->isValueList())
@@ skipping 55 matching lines @@
     }
 
     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.
-    CSSValue* textDecoration = style->getPropertyCSSValue(textDecorationPropertyForEditing());
+    const CSSValue* textDecoration = style->getPropertyCSSValue(textDecorationPropertyForEditing());
     if (textDecoration && textDecoration->isValueList()) {
         DEFINE_STATIC_LOCAL(CSSPrimitiveValue, underline, (CSSPrimitiveValue::createIdentifier(CSSValueUnderline)));
         DEFINE_STATIC_LOCAL(CSSPrimitiveValue, lineThrough, (CSSPrimitiveValue::createIdentifier(CSSValueLineThrough)));
         CSSValueList* newTextDecoration = toCSSValueList(textDecoration)->copy();
         if (newTextDecoration->removeAll(underline))
             m_applyUnderline = true;
         if (newTextDecoration->removeAll(lineThrough))
             m_applyLineThrough = true;
 
         // If trimTextDecorations, delete underline and line-through
@@ skipping 15 matching lines @@
     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
     m_applyFontFace.replace('"', "");
     style->removeProperty(CSSPropertyFontFamily);
 
-    if (CSSValue* fontSize = style->getPropertyCSSValue(CSSPropertyFontSize)) {
+    if (const CSSValue* fontSize = style->getPropertyCSSValue(CSSPropertyFontSize)) {
         if (!fontSize->isPrimitiveValue()) {
             style->removeProperty(CSSPropertyFontSize); // Can't make sense of the number. Put no font size.
         } else if (int legacyFontSize = legacyFontSizeFromCSSValue(document, toCSSPrimitiveValue(fontSize), isMonospaceFont, UseLegacyFontSizeOnlyIfPixelValuesMatch)) {
             m_applyFontSize = String::number(legacyFontSize);
             style->removeProperty(CSSPropertyFontSize);
         }
     }
 }
 
-static void diffTextDecorations(MutableStylePropertySet* style, CSSPropertyID propertID, CSSValue* refTextDecoration)
+static void diffTextDecorations(MutableStylePropertySet* style, CSSPropertyID propertyID, const CSSValue* refTextDecoration)
 {
-    CSSValue* textDecoration = style->getPropertyCSSValue(propertID);
+    const CSSValue* textDecoration = style->getPropertyCSSValue(propertyID);

[sashab, 2016/06/06 05:50:32]

Typo fix hehe

     if (!textDecoration || !textDecoration->isValueList() || !refTextDecoration || !refTextDecoration->isValueList())
         return;
 
     CSSValueList* newTextDecoration = toCSSValueList(textDecoration)->copy();
-    CSSValueList* valuesInRefTextDecoration = toCSSValueList(refTextDecoration);
+    const CSSValueList* valuesInRefTextDecoration = toCSSValueList(refTextDecoration);
 
     for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)
         newTextDecoration->removeAll(*valuesInRefTextDecoration->item(i));
 
-    setTextDecorationProperty(style, newTextDecoration, propertID);
+    setTextDecorationProperty(style, newTextDecoration, propertyID);
 }
 
-static bool fontWeightIsBold(CSSValue* fontWeight)
+static bool fontWeightIsBold(const CSSValue* fontWeight)
 {
     if (!fontWeight->isPrimitiveValue())
         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.
     switch (toCSSPrimitiveValue(fontWeight)->getValueID()) {
     case CSSValue100:
     case CSSValue200:
     case CSSValue300:
     case CSSValue400:
     case CSSValue500:
     case CSSValueNormal:
         return false;
     case CSSValueBold:
     case CSSValue600:
     case CSSValue700:
     case CSSValue800:
     case CSSValue900:
         return true;
     default:
         break;
     }
 
     ASSERT_NOT_REACHED(); // For CSSValueBolder and CSSValueLighter
     return false;
 }
 
-static bool fontWeightNeedsResolving(CSSValue* fontWeight)
+static bool fontWeightNeedsResolving(const CSSValue* fontWeight)
 {
     if (!fontWeight->isPrimitiveValue())
         return true;
 
-    CSSValueID value = toCSSPrimitiveValue(fontWeight)->getValueID();
+    const CSSValueID value = toCSSPrimitiveValue(fontWeight)->getValueID();
     return value == CSSValueLighter || value == CSSValueBolder;
 }
 
 MutableStylePropertySet* getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle)
 {
     DCHECK(styleWithRedundantProperties);
     DCHECK(baseStyle);
     MutableStylePropertySet* result = styleWithRedundantProperties->mutableCopy();
 
     result->removeEquivalentProperties(baseStyle);
 
-    CSSValue* baseTextDecorationsInEffect = baseStyle->getPropertyCSSValueInternal(CSSPropertyWebkitTextDecorationsInEffect);
+    const CSSValue* baseTextDecorationsInEffect = baseStyle->getPropertyCSSValueInternal(CSSPropertyWebkitTextDecorationsInEffect);
     diffTextDecorations(result, textDecorationPropertyForEditing(), baseTextDecorationsInEffect);
     diffTextDecorations(result, CSSPropertyWebkitTextDecorationsInEffect, baseTextDecorationsInEffect);
 
-    if (CSSValue* baseFontWeight = baseStyle->getPropertyCSSValueInternal(CSSPropertyFontWeight)) {
+    if (const CSSValue* baseFontWeight = baseStyle->getPropertyCSSValueInternal(CSSPropertyFontWeight)) {
         if (CSSValue* fontWeight = result->getPropertyCSSValue(CSSPropertyFontWeight)) {
             if (!fontWeightNeedsResolving(fontWeight) && !fontWeightNeedsResolving(baseFontWeight)
                 && (fontWeightIsBold(fontWeight) == fontWeightIsBold(baseFontWeight)))
                 result->removeProperty(CSSPropertyFontWeight);
         }
     }
 
     if (baseStyle->getPropertyCSSValueInternal(CSSPropertyColor) && getFontColor(result) == getFontColor(baseStyle))
         result->removeProperty(CSSPropertyColor);
 
     if (baseStyle->getPropertyCSSValueInternal(CSSPropertyTextAlign)
         && textAlignResolvingStartAndEnd(result) == textAlignResolvingStartAndEnd(baseStyle))
         result->removeProperty(CSSPropertyTextAlign);
 
     if (baseStyle->getPropertyCSSValueInternal(CSSPropertyBackgroundColor) && getBackgroundColor(result) == getBackgroundColor(baseStyle))
         result->removeProperty(CSSPropertyBackgroundColor);
 
     return result;
 }
 
 CSSValueID getIdentifierValue(StylePropertySet* style, CSSPropertyID propertyID)
 {
     if (!style)
         return CSSValueInvalid;
-    CSSValue* value = style->getPropertyCSSValue(propertyID);
+    const CSSValue* value = style->getPropertyCSSValue(propertyID);
     if (!value || !value->isPrimitiveValue())
         return CSSValueInvalid;
     return toCSSPrimitiveValue(value)->getValueID();
 }
 
 CSSValueID getIdentifierValue(CSSStyleDeclaration* style, CSSPropertyID propertyID)
 {
     if (!style)
         return CSSValueInvalid;
-    CSSValue* value = style->getPropertyCSSValueInternal(propertyID);
+    const CSSValue* value = style->getPropertyCSSValueInternal(propertyID);
     if (!value || !value->isPrimitiveValue())
         return CSSValueInvalid;
     return toCSSPrimitiveValue(value)->getValueID();
 }
 
-int legacyFontSizeFromCSSValue(Document* document, CSSPrimitiveValue* value, bool isMonospaceFont, LegacyFontSizeMode mode)
+int legacyFontSizeFromCSSValue(Document* document, const CSSPrimitiveValue* value, bool isMonospaceFont, LegacyFontSizeMode mode)
 {
     CSSPrimitiveValue::LengthUnitType lengthType;
     if (CSSPrimitiveValue::unitTypeToLengthUnitType(value->typeWithCalcResolved(), lengthType)
         && lengthType == CSSPrimitiveValue::UnitTypePixels) {
         double conversion = CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(value->typeWithCalcResolved());
         int pixelFontSize = clampTo<int>(value->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.
         if (mode == AlwaysUseLegacyFontSize || FontSize::fontSizeForKeyword(document, legacyFontSize, isMonospaceFont) == pixelFontSize)
             return legacyFontSize;
 
         return 0;
     }
 
     if (CSSValueXSmall <= value->getValueID() && value->getValueID() <= CSSValueWebkitXxxLarge)
         return value->getValueID() - CSSValueXSmall + 1;
 
     return 0;
 }
 
-bool isTransparentColorValue(CSSValue* cssValue)
+bool isTransparentColorValue(const CSSValue* cssValue)
 {
     if (!cssValue)
         return true;
     if (cssValue->isColorValue())
         return !toCSSColorValue(cssValue)->value().alpha();
     if (!cssValue->isPrimitiveValue())
         return false;
-    CSSPrimitiveValue* value = toCSSPrimitiveValue(cssValue);
+    const CSSPrimitiveValue* value = toCSSPrimitiveValue(cssValue);
     return value->getValueID() == CSSValueTransparent;
 }
 
 bool hasTransparentBackgroundColor(CSSStyleDeclaration* style)
 {
-    CSSValue* cssValue = style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor);
+    const CSSValue* cssValue = style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor);
     return isTransparentColorValue(cssValue);
 }
 
 bool hasTransparentBackgroundColor(StylePropertySet* style)
 {
-    CSSValue* cssValue = style->getPropertyCSSValue(CSSPropertyBackgroundColor);
+    const CSSValue* cssValue = style->getPropertyCSSValue(CSSPropertyBackgroundColor);
     return isTransparentColorValue(cssValue);
 }
 
-CSSValue* backgroundColorValueInEffect(Node* node)
+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