Rename LayoutStyle to papayawhip

Source/core/layout/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Library General Public License for more details.
  *
  * You should have received a copy of the GNU Library General Public License
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
  *
  */
 
-#ifndef LayoutStyle_h
-#define LayoutStyle_h
+#ifndef ComputedStyle_h
+#define ComputedStyle_h
 
 #include "core/CSSPropertyNames.h"
 #include "core/CoreExport.h"
 #include "core/animation/css/CSSAnimationData.h"
 #include "core/animation/css/CSSTransitionData.h"
 #include "core/css/CSSLineBoxContainValue.h"
 #include "core/css/CSSPrimitiveValue.h"
 #include "core/layout/style/BorderValue.h"
 #include "core/layout/style/CounterDirectives.h"
 #include "core/layout/style/DataRef.h"
-#include "core/layout/style/LayoutStyleConstants.h"
+#include "core/layout/style/ComputedStyleConstants.h"
 #include "core/layout/style/LineClampValue.h"
 #include "core/layout/style/NinePieceImage.h"
 #include "core/layout/style/OutlineValue.h"
-#include "core/layout/style/SVGLayoutStyle.h"
+#include "core/layout/style/SVGComputedStyle.h"
 #include "core/layout/style/ShapeValue.h"
 #include "core/layout/style/StyleBackgroundData.h"
 #include "core/layout/style/StyleBoxData.h"
 #include "core/layout/style/StyleDeprecatedFlexibleBoxData.h"
 #include "core/layout/style/StyleDifference.h"
 #include "core/layout/style/StyleFilterData.h"
 #include "core/layout/style/StyleFlexibleBoxData.h"
 #include "core/layout/style/StyleGridData.h"
 #include "core/layout/style/StyleGridItemData.h"
 #include "core/layout/style/StyleInheritedData.h"
@@ skipping 56 matching lines @@
 class Font;
 class FontMetrics;
 class ShadowList;
 class StyleImage;
 class StyleInheritedData;
 class StyleResolver;
 class TransformationMatrix;
 
 class ContentData;
 
-typedef Vector<RefPtr<LayoutStyle>, 4> PseudoStyleCache;
+typedef Vector<RefPtr<ComputedStyle>, 4> PseudoStyleCache;
 
