Rename LayoutStyle to papayawhip

Source/core/css/resolver/StyleBuilderCustom.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 2004-2005 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2006, 2007 Nicholas Shanks (webkit@nickshanks.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  * Copyright (C) 2007, 2008 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (c) 2011, Code Aurora Forum. All rights reserved.
@@ skipping 47 matching lines @@
 #include "core/css/StylePropertySet.h"
 #include "core/css/StyleRule.h"
 #include "core/css/resolver/ElementStyleResources.h"
 #include "core/css/resolver/FilterOperationResolver.h"
 #include "core/css/resolver/FontBuilder.h"
 #include "core/css/resolver/StyleBuilder.h"
 #include "core/css/resolver/TransformBuilder.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/layout/style/CounterContent.h"
-#include "core/layout/style/LayoutStyle.h"
-#include "core/layout/style/LayoutStyleConstants.h"
+#include "core/layout/style/ComputedStyle.h"
+#include "core/layout/style/ComputedStyleConstants.h"
 #include "core/layout/style/PathStyleMotionPath.h"
 #include "core/layout/style/QuotesData.h"
-#include "core/layout/style/SVGLayoutStyle.h"
+#include "core/layout/style/SVGComputedStyle.h"
 #include "core/layout/style/StyleGeneratedImage.h"
 #include "platform/fonts/FontDescription.h"
 #include "wtf/MathExtras.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/Vector.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 45 matching lines @@
             isInherit = true;
         else
             isInitial = true;
     }
 
     StyleBuilder::applyProperty(id, state, value, isInitial, isInherit);
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyColor(StyleResolverState& state)
 {
-    Color color = LayoutStyle::initialColor();
+    Color color = ComputedStyle::initialColor();
     if (state.applyPropertyToRegularStyle())
         state.style()->setColor(color);
     if (state.applyPropertyToVisitedLinkStyle())
         state.style()->setVisitedLinkColor(color);
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyColor(StyleResolverState& state)
 {
     Color color = state.parentStyle()->color();
     if (state.applyPropertyToRegularStyle())
@@ skipping 12 matching lines @@
     }
 
     if (state.applyPropertyToRegularStyle())
         state.style()->setColor(StyleBuilderConverter::convertColor(state, value));
     if (state.applyPropertyToVisitedLinkStyle())
         state.style()->setVisitedLinkColor(StyleBuilderConverter::convertColor(state, value, true));
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyJustifyItems(StyleResolverState& state)
 {
-    state.style()->setJustifyItems(LayoutStyle::initialJustifyItems());
-    state.style()->setJustifyItemsOverflowAlignment(LayoutStyle::initialJustifyItemsOverflowAlignment());
-    state.style()->setJustifyItemsPositionType(LayoutStyle::initialJustifyItemsPositionType());
+    state.style()->setJustifyItems(ComputedStyle::initialJustifyItems());
+    state.style()->setJustifyItemsOverflowAlignment(ComputedStyle::initialJustifyItemsOverflowAlignment());
+    state.style()->setJustifyItemsPositionType(ComputedStyle::initialJustifyItemsPositionType());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyJustifyItems(StyleResolverState& state)
 {
     state.style()->setJustifyItems(state.parentStyle()->justifyItems());
     state.style()->setJustifyItemsOverflowAlignment(state.parentStyle()->justifyItemsOverflowAlignment());
     state.style()->setJustifyItemsPositionType(state.parentStyle()->justifyItemsPositionType());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyJustifyItems(StyleResolverState& state, CSSValue* value)
 {
-    state.style()->setJustifyItems(LayoutStyle::initialJustifyItems());
-    state.style()->setJustifyItemsOverflowAlignment(LayoutStyle::initialJustifyItemsOverflowAlignment());
-    state.style()->setJustifyItemsPositionType(LayoutStyle::initialJustifyItemsPositionType());
+    state.style()->setJustifyItems(ComputedStyle::initialJustifyItems());
+    state.style()->setJustifyItemsOverflowAlignment(ComputedStyle::initialJustifyItemsOverflowAlignment());
+    state.style()->setJustifyItemsPositionType(ComputedStyle::initialJustifyItemsPositionType());
 
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     if (Pair* pairValue = primitiveValue->getPairValue()) {
         if (pairValue->first()->getValueID() == CSSValueLegacy) {
             state.style()->setJustifyItemsPositionType(LegacyPosition);
             state.style()->setJustifyItems(*pairValue->second());
         } else {
             state.style()->setJustifyItems(*pairValue->first());
             state.style()->setJustifyItemsOverflowAlignment(*pairValue->second());
         }
     } else {
         state.style()->setJustifyItems(*primitiveValue);
     }
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyCursor(StyleResolverState& state)
 {
     state.style()->clearCursorList();
-    state.style()->setCursor(LayoutStyle::initialCursor());
+    state.style()->setCursor(ComputedStyle::initialCursor());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyCursor(StyleResolverState& state)
 {
     state.style()->setCursor(state.parentStyle()->cursor());
     state.style()->setCursorList(state.parentStyle()->cursors());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyCursor(StyleResolverState& state, CSSValue* value)
 {
@@ skipping 26 matching lines @@
 void StyleBuilderFunctions::applyValueCSSPropertyGlyphOrientationVertical(StyleResolverState& state, CSSValue* value)
 {
     if (value->isPrimitiveValue() && toCSSPrimitiveValue(value)->getValueID() == CSSValueAuto)
         state.style()->accessSVGStyle().setGlyphOrientationVertical(GO_AUTO);
     else
         state.style()->accessSVGStyle().setGlyphOrientationVertical(StyleBuilderConverter::convertGlyphOrientation(state, value));
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyGridTemplateAreas(StyleResolverState& state)
 {
-    state.style()->setNamedGridArea(LayoutStyle::initialNamedGridArea());
-    state.style()->setNamedGridAreaRowCount(LayoutStyle::initialNamedGridAreaCount());
-    state.style()->setNamedGridAreaColumnCount(LayoutStyle::initialNamedGridAreaCount());
+    state.style()->setNamedGridArea(ComputedStyle::initialNamedGridArea());
+    state.style()->setNamedGridAreaRowCount(ComputedStyle::initialNamedGridAreaCount());
+    state.style()->setNamedGridAreaColumnCount(ComputedStyle::initialNamedGridAreaCount());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyGridTemplateAreas(StyleResolverState& state)
 {
     state.style()->setNamedGridArea(state.parentStyle()->namedGridArea());
     state.style()->setNamedGridAreaRowCount(state.parentStyle()->namedGridAreaRowCount());
     state.style()->setNamedGridAreaColumnCount(state.parentStyle()->namedGridAreaColumnCount());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyGridTemplateAreas(StyleResolverState& state, CSSValue* value)
@@ skipping 21 matching lines @@
     state.style()->setNamedGridAreaColumnCount(gridTemplateAreasValue->columnCount());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyListStyleImage(StyleResolverState& state, CSSValue* value)
 {
     state.style()->setListStyleImage(state.styleImage(CSSPropertyListStyleImage, value));
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyOutlineStyle(StyleResolverState& state)
 {
-    state.style()->setOutlineStyleIsAuto(LayoutStyle::initialOutlineStyleIsAuto());
-    state.style()->setOutlineStyle(LayoutStyle::initialBorderStyle());
+    state.style()->setOutlineStyleIsAuto(ComputedStyle::initialOutlineStyleIsAuto());
+    state.style()->setOutlineStyle(ComputedStyle::initialBorderStyle());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyOutlineStyle(StyleResolverState& state)
 {
     state.style()->setOutlineStyleIsAuto(state.parentStyle()->outlineStyleIsAuto());
     state.style()->setOutlineStyle(state.parentStyle()->outlineStyle());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyOutlineStyle(StyleResolverState& state, CSSValue* value)
 {
@@ skipping 147 matching lines @@
 
 void StyleBuilderFunctions::applyInheritCSSPropertyTextIndent(StyleResolverState& state)
 {
     state.style()->setTextIndent(state.parentStyle()->textIndent());
     state.style()->setTextIndentLine(state.parentStyle()->textIndentLine());
     state.style()->setTextIndentType(state.parentStyle()->textIndentType());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyTextIndent(StyleResolverState& state)
 {
-    state.style()->setTextIndent(LayoutStyle::initialTextIndent());
-    state.style()->setTextIndentLine(LayoutStyle::initialTextIndentLine());
-    state.style()->setTextIndentType(LayoutStyle::initialTextIndentType());
+    state.style()->setTextIndent(ComputedStyle::initialTextIndent());
+    state.style()->setTextIndentLine(ComputedStyle::initialTextIndentLine());
+    state.style()->setTextIndentType(ComputedStyle::initialTextIndentType());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyTextIndent(StyleResolverState& state, CSSValue* value)
 {
     Length lengthOrPercentageValue;
-    TextIndentLine textIndentLineValue = LayoutStyle::initialTextIndentLine();
-    TextIndentType textIndentTypeValue = LayoutStyle::initialTextIndentType();
+    TextIndentLine textIndentLineValue = ComputedStyle::initialTextIndentLine();
+    TextIndentType textIndentTypeValue = ComputedStyle::initialTextIndentType();
 
     for (auto& listValue : toCSSValueList(*value)) {
         CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(listValue.get());
         if (!primitiveValue->getValueID())
             lengthOrPercentageValue = primitiveValue->convertToLength(state.cssToLengthConversionData());
         else if (primitiveValue->getValueID() == CSSValueEachLine)
             textIndentLineValue = TextIndentEachLine;
         else if (primitiveValue->getValueID() == CSSValueHanging)
             textIndentTypeValue = TextIndentHanging;
         else
@@ skipping 39 matching lines @@
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyMotionRotation(StyleResolverState& state)
 {
     state.style()->setMotionRotation(state.parentStyle()->motionRotation());
     state.style()->setMotionRotationType(state.parentStyle()->motionRotationType());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyMotionRotation(StyleResolverState& state)
 {
-    state.style()->setMotionRotation(LayoutStyle::initialMotionRotation());
-    state.style()->setMotionRotationType(LayoutStyle::initialMotionRotationType());
+    state.style()->setMotionRotation(ComputedStyle::initialMotionRotation());
+    state.style()->setMotionRotationType(ComputedStyle::initialMotionRotationType());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyMotionRotation(StyleResolverState& state, CSSValue* value)
 {
     float rotation = 0;
     MotionRotationType rotationType = MotionRotationFixed;
 
     ASSERT(value->isValueList());
     CSSValueList* list = toCSSValueList(value);
     int len = list->length();
@@ skipping 29 matching lines @@
 
     if (primitiveValue->getValueID())
         state.style()->setVerticalAlign(*primitiveValue);
     else
         state.style()->setVerticalAlignLength(primitiveValue->convertToLength(state.cssToLengthConversionData()));
 }
 
 static void resetEffectiveZoom(StyleResolverState& state)
 {
     // Reset the zoom in effect. This allows the setZoom method to accurately compute a new zoom in effect.
-    state.setEffectiveZoom(state.parentStyle() ? state.parentStyle()->effectiveZoom() : LayoutStyle::initialZoom());
+    state.setEffectiveZoom(state.parentStyle() ? state.parentStyle()->effectiveZoom() : ComputedStyle::initialZoom());
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
-    state.setZoom(LayoutStyle::initialZoom());
+    state.setZoom(ComputedStyle::initialZoom());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyZoom(StyleResolverState& state)
 {
     resetEffectiveZoom(state);
     state.setZoom(state.parentStyle()->zoom());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyZoom(StyleResolverState& state, CSSValue* value)
 {
     ASSERT_WITH_SECURITY_IMPLICATION(value->isPrimitiveValue());
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
 
     if (primitiveValue->getValueID() == CSSValueNormal) {
         resetEffectiveZoom(state);
-        state.setZoom(LayoutStyle::initialZoom());
+        state.setZoom(ComputedStyle::initialZoom());
     } else if (primitiveValue->getValueID() == CSSValueReset) {
-        state.setEffectiveZoom(LayoutStyle::initialZoom());
-        state.setZoom(LayoutStyle::initialZoom());
+        state.setEffectiveZoom(ComputedStyle::initialZoom());
+        state.setZoom(ComputedStyle::initialZoom());
     } else if (primitiveValue->getValueID() == CSSValueDocument) {
-        float docZoom = state.rootElementStyle() ? state.rootElementStyle()->zoom() : LayoutStyle::initialZoom();
+        float docZoom = state.rootElementStyle() ? state.rootElementStyle()->zoom() : ComputedStyle::initialZoom();
         state.setEffectiveZoom(docZoom);
         state.setZoom(docZoom);
     } else if (primitiveValue->isPercentage()) {
         resetEffectiveZoom(state);
         if (float percent = primitiveValue->getFloatValue())
             state.setZoom(percent / 100.0f);
     } else if (primitiveValue->isNumber()) {
         resetEffectiveZoom(state);
         if (float number = primitiveValue->getFloatValue())
             state.setZoom(number);
@@ skipping 26 matching lines @@
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitFilter(StyleResolverState& state, CSSValue* value)
 {
     FilterOperations operations;
     if (FilterOperationResolver::createFilterOperations(value, state.cssToLengthConversionData(), operations, state))
         state.style()->setFilter(operations);
 }
 
 void StyleBuilderFunctions::applyInitialCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state)
 {
-    state.style()->setTextEmphasisFill(LayoutStyle::initialTextEmphasisFill());
-    state.style()->setTextEmphasisMark(LayoutStyle::initialTextEmphasisMark());
-    state.style()->setTextEmphasisCustomMark(LayoutStyle::initialTextEmphasisCustomMark());
+    state.style()->setTextEmphasisFill(ComputedStyle::initialTextEmphasisFill());
+    state.style()->setTextEmphasisMark(ComputedStyle::initialTextEmphasisMark());
+    state.style()->setTextEmphasisCustomMark(ComputedStyle::initialTextEmphasisCustomMark());
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state)
 {
     state.style()->setTextEmphasisFill(state.parentStyle()->textEmphasisFill());
     state.style()->setTextEmphasisMark(state.parentStyle()->textEmphasisMark());
     state.style()->setTextEmphasisCustomMark(state.parentStyle()->textEmphasisCustomMark());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextEmphasisStyle(StyleResolverState& state, CSSValue* value)
@@ skipping 188 matching lines @@
     state.setWritingMode(*toCSSPrimitiveValue(value));
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyWebkitTextOrientation(StyleResolverState& state, CSSValue* value)
 {
     state.setTextOrientation(*toCSSPrimitiveValue(value));
 }
 
 void StyleBuilderFunctions::applyInheritCSSPropertyBaselineShift(StyleResolverState& state)
 {
-    const SVGLayoutStyle& parentSvgStyle = state.parentStyle()->svgStyle();
+    const SVGComputedStyle& parentSvgStyle = state.parentStyle()->svgStyle();
     EBaselineShift baselineShift = parentSvgStyle.baselineShift();
-    SVGLayoutStyle& svgStyle = state.style()->accessSVGStyle();
+    SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
     svgStyle.setBaselineShift(baselineShift);
     if (baselineShift == BS_LENGTH)
         svgStyle.setBaselineShiftValue(parentSvgStyle.baselineShiftValue());
 }
 
 void StyleBuilderFunctions::applyValueCSSPropertyBaselineShift(StyleResolverState& state, CSSValue* value)
 {
-    SVGLayoutStyle& svgStyle = state.style()->accessSVGStyle();
+    SVGComputedStyle& svgStyle = state.style()->accessSVGStyle();
     CSSPrimitiveValue* primitiveValue = toCSSPrimitiveValue(value);
     if (!primitiveValue->isValueID()) {
         svgStyle.setBaselineShift(BS_LENGTH);
         svgStyle.setBaselineShiftValue(StyleBuilderConverter::convertLength(state, primitiveValue));
         return;
     }
     switch (primitiveValue->getValueID()) {
     case CSSValueBaseline:
         svgStyle.setBaselineShift(BS_LENGTH);
         svgStyle.setBaselineShiftValue(Length(Fixed));
         return;
     case CSSValueSub:
         svgStyle.setBaselineShift(BS_SUB);
         return;
     case CSSValueSuper:
         svgStyle.setBaselineShift(BS_SUPER);
         return;
     default:
         ASSERT_NOT_REACHED();
     }
 }
 
 } // namespace blink