CSSValue Immediates: Replace CSSValue 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 131 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 bool isTransparentColorValue(const NullableCSSValue&);
 static bool hasTransparentBackgroundColor(CSSStyleDeclaration*);
 static bool hasTransparentBackgroundColor(StylePropertySet*);
 static NullableCSSValue backgroundColorInEffect(Node*);
 
 class HTMLElementEquivalent : public NoBaseWillBeGarbageCollected<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 1030 matching lines @@
 
     // 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
     RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> computedStyleForElement = CSSComputedStyleDeclaration::create(element);
     RefPtrWillBeRawPtr<MutableStylePropertySet> fromComputedStyle = MutableStylePropertySet::create();
     {
         unsigned propertyCount = m_mutableStyle->propertyCount();
         for (unsigned i = 0; i < propertyCount; ++i) {
             StylePropertySet::PropertyReference property = m_mutableStyle->propertyAt(i);
-            CSSValue value = property.value();
+            const CSSValue& value = property.value();
             if (!value.isPrimitiveValue())
                 continue;
             if (toCSSPrimitiveValue(value).isPercentage()) {
                 if (NullableCSSValue computedPropertyValue = computedStyleForElement->getPropertyCSSValue(property.id()))
                     fromComputedStyle->addRespectingCascade(CSSProperty(property.id(), *computedPropertyValue));
             }
         }
     }
     m_mutableStyle->mergeAndOverrideOnConflict(fromComputedStyle.get());
 }
@@ skipping 349 matching lines @@
 
     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);
 }
 
-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();
     return value == CSSValueLighter || value == CSSValueBolder;
 }
 
 PassRefPtrWillBeRawPtr<MutableStylePropertySet> getPropertiesNotIn(StylePropertySet* styleWithRedundantProperties, CSSStyleDeclaration* baseStyle)
 {
@@ skipping 61 matching lines @@
 
         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);
     if (value->isRGBColor())
         return !alphaChannel(value->getRGBA32Value());
     return value->getValueID() == CSSValueTransparent;
 }
@@ skipping 14 matching lines @@
 {
     for (Node* ancestor = node; ancestor; ancestor = ancestor->parentNode()) {
         RefPtrWillBeRawPtr<CSSComputedStyleDeclaration> ancestorStyle = CSSComputedStyleDeclaration::create(ancestor);
         if (!hasTransparentBackgroundColor(ancestorStyle.get()))
             return ancestorStyle->getPropertyCSSValue(CSSPropertyBackgroundColor);
     }
     return nullptr;
 }
 
 }