-class CORE_EXPORT LayoutStyle: public RefCounted<LayoutStyle> {
+class CORE_EXPORT ComputedStyle: public RefCounted<ComputedStyle> {
     friend class AnimatedStyleBuilder; // Used by Web Animations CSS. Sets the color styles
     friend class CSSAnimatableValueFactory; // Used by Web Animations CSS. Gets visited and unvisited colors separately.
     friend class CSSPropertyEquality; // Used by CSS animations. We can't allow them to animate based off visited colors.
     friend class ApplyStyleCommand; // Editing has to only reveal unvisited info.
     friend class EditingStyle; // Editing has to only reveal unvisited info.
-    friend class LayoutStyleCSSValueMapping; // Needs to be able to see visited and unvisited colors for devtools.
+    friend class ComputedStyleCSSValueMapping; // Needs to be able to see visited and unvisited colors for devtools.
     friend class StyleBuilderFunctions; // Sets color styles
     friend class CachedUAStyle; // Saves Border/Background information for later comparison.
 
     // FIXME: When we stop resolving currentColor at style time, these can be removed.
     friend class CSSToStyleMap;
     friend class FilterOperationResolver;
     friend class StyleBuilderConverter;
     friend class StyleResolverState;
     friend class StyleResolver;
 protected:
 
     // non-inherited attributes
     DataRef<StyleBoxData> m_box;
     DataRef<StyleVisualData> visual;
     DataRef<StyleBackgroundData> m_background;
     DataRef<StyleSurroundData> surround;
     DataRef<StyleRareNonInheritedData> rareNonInheritedData;
 
     // inherited attributes
     DataRef<StyleRareInheritedData> rareInheritedData;
     DataRef<StyleInheritedData> inherited;
 
     // list of associated pseudo styles
     OwnPtr<PseudoStyleCache> m_cachedPseudoStyles;
 
-    DataRef<SVGLayoutStyle> m_svgStyle;
+    DataRef<SVGComputedStyle> m_svgStyle;
 
-// !START SYNC!: Keep this in sync with the copy constructor in LayoutStyle.cpp and implicitlyInherited() in StyleResolver.cpp
+// !START SYNC!: Keep this in sync with the copy constructor in ComputedStyle.cpp and implicitlyInherited() in StyleResolver.cpp
 
     // inherit
     struct InheritedFlags {
         bool operator==(const InheritedFlags& other) const
         {
             return (_empty_cells == other._empty_cells)
                 && (_caption_side == other._caption_side)
                 && (_list_style_type == other._list_style_type)
                 && (_list_style_position == other._list_style_position)
                 && (_visibility == other._visibility)
@@ skipping 78 matching lines @@
         unsigned overflowX : 3; // EOverflow
         unsigned overflowY : 3; // EOverflow
         unsigned verticalAlign : 4; // EVerticalAlign
         unsigned clear : 2; // EClear
         unsigned position : 3; // EPosition
         unsigned floating : 2; // EFloat
         unsigned tableLayout : 1; // ETableLayout
         unsigned unicodeBidi : 3; // EUnicodeBidi
 
         // This is set if we used viewport units when resolving a length.
-        // It is mutable so we can pass around const LayoutStyles to resolve lengths.
+        // It is mutable so we can pass around const ComputedStyles to resolve lengths.
         mutable unsigned hasViewportUnits : 1;
 
         // 32 bits
 
         unsigned pageBreakBefore : 2; // EPageBreak
         unsigned pageBreakAfter : 2; // EPageBreak
         unsigned pageBreakInside : 2; // EPageBreak
 
         unsigned styleType : 6; // PseudoId
         unsigned pseudoBits : 8;
         unsigned explicitInheritance : 1; // Explicitly inherits a non-inherited property
         unsigned unique : 1; // Style can not be shared.
 
         unsigned emptyState : 1;
 
         unsigned affectedByFocus : 1;
         unsigned affectedByHover : 1;
         unsigned affectedByActive : 1;
         unsigned affectedByDrag : 1;
 
         unsigned isLink : 1;
-        // If you add more style bits here, you will also need to update LayoutStyle::copyNonInheritedFromCached()
+        // If you add more style bits here, you will also need to update ComputedStyle::copyNonInheritedFromCached()
         // 62 bits
     } noninherited_flags;
 
 // !END SYNC!
 
 protected:
     void setBitDefaults()
     {
         inherited_flags._empty_cells = initialEmptyCells();
         inherited_flags._caption_side = initialCaptionSide();
@@ skipping 33 matching lines @@
         noninherited_flags.emptyState = false;
         noninherited_flags.hasViewportUnits = false;
         noninherited_flags.affectedByFocus = false;
         noninherited_flags.affectedByHover = false;
         noninherited_flags.affectedByActive = false;
         noninherited_flags.affectedByDrag = false;
         noninherited_flags.isLink = false;
     }
 
 private:
-    ALWAYS_INLINE LayoutStyle();
+    ALWAYS_INLINE ComputedStyle();
 
     enum InitialStyleTag {
         InitialStyle
     };
-    ALWAYS_INLINE explicit LayoutStyle(InitialStyleTag);
-    ALWAYS_INLINE LayoutStyle(const LayoutStyle&);
+    ALWAYS_INLINE explicit ComputedStyle(InitialStyleTag);
+    ALWAYS_INLINE ComputedStyle(const ComputedStyle&);
 
-    static PassRefPtr<LayoutStyle> createInitialStyle();
-    static inline LayoutStyle* initialStyle()
+    static PassRefPtr<ComputedStyle> createInitialStyle();
+    static inline ComputedStyle* initialStyle()
     {
-        DEFINE_STATIC_REF(LayoutStyle, s_initialStyle, (LayoutStyle::createInitialStyle()));
+        DEFINE_STATIC_REF(ComputedStyle, s_initialStyle, (ComputedStyle::createInitialStyle()));
         return s_initialStyle;
     }
 
 public:
-    static PassRefPtr<LayoutStyle> create();
-    static PassRefPtr<LayoutStyle> createAnonymousStyleWithDisplay(const LayoutStyle& parentStyle, EDisplay);
-    static PassRefPtr<LayoutStyle> clone(const LayoutStyle&);
+    static PassRefPtr<ComputedStyle> create();
+    static PassRefPtr<ComputedStyle> createAnonymousStyleWithDisplay(const ComputedStyle& parentStyle, EDisplay);
+    static PassRefPtr<ComputedStyle> clone(const ComputedStyle&);
 
     // Computes how the style change should be propagated down the tree.
-    static StyleRecalcChange stylePropagationDiff(const LayoutStyle* oldStyle, const LayoutStyle* newStyle);
+    static StyleRecalcChange stylePropagationDiff(const ComputedStyle* oldStyle, const ComputedStyle* newStyle);
 
-    static ItemPosition resolveAlignment(const LayoutStyle& parentStyle, const LayoutStyle& childStyle, ItemPosition resolvedAutoPositionForLayoutObject);
-    static ItemPosition resolveJustification(const LayoutStyle& parentStyle, const LayoutStyle& childStyle, ItemPosition resolvedAutoPositionForLayoutObject);
+    static ItemPosition resolveAlignment(const ComputedStyle& parentStyle, const ComputedStyle& childStyle, ItemPosition resolvedAutoPositionForLayoutObject);
+    static ItemPosition resolveJustification(const ComputedStyle& parentStyle, const ComputedStyle& childStyle, ItemPosition resolvedAutoPositionForLayoutObject);
 
-    StyleDifference visualInvalidationDiff(const LayoutStyle&) const;
+    StyleDifference visualInvalidationDiff(const ComputedStyle&) const;
 
     enum IsAtShadowBoundary {
         AtShadowBoundary,
         NotAtShadowBoundary,
     };
 
-    void inheritFrom(const LayoutStyle& inheritParent, IsAtShadowBoundary = NotAtShadowBoundary);
-    void copyNonInheritedFromCached(const LayoutStyle&);
+    void inheritFrom(const ComputedStyle& inheritParent, IsAtShadowBoundary = NotAtShadowBoundary);
+    void copyNonInheritedFromCached(const ComputedStyle&);
 
     PseudoId styleType() const { return static_cast<PseudoId>(noninherited_flags.styleType); }
     void setStyleType(PseudoId styleType) { noninherited_flags.styleType = styleType; }
 
-    LayoutStyle* getCachedPseudoStyle(PseudoId) const;
-    LayoutStyle* addCachedPseudoStyle(PassRefPtr<LayoutStyle>);
+    ComputedStyle* getCachedPseudoStyle(PseudoId) const;
+    ComputedStyle* addCachedPseudoStyle(PassRefPtr<ComputedStyle>);
     void removeCachedPseudoStyle(PseudoId);
 
     const PseudoStyleCache* cachedPseudoStyles() const { return m_cachedPseudoStyles.get(); }
 
     void setHasViewportUnits(bool hasViewportUnits = true) const { noninherited_flags.hasViewportUnits = hasViewportUnits; }
     bool hasViewportUnits() const { return noninherited_flags.hasViewportUnits; }
 
     bool affectedByFocus() const { return noninherited_flags.affectedByFocus; }
     bool affectedByHover() const { return noninherited_flags.affectedByHover; }
     bool affectedByActive() const { return noninherited_flags.affectedByActive; }
     bool affectedByDrag() const { return noninherited_flags.affectedByDrag; }
 
     void setAffectedByFocus() { noninherited_flags.affectedByFocus = true; }
     void setAffectedByHover() { noninherited_flags.affectedByHover = true; }
     void setAffectedByActive() { noninherited_flags.affectedByActive = true; }
     void setAffectedByDrag() { noninherited_flags.affectedByDrag = true; }
 
-    bool operator==(const LayoutStyle& other) const;
-    bool operator!=(const LayoutStyle& other) const { return !(*this == other); }
+    bool operator==(const ComputedStyle& other) const;
+    bool operator!=(const ComputedStyle& other) const { return !(*this == other); }
     bool isFloating() const { return noninherited_flags.floating != NoFloat; }
     bool hasMargin() const { return surround->margin.nonZero(); }
     bool hasBorder() const { return surround->border.hasBorder(); }
     bool hasPadding() const { return surround->padding.nonZero(); }
     bool hasMarginBeforeQuirk() const { return marginBefore().quirk(); }
     bool hasMarginAfterQuirk() const { return marginAfter().quirk(); }
 
     bool hasBackgroundImage() const { return m_background->background().hasImage(); }
     bool hasFixedBackgroundImage() const { return m_background->background().hasFixedImage(); }
 
@@ skipping 273 matching lines @@
     EListStylePosition listStylePosition() const { return static_cast<EListStylePosition>(inherited_flags._list_style_position); }
 
     const Length& marginTop() const { return surround->margin.top(); }
     const Length& marginBottom() const { return surround->margin.bottom(); }
     const Length& marginLeft() const { return surround->margin.left(); }
     const Length& marginRight() const { return surround->margin.right(); }
     const Length& marginBefore() const { return surround->margin.before(writingMode()); }
     const Length& marginAfter() const { return surround->margin.after(writingMode()); }
     const Length& marginStart() const { return surround->margin.start(writingMode(), direction()); }
     const Length& marginEnd() const { return surround->margin.end(writingMode(), direction()); }
-    const Length& marginStartUsing(const LayoutStyle* otherStyle) const { return surround->margin.start(otherStyle->writingMode(), otherStyle->direction()); }
-    const Length& marginEndUsing(const LayoutStyle* otherStyle) const { return surround->margin.end(otherStyle->writingMode(), otherStyle->direction()); }
-    const Length& marginBeforeUsing(const LayoutStyle* otherStyle) const { return surround->margin.before(otherStyle->writingMode()); }
-    const Length& marginAfterUsing(const LayoutStyle* otherStyle) const { return surround->margin.after(otherStyle->writingMode()); }
+    const Length& marginStartUsing(const ComputedStyle* otherStyle) const { return surround->margin.start(otherStyle->writingMode(), otherStyle->direction()); }
+    const Length& marginEndUsing(const ComputedStyle* otherStyle) const { return surround->margin.end(otherStyle->writingMode(), otherStyle->direction()); }
+    const Length& marginBeforeUsing(const ComputedStyle* otherStyle) const { return surround->margin.before(otherStyle->writingMode()); }
+    const Length& marginAfterUsing(const ComputedStyle* otherStyle) const { return surround->margin.after(otherStyle->writingMode()); }
 
     const LengthBox& paddingBox() const { return surround->padding; }
     const Length& paddingTop() const { return surround->padding.top(); }
     const Length& paddingBottom() const { return surround->padding.bottom(); }
     const Length& paddingLeft() const { return surround->padding.left(); }
     const Length& paddingRight() const { return surround->padding.right(); }
     const Length& paddingBefore() const { return surround->padding.before(writingMode()); }
     const Length& paddingAfter() const { return surround->padding.after(writingMode()); }
     const Length& paddingStart() const { return surround->padding.start(writingMode(), direction()); }
     const Length& paddingEnd() const { return surround->padding.end(writingMode(), direction()); }
@@ skipping 80 matching lines @@
 
     const GridPosition& gridColumnStart() const { return rareNonInheritedData->m_gridItem->m_gridColumnStart; }
     const GridPosition& gridColumnEnd() const { return rareNonInheritedData->m_gridItem->m_gridColumnEnd; }
     const GridPosition& gridRowStart() const { return rareNonInheritedData->m_gridItem->m_gridRowStart; }
     const GridPosition& gridRowEnd() const { return rareNonInheritedData->m_gridItem->m_gridRowEnd; }
 
     ShadowList* boxShadow() const { return rareNonInheritedData->m_boxShadow.get(); }
 
     EBoxDecorationBreak boxDecorationBreak() const { return m_box->boxDecorationBreak(); }
     StyleReflection* boxReflect() const { return rareNonInheritedData->m_boxReflect.get(); }
-    bool reflectionDataEquivalent(const LayoutStyle* otherStyle) const { return rareNonInheritedData->reflectionDataEquivalent(*otherStyle->rareNonInheritedData); }
+    bool reflectionDataEquivalent(const ComputedStyle* otherStyle) const { return rareNonInheritedData->reflectionDataEquivalent(*otherStyle->rareNonInheritedData); }
 
     // FIXME: reflections should belong to this helper function but they are currently handled
     // through their self-painting layers. So the layout code doesn't account for them.
     bool hasVisualOverflowingEffect() const { return boxShadow() || hasBorderImageOutsets() || hasOutline(); }
 
     EBoxSizing boxSizing() const { return m_box->boxSizing(); }
     EUserModify userModify() const { return static_cast<EUserModify>(rareInheritedData->userModify); }
     EUserDrag userDrag() const { return static_cast<EUserDrag>(rareNonInheritedData->userDrag); }
     EUserSelect userSelect() const { return static_cast<EUserSelect>(rareInheritedData->userSelect); }
     TextOverflow textOverflow() const { return static_cast<TextOverflow>(rareNonInheritedData->textOverflow); }
@@ skipping 19 matching lines @@
     bool hasAutoColumnWidth() const { return rareNonInheritedData->m_multiCol->m_autoWidth; }
     unsigned short columnCount() const { return rareNonInheritedData->m_multiCol->m_count; }
     bool hasAutoColumnCount() const { return rareNonInheritedData->m_multiCol->m_autoCount; }
     bool specifiesColumns() const { return !hasAutoColumnCount() || !hasAutoColumnWidth(); }
     ColumnFill columnFill() const { return static_cast<ColumnFill>(rareNonInheritedData->m_multiCol->m_fill); }
     float columnGap() const { return rareNonInheritedData->m_multiCol->m_gap; }
     bool hasNormalColumnGap() const { return rareNonInheritedData->m_multiCol->m_normalGap; }
     EBorderStyle columnRuleStyle() const { return rareNonInheritedData->m_multiCol->m_rule.style(); }
     unsigned short columnRuleWidth() const { return rareNonInheritedData->m_multiCol->ruleWidth(); }
     bool columnRuleIsTransparent() const { return rareNonInheritedData->m_multiCol->m_rule.isTransparent(); }
-    bool columnRuleEquivalent(const LayoutStyle* otherStyle) const;
+    bool columnRuleEquivalent(const ComputedStyle* otherStyle) const;
     ColumnSpan columnSpan() const { return static_cast<ColumnSpan>(rareNonInheritedData->m_multiCol->m_columnSpan); }
     EPageBreak columnBreakBefore() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakBefore); }
     EPageBreak columnBreakInside() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakInside); }
     EPageBreak columnBreakAfter() const { return static_cast<EPageBreak>(rareNonInheritedData->m_multiCol->m_breakAfter); }
     bool hasInlineTransform() const { return rareNonInheritedData->m_hasInlineTransform; }
     const TransformOperations& transform() const { return rareNonInheritedData->m_transform->m_operations; }
     const TransformOrigin& transformOrigin() const { return rareNonInheritedData->m_transform->m_origin; }
     const Length& transformOriginX() const { return transformOrigin().x(); }
     const Length& transformOriginY() const { return transformOrigin().y(); }
     float transformOriginZ() const { return transformOrigin().z(); }
     bool hasTransform() const { return hasTransformOperations() || hasMotionPath() || hasCurrentTransformAnimation(); }
