CSSValue Immediates: Replace CSSPrimitiveValue usage with const references

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 130 matching lines @@
 
 static PassRefPtrWillBeRawPtr<MutableStylePropertySet> editingStyleFromComputedStyle(PassRefPtrWillBeRawPtr<CSSComputedStyleDeclaration> style, EditingPropertiesType type = OnlyInheritableEditingProperties)
 {
     if (!style)
         return MutableStylePropertySet::create();
     return copyEditingProperties(style.get(), type);
 }
 
 static PassRefPtrWillBeRawPtr<MutableStylePropertySet> getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle);
 enum LegacyFontSizeMode { AlwaysUseLegacyFontSize, UseLegacyFontSizeOnlyIfPixelValuesMatch };
-static int legacyFontSizeFromCSSValue(Document*, CSSPrimitiveValue, bool, LegacyFontSizeMode);
-static bool isTransparentColorValue(NullableCSSValue);
+static int legacyFontSizeFromCSSValue(Document*, const CSSPrimitiveValue&, bool, LegacyFontSizeMode);
+static bool isTransparentColorValue(const NullableCSSValue&);
 static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
 static bool hasTransparentBackgroundColor(StylePropertySet*);
 static NullableCSSValue backgroundColorInEffect(Node*);
 
 class HTMLElementEquivalent : public NoBaseWillBeGarbageCollectedFinalized<HTMLElementEquivalent> {
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED(HTMLElementEquivalent);
     DECLARE_EMPTY_VIRTUAL_DESTRUCTOR_WILL_BE_REMOVED(HTMLElementEquivalent);
 public:
     static PassOwnPtrWillBeRawPtr<HTMLElementEquivalent> create(CSSPropertyID propertyID, CSSValueID primitiveValue, const HTMLQualifiedName& tagName)
     {
@@ skipping 221 matching lines @@
 
 EditingStyle::~EditingStyle()
 {
 }
 
 static RGBA32 cssValueToRGBA(NullableCSSValue colorValue)
 {
     if (!colorValue || !colorValue->isPrimitiveValue())
         return Color::transparent;
 
-    CSSPrimitiveValue primitiveColor = toCSSPrimitiveValue(*colorValue);
+    const CSSPrimitiveValue& primitiveColor = toCSSPrimitiveValue(*colorValue);
     if (primitiveColor.isRGBColor())
         return primitiveColor.getRGBA32Value();
 
     RGBA32 rgba = 0;
     // FIXME: Why ignore the return value?
     CSSParser::parseColor(rgba, colorValue->cssText());
     return rgba;
 }
 
 static inline RGBA32 getRGBAFontColor(CSSStyleDeclaration* style)
@@ skipping 111 matching lines @@
         // Explicit font size overrides any delta.
         m_mutableStyle->removeProperty(CSSPropertyWebkitFontSizeDelta);
         return;
     }
 
     // Get the adjustment amount out of the style.
     NullableCSSValue 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);
 }
 
@@ skipping 1011 matching lines @@
     if (NullableCSSValue 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 propertyID, NullableCSSValue refTextDecoration)
+static void diffTextDecorations(MutableStylePropertySet* style, CSSPropertyID propertyID, const NullableCSSValue& refTextDecoration)
 {
-    NullableCSSValue textDecoration = style->getPropertyCSSValue(propertyID);
+    const NullableCSSValue& textDecoration = style->getPropertyCSSValue(propertyID);
     if (!textDecoration || !textDecoration->isValueList() || !refTextDecoration || !refTextDecoration->isValueList())
         return;
 
     RefPtrWillBeRawPtr<CSSValueList> newTextDecoration = toCSSValueList(textDecoration)->copy();
     CSSValueList* valuesInRefTextDecoration = toCSSValueList(refTextDecoration);
 
     for (size_t i = 0; i < valuesInRefTextDecoration->length(); i++)
         newTextDecoration->removeAll(valuesInRefTextDecoration->item(i));
 
     setTextDecorationProperty(style, newTextDecoration.get(), propertyID);
@@ skipping 82 matching lines @@
 CSSValueID getIdentifierValue(CSSStyleDeclaration* style, CSSPropertyID propertyID)
 {
     if (!style)
         return CSSValueInvalid;
     NullableCSSValue 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.primitiveType(), lengthType)
         && lengthType == CSSPrimitiveValue::UnitTypePixels) {
         double conversion = CSSPrimitiveValue::conversionToCanonicalUnitsScaleFactor(value.primitiveType());
         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(NullableCSSValue cssValue)
+bool isTransparentColorValue(const NullableCSSValue& cssValue)
 {
     if (!cssValue)
         return true;
     if (!cssValue->isPrimitiveValue())
         return false;
-    CSSPrimitiveValue value = toCSSPrimitiveValue(*cssValue);
+    const CSSPrimitiveValue& value = toCSSPrimitiveValue(*cssValue);
     if (value.isRGBColor())
         return !alphaChannel(value.getRGBA32Value());
     return value.getValueID() == CSSValueTransparent;
 }
 
 bool hasTransparentBackgroundColor(CSSStyleDeclaration* style)
 {
     NullableCSSValue cssValue = style->getPropertyCSSValueInternal(CSSPropertyBackgroundColor);
     return isTransparentColorValue(cssValue);
 }
 
 bool hasTransparentBackgroundColor(StylePropertySet* style)
 {
     NullableCSSValue cssValue = style->getPropertyCSSValue(CSSPropertyBackgroundColor);
     return isTransparentColorValue(cssValue);
 }
 
 NullableCSSValue backgroundColorInEffect(Node* node)
 {
     for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
         RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> ancestorStyle = CSSComputedStyleDeclaration::create(ancestor);
         if (!hasTransparentBackgroundColor(ancestorStyle.get()))
             return ancestorStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
     }
     return nullptr;
 }
 
 }