Rename LayoutStyle to papayawhip

Source/core/css/resolver/StyleBuilderConverter.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
  * distribution.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 46 matching lines @@
 
     return StyleBuilderConverter::convertLengthOrAuto(state, primitiveValue);
 }
 
 } // namespace
 
 PassRefPtr<StyleReflection> StyleBuilderConverter::convertBoxReflect(StyleResolverState& state, CSSValue* value)
 {
     if (value->isPrimitiveValue()) {
         ASSERT(toCSSPrimitiveValue(value)->getValueID() == CSSValueNone);
-        return LayoutStyle::initialBoxReflect();
+        return ComputedStyle::initialBoxReflect();
     }
 
     CSSReflectValue* reflectValue = toCSSReflectValue(value);
     RefPtr<StyleReflection> reflection = StyleReflection::create();
     reflection->setDirection(*reflectValue->direction());
     if (reflectValue->offset())
         reflection->setOffset(reflectValue->offset()->convertToLength(state.cssToLengthConversionData()));
     NinePieceImage mask;
     mask.setMaskDefaults();
     CSSToStyleMap::mapNinePieceImage(state, CSSPropertyWebkitBoxReflect, reflectValue->mask(), mask);
@@ skipping 269 matching lines @@
     case CSSValueColumn:
         if (second && second->getValueID() == CSSValueDense)
             return AutoFlowColumnDense;
         return AutoFlowColumn;
     case CSSValueDense:
         if (second && second->getValueID() == CSSValueColumn)
             return AutoFlowColumnDense;
         return AutoFlowRowDense;
     default:
         ASSERT_NOT_REACHED();
-        return LayoutStyle::initialGridAutoFlow();
+        return ComputedStyle::initialGridAutoFlow();
     }
 }
 
 GridPosition StyleBuilderConverter::convertGridPosition(StyleResolverState&, CSSValue* value)
 {
     // We accept the specification's grammar:
     // 'auto' | [ <integer> || <custom-ident> ] | [ span && [ <integer> || <custom-ident> ] ] | <custom-ident>
 
     GridPosition position;
 
@@ skipping 216 matching lines @@
     if (primitiveValue->isPercentage())
         return Length((state.style()->computedFontSize() * primitiveValue->getIntValue()) / 100.0, Fixed);
     if (primitiveValue->isNumber())
         return Length(primitiveValue->getDoubleValue() * 100.0, Percent);
     if (primitiveValue->isCalculated()) {
         Length zoomedLength = Length(primitiveValue->cssCalcValue()->toCalcValue(lineHeightToLengthConversionData(state)));
         return Length(valueForLength(zoomedLength, state.style()->fontSize()), Fixed);
     }
 
     ASSERT(primitiveValue->getValueID() == CSSValueNormal);
-    return LayoutStyle::initialLineHeight();
+    return ComputedStyle::initialLineHeight();
 }
 
 float StyleBuilderConverter::convertNumberOrPercentage(StyleResolverState& state, CSSValue* value)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     ASSERT(primitiveValue->isNumber() || primitiveValue->isPercentage());
     if (primitiveValue->isNumber())
         return primitiveValue->getFloatValue();
     return primitiveValue->getFloatValue() / 100.0f;
 }
@@ skipping 25 matching lines @@
 static float convertPerspectiveLength(StyleResolverState& state, CSSPrimitiveValue* primitiveValue)
 {
     return std::max(primitiveValue->computeLength<float>(state.cssToLengthConversionData()), 0.0f);
 }
 
 float StyleBuilderConverter::convertPerspective(StyleResolverState& state, CSSValue* value)
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue->getValueID() == CSSValueNone)
-        return LayoutStyle::initialPerspective();
+        return ComputedStyle::initialPerspective();
 
     // CSSPropertyWebkitPerspective accepts unitless numbers.
     if (primitiveValue->isNumber()) {
         RefPtrWillBeRawPtr<CSSPrimitiveValue> px = CSSPrimitiveValue::create(primitiveValue->getDoubleValue(), CSSPrimitiveValue::CSS_PX);
         return convertPerspectiveLength(state, px.get());
     }
 
     return convertPerspectiveLength(state, primitiveValue);
 }
 
@@ skipping 159 matching lines @@
 {
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     if (primitiveValue->getValueID() == CSSValueNormal)
         return 0;
     return primitiveValue->computeLength<float>(state.cssToLengthConversionData());
 }
 
 PassRefPtr<SVGDashArray> StyleBuilderConverter::convertStrokeDasharray(StyleResolverState& state, CSSValue* value)
 {
     if (!value->isValueList())
-        return SVGLayoutStyle::initialStrokeDashArray();
+        return SVGComputedStyle::initialStrokeDashArray();
 
     CSSValueList* dashes = toCSSValueList(value);
 
     RefPtr<SVGDashArray> array = SVGDashArray::create();
     size_t length = dashes->length();
     for (size_t i = 0; i < length; ++i) {
         CSSValue* currValue = dashes->item(i);
         if (!currValue->isPrimitiveValue())
             continue;
 
@@ skipping 41 matching lines @@
     CSSPrimitiveValue* primitiveValueZ = toCSSPrimitiveValue(list->item(2));
 
     return TransformOrigin(
         convertOriginLength<CSSValueLeft, CSSValueRight>(state, primitiveValueX),
         convertOriginLength<CSSValueTop, CSSValueBottom>(state, primitiveValueY),
         StyleBuilderConverter::convertComputedLength<float>(state, primitiveValueZ)
     );
 }
 
 } // namespace blink