-    bool transformDataEquivalent(const LayoutStyle& otherStyle) const { return rareNonInheritedData->m_transform == otherStyle.rareNonInheritedData->m_transform; }
+    bool transformDataEquivalent(const ComputedStyle& otherStyle) const { return rareNonInheritedData->m_transform == otherStyle.rareNonInheritedData->m_transform; }
 
     StyleMotionPath* motionPath() const { return rareNonInheritedData->m_transform->m_motion.m_path.get(); }
     bool hasMotionPath() const { return rareNonInheritedData->m_transform->m_motion.m_path; }
     const Length& motionOffset() const { return rareNonInheritedData->m_transform->m_motion.m_offset; }
     float motionRotation() const { return rareNonInheritedData->m_transform->m_motion.m_rotation; }
     MotionRotationType motionRotationType() const { return rareNonInheritedData->m_transform->m_motion.m_rotationType; }
 
     TextEmphasisFill textEmphasisFill() const { return static_cast<TextEmphasisFill>(rareInheritedData->textEmphasisFill); }
     TextEmphasisMark textEmphasisMark() const;
     const AtomicString& textEmphasisCustomMark() const { return rareInheritedData->textEmphasisCustomMark; }
@@ skipping 200 matching lines @@
     void setBorderTopStyle(EBorderStyle v) { SET_VAR(surround, border.m_top.m_style, v); }
     void setBorderTopColor(const StyleColor& v) { SET_BORDERVALUE_COLOR(surround, border.m_top, v); }
     void setBorderBottomWidth(unsigned v) { SET_VAR(surround, border.m_bottom.m_width, v); }
     void setBorderBottomStyle(EBorderStyle v) { SET_VAR(surround, border.m_bottom.m_style, v); }
     void setBorderBottomColor(const StyleColor& v) { SET_BORDERVALUE_COLOR(surround, border.m_bottom, v); }
 
     void setOutlineWidth(unsigned short v) { SET_VAR(m_background, m_outline.m_width, v); }
     void setOutlineStyleIsAuto(OutlineIsAuto isAuto) { SET_VAR(m_background, m_outline.m_isAuto, isAuto); }
     void setOutlineStyle(EBorderStyle v) { SET_VAR(m_background, m_outline.m_style, v); }
     void setOutlineColor(const StyleColor& v) { SET_BORDERVALUE_COLOR(m_background, m_outline, v); }
-    bool isOutlineEquivalent(const LayoutStyle* otherStyle) const
+    bool isOutlineEquivalent(const ComputedStyle* otherStyle) const
     {
         // No other style, so we don't have an outline then we consider them to be the same.
         if (!otherStyle)
             return !hasOutline();
         return m_background->outline().visuallyEqual(otherStyle->m_background->outline());
     }
-    void setOutlineFromStyle(const LayoutStyle& o)
+    void setOutlineFromStyle(const ComputedStyle& o)
     {
         ASSERT(!isOutlineEquivalent(&o));
         m_background.access()->m_outline = o.m_background->m_outline;
     }
 
     void setOverflowX(EOverflow v) { noninherited_flags.overflowX = v; }
     void setOverflowY(EOverflow v) { noninherited_flags.overflowY = v; }
     void setVisibility(EVisibility v) { inherited_flags._visibility = v; }
     void setVerticalAlign(EVerticalAlign v) { noninherited_flags.verticalAlign = v; }
     void setVerticalAlignLength(const Length& length) { setVerticalAlign(LENGTH); SET_VAR(m_box, m_verticalAlign, length); }
 
-    void setHasAutoClip() { SET_VAR(visual, hasAutoClip, true); SET_VAR(visual, clip, LayoutStyle::initialClip()); }
+    void setHasAutoClip() { SET_VAR(visual, hasAutoClip, true); SET_VAR(visual, clip, ComputedStyle::initialClip()); }
     void setClip(const LengthBox& box) { SET_VAR(visual, hasAutoClip, false); SET_VAR(visual, clip, box); }
 
     void setUnicodeBidi(EUnicodeBidi b) { noninherited_flags.unicodeBidi = b; }
 
     void setClear(EClear v) { noninherited_flags.clear = v; }
     void setTableLayout(ETableLayout v) { noninherited_flags.tableLayout = v; }
 
     bool setFontDescription(const FontDescription&);
 
     void setTextAutosizingMultiplier(float);
@@ skipping 195 matching lines @@
     void setColumnGap(float f) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_normalGap, false); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_gap, f); }
     void setHasNormalColumnGap() { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_normalGap, true); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_gap, 0); }
     void setColumnRuleColor(const StyleColor& c) { SET_BORDERVALUE_COLOR(rareNonInheritedData.access()->m_multiCol, m_rule, c); }
     void setColumnRuleStyle(EBorderStyle b) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.m_style, b); }
     void setColumnRuleWidth(unsigned short w) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_rule.m_width, w); }
     void setColumnSpan(ColumnSpan columnSpan) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_columnSpan, columnSpan); }
     void setColumnBreakBefore(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakBefore, p); }
     // For valid values of column-break-inside see http://www.w3.org/TR/css3-multicol/#break-before-break-after-break-inside
     void setColumnBreakInside(EPageBreak p) { ASSERT(p == PBAUTO || p == PBAVOID); SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakInside, p); }
     void setColumnBreakAfter(EPageBreak p) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_breakAfter, p); }
-    void inheritColumnPropertiesFrom(const LayoutStyle& parent) { rareNonInheritedData.access()->m_multiCol = parent.rareNonInheritedData->m_multiCol; }
+    void inheritColumnPropertiesFrom(const ComputedStyle& parent) { rareNonInheritedData.access()->m_multiCol = parent.rareNonInheritedData->m_multiCol; }
     void setHasInlineTransform(bool b) { SET_VAR(rareNonInheritedData, m_hasInlineTransform, b); }
     void setTransform(const TransformOperations& ops) { SET_VAR(rareNonInheritedData.access()->m_transform, m_operations, ops); }
     void setTransformOriginX(const Length& v) { setTransformOrigin(TransformOrigin(v, transformOriginY(), transformOriginZ())); }
     void setTransformOriginY(const Length& v) { setTransformOrigin(TransformOrigin(transformOriginX(), v, transformOriginZ())); }
     void setTransformOriginZ(float f) { setTransformOrigin(TransformOrigin(transformOriginX(), transformOriginY(), f)); }
     void setTransformOrigin(const TransformOrigin& o) { SET_VAR(rareNonInheritedData.access()->m_transform, m_origin, o); }
     void setSpeak(ESpeak s) { SET_VAR(rareInheritedData, speak, s); }
     void setTextCombine(TextCombine v) { SET_VAR(rareNonInheritedData, m_textCombine, v); }
     void setTextDecorationColor(const StyleColor& c) { SET_VAR(rareNonInheritedData, m_textDecorationColor, c); }
     void setTextEmphasisColor(const StyleColor& c) { SET_VAR_WITH_SETTER(rareInheritedData, textEmphasisColor, setTextEmphasisColor, c); }
@@ skipping 54 matching lines @@
     void setScrollBlocksOn(WebScrollBlocksOn b) { SET_VAR(rareNonInheritedData, m_scrollBlocksOn, b); }
 
     void setWillChangeProperties(const Vector<CSSPropertyID>& properties) { SET_VAR(rareNonInheritedData.access()->m_willChange, m_properties, properties); }
     void setWillChangeContents(bool b) { SET_VAR(rareNonInheritedData.access()->m_willChange, m_contents, b); }
     void setWillChangeScrollPosition(bool b) { SET_VAR(rareNonInheritedData.access()->m_willChange, m_scrollPosition, b); }
     void setSubtreeWillChangeContents(bool b) { SET_VAR(rareInheritedData, m_subtreeWillChangeContents, b); }
 
     bool requiresAcceleratedCompositingForExternalReasons(bool b) { return rareNonInheritedData->m_requiresAcceleratedCompositingForExternalReasons; }
     void setRequiresAcceleratedCompositingForExternalReasons(bool b) { SET_VAR(rareNonInheritedData, m_requiresAcceleratedCompositingForExternalReasons, b); }
 
-    const SVGLayoutStyle& svgStyle() const { return *m_svgStyle.get(); }
-    SVGLayoutStyle& accessSVGStyle() { return *m_svgStyle.access(); }
+    const SVGComputedStyle& svgStyle() const { return *m_svgStyle.get(); }
+    SVGComputedStyle& accessSVGStyle() { return *m_svgStyle.access(); }
 
     const SVGPaintType& fillPaintType() const { return svgStyle().fillPaintType(); }
     Color fillPaintColor() const { return svgStyle().fillPaintColor(); }
     float fillOpacity() const { return svgStyle().fillOpacity(); }
     void setFillOpacity(float f) { accessSVGStyle().setFillOpacity(f); }
 
     const SVGPaintType& strokePaintType() const { return svgStyle().strokePaintType(); }
     Color strokePaintColor() const { return svgStyle().strokePaintColor(); }
     float strokeOpacity() const { return svgStyle().strokeOpacity(); }
     void setStrokeOpacity(float f) { accessSVGStyle().setStrokeOpacity(f); }
@@ skipping 53 matching lines @@
     float shapeImageThreshold() const { return rareNonInheritedData->m_shapeImageThreshold; }
     void setShapeImageThreshold(float shapeImageThreshold)
     {
         float clampedShapeImageThreshold = clampTo<float>(shapeImageThreshold, 0, 1);
         SET_VAR(rareNonInheritedData, m_shapeImageThreshold, clampedShapeImageThreshold);
     }
     static float initialShapeImageThreshold() { return 0; }
 
     bool hasContent() const { return contentData(); }
     const ContentData* contentData() const { return rareNonInheritedData->m_content.get(); }
-    bool contentDataEquivalent(const LayoutStyle* otherStyle) const { return const_cast<LayoutStyle*>(this)->rareNonInheritedData->contentDataEquivalent(*const_cast<LayoutStyle*>(otherStyle)->rareNonInheritedData); }
+    bool contentDataEquivalent(const ComputedStyle* otherStyle) const { return const_cast<ComputedStyle*>(this)->rareNonInheritedData->contentDataEquivalent(*const_cast<ComputedStyle*>(otherStyle)->rareNonInheritedData); }
     void clearContent();
     void setContent(const String&, bool add = false);
     void setContent(PassRefPtr<StyleImage>, bool add = false);
     void setContent(PassOwnPtr<CounterContent>, bool add = false);
     void setContent(QuoteType, bool add = false);
 
     const CounterDirectiveMap* counterDirectives() const;
     CounterDirectiveMap& accessCounterDirectives();
     const CounterDirectives getCounterDirectives(const AtomicString& identifier) const;
     void clearIncrementDirectives();
     void clearResetDirectives();
 
     QuotesData* quotes() const { return rareInheritedData->quotes.get(); }
     void setQuotes(PassRefPtr<QuotesData>);
 
     const AtomicString& hyphenString() const;
 
-    bool inheritedNotEqual(const LayoutStyle&) const;
-    bool inheritedDataShared(const LayoutStyle&) const;
+    bool inheritedNotEqual(const ComputedStyle&) const;
+    bool inheritedDataShared(const ComputedStyle&) const;
 
     bool isDisplayReplacedType() const { return isDisplayReplacedType(display()); }
     bool isDisplayInlineType() const { return isDisplayInlineType(display()); }
     bool isOriginalDisplayInlineType() const { return isDisplayInlineType(originalDisplay()); }
     bool isDisplayFlexibleOrGridBox() const { return isDisplayFlexibleBox(display()) || isDisplayGridBox(display()); }
     bool isDisplayFlexibleBox() const { return isDisplayFlexibleBox(display()); }
 
 
     bool setWritingMode(WritingMode v)
     {
@@ skipping 222 matching lines @@
     void setVisitedLinkBorderRightColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkBorderRightColor, v); }
     void setVisitedLinkBorderBottomColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkBorderBottomColor, v); }
     void setVisitedLinkBorderTopColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkBorderTopColor, v); }
     void setVisitedLinkOutlineColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkOutlineColor, v); }
     void setVisitedLinkColumnRuleColor(const StyleColor& v) { SET_VAR(rareNonInheritedData.access()->m_multiCol, m_visitedLinkColumnRuleColor, v); }
     void setVisitedLinkTextDecorationColor(const StyleColor& v) { SET_VAR(rareNonInheritedData, m_visitedLinkTextDecorationColor, v); }
     void setVisitedLinkTextEmphasisColor(const StyleColor& v) { SET_VAR_WITH_SETTER(rareInheritedData, visitedLinkTextEmphasisColor, setVisitedLinkTextEmphasisColor, v); }
     void setVisitedLinkTextFillColor(const StyleColor& v) { SET_VAR_WITH_SETTER(rareInheritedData, visitedLinkTextFillColor, setVisitedLinkTextFillColor, v); }
     void setVisitedLinkTextStrokeColor(const StyleColor& v) { SET_VAR_WITH_SETTER(rareInheritedData, visitedLinkTextStrokeColor, setVisitedLinkTextStrokeColor, v); }
 
-    void inheritUnicodeBidiFrom(const LayoutStyle& parent) { noninherited_flags.unicodeBidi = parent.noninherited_flags.unicodeBidi; }
+    void inheritUnicodeBidiFrom(const ComputedStyle& parent) { noninherited_flags.unicodeBidi = parent.noninherited_flags.unicodeBidi; }
 
     bool isDisplayFlexibleBox(EDisplay display) const
     {
         return display == FLEX || display == INLINE_FLEX;
     }
 
     bool isDisplayGridBox(EDisplay display) const
     {
         return display == GRID || display == INLINE_GRID;
     }
@@ skipping 40 matching lines @@
 
     Color stopColor() const { return svgStyle().stopColor(); }
     Color floodColor() const { return svgStyle().floodColor(); }
     Color lightingColor() const { return svgStyle().lightingColor(); }
 
     void appendContent(PassOwnPtr<ContentData>);
     void addAppliedTextDecoration(const AppliedTextDecoration&);
     bool hasTransformOperations() const { return !rareNonInheritedData->m_transform->m_operations.operations().isEmpty(); }
     void applyMotionPathTransform(TransformationMatrix&) const;
 
-    bool diffNeedsFullLayoutAndPaintInvalidation(const LayoutStyle& other) const;
-    bool diffNeedsFullLayout(const LayoutStyle& other) const;
-    bool diffNeedsPaintInvalidationLayer(const LayoutStyle& other) const;
-    bool diffNeedsPaintInvalidationObject(const LayoutStyle& other) const;
-    void updatePropertySpecificDifferences(const LayoutStyle& other, StyleDifference&) const;
+    bool diffNeedsFullLayoutAndPaintInvalidation(const ComputedStyle& other) const;
+    bool diffNeedsFullLayout(const ComputedStyle& other) const;
+    bool diffNeedsPaintInvalidationLayer(const ComputedStyle& other) const;
+    bool diffNeedsPaintInvalidationObject(const ComputedStyle& other) const;
+    void updatePropertySpecificDifferences(const ComputedStyle& other, StyleDifference&) const;
 };
 
 // FIXME: Reduce/remove the dependency on zoom adjusted int values.
 // The float or LayoutUnit versions of layout values should be used.
 inline int adjustForAbsoluteZoom(int value, float zoomFactor)
 {
     if (zoomFactor == 1)
         return value;
     // Needed because computeLengthInt truncates (rather than rounds) when scaling up.
     float fvalue = value;
     if (zoomFactor > 1) {
         if (value < 0)
             fvalue -= 0.5f;
         else
             fvalue += 0.5f;
     }
 
     return roundForImpreciseConversion<int>(fvalue / zoomFactor);
 }
 
-inline int adjustForAbsoluteZoom(int value, const LayoutStyle* style)
+inline int adjustForAbsoluteZoom(int value, const ComputedStyle* style)
 {
     return adjustForAbsoluteZoom(value, style->effectiveZoom());
 }
 
-inline float adjustFloatForAbsoluteZoom(float value, const LayoutStyle& style)
+inline float adjustFloatForAbsoluteZoom(float value, const ComputedStyle& style)
 {
     return value / style.effectiveZoom();
 }
 
-inline double adjustDoubleForAbsoluteZoom(double value, const LayoutStyle& style)
+inline double adjustDoubleForAbsoluteZoom(double value, const ComputedStyle& style)
 {
     return value / style.effectiveZoom();
 }
 
-inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const LayoutStyle& style)
+inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value, const ComputedStyle& style)
 {
     return value / style.effectiveZoom();
 }
 
 inline double adjustScrollForAbsoluteZoom(double scrollOffset, float zoomFactor)
 {
     return scrollOffset / zoomFactor;
 }
 
-inline double adjustScrollForAbsoluteZoom(double scrollOffset, const LayoutStyle& style)
+inline double adjustScrollForAbsoluteZoom(double scrollOffset, const ComputedStyle& style)
 {
     return adjustScrollForAbsoluteZoom(scrollOffset, style.effectiveZoom());
 }
 
-inline bool LayoutStyle::setZoom(float f)
+inline bool ComputedStyle::setZoom(float f)
 {
     if (compareEqual(visual->m_zoom, f))
         return false;
     visual.access()->m_zoom = f;
     setEffectiveZoom(effectiveZoom() * zoom());
     return true;
 }
 
-inline bool LayoutStyle::setEffectiveZoom(float f)
+inline bool ComputedStyle::setEffectiveZoom(float f)
 {
     if (compareEqual(rareInheritedData->m_effectiveZoom, f))
         return false;
     rareInheritedData.access()->m_effectiveZoom = f;
     return true;
 }
 
-inline bool LayoutStyle::isSharable() const
+inline bool ComputedStyle::isSharable() const
 {
     if (unique())
         return false;
     if (hasUniquePseudoStyle())
         return false;
     return true;
 }
 
-inline bool LayoutStyle::setTextOrientation(TextOrientation textOrientation)
+inline bool ComputedStyle::setTextOrientation(TextOrientation textOrientation)
 {
     if (compareEqual(rareInheritedData->m_textOrientation, textOrientation))
         return false;
 
     rareInheritedData.access()->m_textOrientation = textOrientation;
     return true;
 }
 
-inline bool LayoutStyle::hasAnyPublicPseudoStyles() const
+inline bool ComputedStyle::hasAnyPublicPseudoStyles() const
 {
     return PUBLIC_PSEUDOID_MASK & noninherited_flags.pseudoBits;
 }
 
-inline bool LayoutStyle::hasPseudoStyle(PseudoId pseudo) const
+inline bool ComputedStyle::hasPseudoStyle(PseudoId pseudo) const
 {
     ASSERT(pseudo > NOPSEUDO);
     ASSERT(pseudo < FIRST_INTERNAL_PSEUDOID);
     return (1 << (pseudo - 1)) & noninherited_flags.pseudoBits;
 }
 
-inline void LayoutStyle::setHasPseudoStyle(PseudoId pseudo)
+inline void ComputedStyle::setHasPseudoStyle(PseudoId pseudo)
 {
     ASSERT(pseudo > NOPSEUDO);
     ASSERT(pseudo < FIRST_INTERNAL_PSEUDOID);
     noninherited_flags.pseudoBits |= 1 << (pseudo - 1);
 }
 
-inline bool LayoutStyle::hasPseudoElementStyle() const
+inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return noninherited_flags.pseudoBits & PSEUDO_ELEMENT_MASK;
 }
 
 } // namespace blink
 
-#endif // LayoutStyle_h
+#endif // ComputedStyle_h