Rename enums/functions that collide in chromium style in core/style/

third_party/WebKit/Source/core/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
@@ skipping 468 matching lines @@
 
     EDisplay display() const { return static_cast<EDisplay>(noninherited_flags.effectiveDisplay); }
     EDisplay originalDisplay() const { return static_cast<EDisplay>(noninherited_flags.originalDisplay); }
 
     const Length& left() const { return surround->offset.left(); }
     const Length& right() const { return surround->offset.right(); }
     const Length& top() const { return surround->offset.top(); }
     const Length& bottom() const { return surround->offset.bottom(); }
 
     // Accessors for positioned object edges that take into account writing mode.
-    const Length& logicalLeft() const { return surround->offset.logicalLeft(writingMode()); }
-    const Length& logicalRight() const { return surround->offset.logicalRight(writingMode()); }
-    const Length& logicalTop() const { return surround->offset.before(writingMode()); }
-    const Length& logicalBottom() const { return surround->offset.after(writingMode()); }
+    const Length& logicalLeft() const { return surround->offset.logicalLeft(getWritingMode()); }
+    const Length& logicalRight() const { return surround->offset.logicalRight(getWritingMode()); }
+    const Length& logicalTop() const { return surround->offset.before(getWritingMode()); }
+    const Length& logicalBottom() const { return surround->offset.after(getWritingMode()); }
 
     // Whether or not a positioned element requires normal flow x/y to be computed
     // to determine its position.
     bool hasAutoLeftAndRight() const { return left().isAuto() && right().isAuto(); }
     bool hasAutoTopAndBottom() const { return top().isAuto() && bottom().isAuto(); }
     bool hasStaticInlinePosition(bool horizontal) const { return horizontal ? hasAutoLeftAndRight() : hasAutoTopAndBottom(); }
     bool hasStaticBlockPosition(bool horizontal) const { return horizontal ? hasAutoTopAndBottom() : hasAutoLeftAndRight(); }
 
     EPosition position() const { return static_cast<EPosition>(noninherited_flags.position); }
     bool hasOutOfFlowPosition() const { return position() == AbsolutePosition || position() == FixedPosition; }
@@ skipping 96 matching lines @@
     float computedFontSize() const;
     int fontSize() const;
     float fontSizeAdjust() const;
     bool hasFontSizeAdjust() const;
     FontWeight fontWeight() const;
     FontStretch fontStretch() const;
 
     float textAutosizingMultiplier() const { return inherited->textAutosizingMultiplier; }
 
     const Length& textIndent() const { return rareInheritedData->indent; }
-    TextIndentLine textIndentLine() const { return static_cast<TextIndentLine>(rareInheritedData->m_textIndentLine); }
-    TextIndentType textIndentType() const { return static_cast<TextIndentType>(rareInheritedData->m_textIndentType); }
+    TextIndentLine getTextIndentLine() const { return static_cast<TextIndentLine>(rareInheritedData->m_textIndentLine); }
+    TextIndentType getTextIndentType() const { return static_cast<TextIndentType>(rareInheritedData->m_textIndentType); }
     ETextAlign textAlign() const { return static_cast<ETextAlign>(inherited_flags._text_align); }
-    TextAlignLast textAlignLast() const { return static_cast<TextAlignLast>(rareInheritedData->m_textAlignLast); }
-    TextJustify textJustify() const { return static_cast<TextJustify>(rareInheritedData->m_textJustify); }
+    TextAlignLast getTextAlignLast() const { return static_cast<TextAlignLast>(rareInheritedData->m_textAlignLast); }
+    TextJustify getTextJustify() const { return static_cast<TextJustify>(rareInheritedData->m_textJustify); }
     ETextTransform textTransform() const { return static_cast<ETextTransform>(inherited_flags._text_transform); }
     TextDecoration textDecorationsInEffect() const;
     const Vector<AppliedTextDecoration>& appliedTextDecorations() const;
-    TextDecoration textDecoration() const { return static_cast<TextDecoration>(visual->textDecoration); }
-    TextUnderlinePosition textUnderlinePosition() const { return static_cast<TextUnderlinePosition>(rareInheritedData->m_textUnderlinePosition); }
-    TextDecorationStyle textDecorationStyle() const { return static_cast<TextDecorationStyle>(rareNonInheritedData->m_textDecorationStyle); }
+    TextDecoration getTextDecoration() const { return static_cast<TextDecoration>(visual->textDecoration); }
+    TextUnderlinePosition getTextUnderlinePosition() const { return static_cast<TextUnderlinePosition>(rareInheritedData->m_textUnderlinePosition); }
+    TextDecorationStyle getTextDecorationStyle() const { return static_cast<TextDecorationStyle>(rareNonInheritedData->m_textDecorationStyle); }
     float wordSpacing() const;
     float letterSpacing() const;
     StyleVariableData* variables() const;
 
     void setVariable(const AtomicString&, PassRefPtr<CSSVariableData>);
     void removeVariable(const AtomicString&);
 
     float zoom() const { return visual->m_zoom; }
     float effectiveZoom() const { return rareInheritedData->m_effectiveZoom; }
 
@@ skipping 46 matching lines @@
         case '\t':
             return collapseWhiteSpace();
         case '\n':
             return !preserveNewline();
         }
         return false;
     }
 
     bool breakOnlyAfterWhiteSpace() const
     {
-        return whiteSpace() == PRE_WRAP || lineBreak() == LineBreakAfterWhiteSpace;
+        return whiteSpace() == PRE_WRAP || getLineBreak() == LineBreakAfterWhiteSpace;
     }
 
     bool breakWords() const
     {
         return (wordBreak() == BreakWordBreak || overflowWrap() == BreakOverflowWrap)
             && whiteSpace() != PRE && whiteSpace() != NOWRAP;
     }
 
     EFillBox backgroundClip() const { return static_cast<EFillBox>(m_background->background().clip()); }
     FillLayer& accessBackgroundLayers() { return m_background.access()->m_background; }
@@ skipping 17 matching lines @@
     ECaptionSide captionSide() const { return static_cast<ECaptionSide>(inherited_flags._caption_side); }
 
     EListStyleType listStyleType() const { return static_cast<EListStyleType>(inherited_flags._list_style_type); }
     StyleImage* listStyleImage() const;
     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& marginOver() const { return surround->margin.over(writingMode()); }
-    const Length& marginUnder() const { return surround->margin.under(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 Length& marginBefore() const { return surround->margin.before(getWritingMode()); }
+    const Length& marginAfter() const { return surround->margin.after(getWritingMode()); }
+    const Length& marginStart() const { return surround->margin.start(getWritingMode(), direction()); }
+    const Length& marginEnd() const { return surround->margin.end(getWritingMode(), direction()); }
+    const Length& marginOver() const { return surround->margin.over(getWritingMode()); }
+    const Length& marginUnder() const { return surround->margin.under(getWritingMode()); }
+    const Length& marginStartUsing(const ComputedStyle* otherStyle) const { return surround->margin.start(otherStyle->getWritingMode(), otherStyle->direction()); }
+    const Length& marginEndUsing(const ComputedStyle* otherStyle) const { return surround->margin.end(otherStyle->getWritingMode(), otherStyle->direction()); }
+    const Length& marginBeforeUsing(const ComputedStyle* otherStyle) const { return surround->margin.before(otherStyle->getWritingMode()); }
+    const Length& marginAfterUsing(const ComputedStyle* otherStyle) const { return surround->margin.after(otherStyle->getWritingMode()); }
 
     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()); }
-    const Length& paddingOver() const { return surround->padding.over(writingMode()); }
-    const Length& paddingUnder() const { return surround->padding.under(writingMode()); }
+    const Length& paddingBefore() const { return surround->padding.before(getWritingMode()); }
+    const Length& paddingAfter() const { return surround->padding.after(getWritingMode()); }
+    const Length& paddingStart() const { return surround->padding.start(getWritingMode(), direction()); }
+    const Length& paddingEnd() const { return surround->padding.end(getWritingMode(), direction()); }
+    const Length& paddingOver() const { return surround->padding.over(getWritingMode()); }
+    const Length& paddingUnder() const { return surround->padding.under(getWritingMode()); }
 
     ECursor cursor() const { return static_cast<ECursor>(inherited_flags._cursor_style); }
     CursorList* cursors() const { return rareInheritedData->cursorData.get(); }
 
     EInsideLink insideLink() const { return static_cast<EInsideLink>(inherited_flags._insideLink); }
     bool isLink() const { return noninherited_flags.isLink; }
 
     short widows() const { return rareInheritedData->widows; }
     short orphans() const { return rareInheritedData->orphans; }
     bool hasAutoWidows() const { return rareInheritedData->widows == 1; }
@@ skipping 59 matching lines @@
 
     const Vector<GridTrackSize>& gridTemplateColumns() const { return rareNonInheritedData->m_grid->m_gridTemplateColumns; }
     const Vector<GridTrackSize>& gridTemplateRows() const { return rareNonInheritedData->m_grid->m_gridTemplateRows; }
     const NamedGridLinesMap& namedGridColumnLines() const { return rareNonInheritedData->m_grid->m_namedGridColumnLines; }
     const NamedGridLinesMap& namedGridRowLines() const { return rareNonInheritedData->m_grid->m_namedGridRowLines; }
     const OrderedNamedGridLines& orderedNamedGridColumnLines() const { return rareNonInheritedData->m_grid->m_orderedNamedGridColumnLines; }
     const OrderedNamedGridLines& orderedNamedGridRowLines() const { return rareNonInheritedData->m_grid->m_orderedNamedGridRowLines; }
     const NamedGridAreaMap& namedGridArea() const { return rareNonInheritedData->m_grid->m_namedGridArea; }
     size_t namedGridAreaRowCount() const { return rareNonInheritedData->m_grid->m_namedGridAreaRowCount; }
     size_t namedGridAreaColumnCount() const { return rareNonInheritedData->m_grid->m_namedGridAreaColumnCount; }
-    GridAutoFlow gridAutoFlow() const { return static_cast<GridAutoFlow>(rareNonInheritedData->m_grid->m_gridAutoFlow); }
+    GridAutoFlow getGridAutoFlow() const { return static_cast<GridAutoFlow>(rareNonInheritedData->m_grid->m_gridAutoFlow); }
     bool isGridAutoFlowDirectionRow() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowDirectionRow) == InternalAutoFlowDirectionRow; }
     bool isGridAutoFlowDirectionColumn() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowDirectionColumn) == InternalAutoFlowDirectionColumn; }
     bool isGridAutoFlowAlgorithmSparse() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowAlgorithmSparse) == InternalAutoFlowAlgorithmSparse; }
     bool isGridAutoFlowAlgorithmDense() const { return (rareNonInheritedData->m_grid->m_gridAutoFlow & InternalAutoFlowAlgorithmDense) == InternalAutoFlowAlgorithmDense; }
     const GridTrackSize& gridAutoColumns() const { return rareNonInheritedData->m_grid->m_gridAutoColumns; }
     const GridTrackSize& gridAutoRows() const { return rareNonInheritedData->m_grid->m_gridAutoRows; }
     const Length& gridColumnGap() const { return rareNonInheritedData->m_grid->m_gridColumnGap; }
     const Length& gridRowGap() const { return rareNonInheritedData->m_grid->m_gridRowGap; }
 
     const GridPosition& gridColumnStart() const { return rareNonInheritedData->m_gridItem->m_gridColumnStart; }
@@ skipping 12 matching lines @@
     bool hasVisualOverflowingEffect() const { return boxShadow() || hasBorderImageOutsets() || hasOutline(); }
 
     Containment contain() const { return static_cast<Containment>(rareNonInheritedData->m_contain); }
     bool containsPaint() const { return rareNonInheritedData->m_contain & ContainsPaint; }
     bool containsStyle() const { return rareNonInheritedData->m_contain & ContainsStyle; }
 
     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); }
+    TextOverflow getTextOverflow() const { return static_cast<TextOverflow>(rareNonInheritedData->textOverflow); }
     EMarginCollapse marginBeforeCollapse() const { return static_cast<EMarginCollapse>(rareNonInheritedData->marginBeforeCollapse); }
     EMarginCollapse marginAfterCollapse() const { return static_cast<EMarginCollapse>(rareNonInheritedData->marginAfterCollapse); }
     EWordBreak wordBreak() const { return static_cast<EWordBreak>(rareInheritedData->wordBreak); }
     EOverflowWrap overflowWrap() const { return static_cast<EOverflowWrap>(rareInheritedData->overflowWrap); }
-    LineBreak lineBreak() const { return static_cast<LineBreak>(rareInheritedData->lineBreak); }
+    LineBreak getLineBreak() const { return static_cast<LineBreak>(rareInheritedData->lineBreak); }
     const AtomicString& highlight() const { return rareInheritedData->highlight; }
     const AtomicString& hyphenationString() const { return rareInheritedData->hyphenationString; }
     const AtomicString& locale() const { return fontDescription().locale(false); }
     EResize resize() const { return static_cast<EResize>(rareNonInheritedData->m_resize); }
     bool hasInlinePaginationAxis() const
     {
         // If the pagination axis is parallel with the writing mode inline axis, columns may be laid
         // out along the inline axis, just like for regular multicol. Otherwise, we need to lay out
         // along the block axis.
         if (isOverflowPaged())
             return (overflowY() == OPAGEDX) == isHorizontalWritingMode();
         return false;
     }
     float columnWidth() const { return rareNonInheritedData->m_multiCol->m_width; }
     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); }
+    ColumnFill getColumnFill() 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 ComputedStyle* otherStyle) const;
-    ColumnSpan columnSpan() const { return static_cast<ColumnSpan>(rareNonInheritedData->m_multiCol->m_columnSpan); }
+    ColumnSpan getColumnSpan() const { return static_cast<ColumnSpan>(rareNonInheritedData->m_multiCol->m_columnSpan); }
     bool hasInlineTransform() const { return rareNonInheritedData->m_hasInlineTransform; }
     bool hasCompositorProxy() const { return rareNonInheritedData->m_hasCompositorProxy; }
     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(); }
     TranslateTransformOperation* translate() const { return rareNonInheritedData->m_transform->m_translate.get(); }
     RotateTransformOperation* rotate() const { return rareNonInheritedData->m_transform->m_rotate.get(); }
     ScaleTransformOperation* scale() const { return rareNonInheritedData->m_transform->m_scale.get(); }
     float transformOriginZ() const { return transformOrigin().z(); }
     bool has3DTransform() const { return rareNonInheritedData->m_transform->has3DTransform(); }
     bool hasTransform() const { return hasTransformOperations() || hasMotionPath() || hasCurrentTransformAnimation() || translate() || rotate() || scale(); }
     bool hasTransformOperations() const { return !rareNonInheritedData->m_transform->m_operations.operations().isEmpty(); }
     bool transformDataEquivalent(const ComputedStyle& otherStyle) const { return rareNonInheritedData->m_transform == otherStyle.rareNonInheritedData->m_transform; }
 
     StylePath* 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; }
     const StyleMotionRotation& motionRotation() const { return rareNonInheritedData->m_transform->m_motion.m_rotation; }
 
-    TextEmphasisFill textEmphasisFill() const { return static_cast<TextEmphasisFill>(rareInheritedData->textEmphasisFill); }
-    TextEmphasisMark textEmphasisMark() const;
+    TextEmphasisFill getTextEmphasisFill() const { return static_cast<TextEmphasisFill>(rareInheritedData->textEmphasisFill); }
+    TextEmphasisMark getTextEmphasisMark() const;
     const AtomicString& textEmphasisCustomMark() const { return rareInheritedData->textEmphasisCustomMark; }
-    TextEmphasisPosition textEmphasisPosition() const { return static_cast<TextEmphasisPosition>(rareInheritedData->textEmphasisPosition); }
+    TextEmphasisPosition getTextEmphasisPosition() const { return static_cast<TextEmphasisPosition>(rareInheritedData->textEmphasisPosition); }
     const AtomicString& textEmphasisMarkString() const;
 
-    RubyPosition rubyPosition() const { return static_cast<RubyPosition>(rareInheritedData->m_rubyPosition); }
+    RubyPosition getRubyPosition() const { return static_cast<RubyPosition>(rareInheritedData->m_rubyPosition); }
 
-    TextOrientation textOrientation() const { return static_cast<TextOrientation>(rareInheritedData->m_textOrientation); }
+    TextOrientation getTextOrientation() const { return static_cast<TextOrientation>(rareInheritedData->m_textOrientation); }
 
-    ObjectFit objectFit() const { return static_cast<ObjectFit>(rareNonInheritedData->m_objectFit); }
+    ObjectFit getObjectFit() const { return static_cast<ObjectFit>(rareNonInheritedData->m_objectFit); }
     LengthPoint objectPosition() const { return rareNonInheritedData->m_objectPosition; }
 
     // Return true if any transform related property (currently transform/motionPath, transformStyle3D, perspective,
     // or will-change:transform) indicates that we are transforming. will-change:transform should result in
     // the same rendering behavior as having a transform, including the creation of a containing block
     // for fixed position descendants.
     bool hasTransformRelatedProperty() const { return hasTransform() || preserves3D() || hasPerspective() || hasWillChangeTransformHint(); }
 
     enum ApplyTransformOrigin { IncludeTransformOrigin, ExcludeTransformOrigin };
     enum ApplyMotionPath { IncludeMotionPath, ExcludeMotionPath };
     enum ApplyIndependentTransformProperties { IncludeIndependentTransformProperties , ExcludeIndependentTransformProperties };
     void applyTransform(TransformationMatrix&, const LayoutSize& borderBoxSize, ApplyTransformOrigin, ApplyMotionPath, ApplyIndependentTransformProperties) const;
     void applyTransform(TransformationMatrix&, const FloatRect& boundingBox, ApplyTransformOrigin, ApplyMotionPath, ApplyIndependentTransformProperties) const;
     bool hasMask() const { return rareNonInheritedData->m_mask.hasImage() || rareNonInheritedData->m_maskBoxImage.hasImage(); }
 
-    TextCombine textCombine() const { return static_cast<TextCombine>(rareInheritedData->m_textCombine); }
-    bool hasTextCombine() const { return textCombine() != TextCombineNone; }
+    TextCombine getTextCombine() const { return static_cast<TextCombine>(rareInheritedData->m_textCombine); }
+    bool hasTextCombine() const { return getTextCombine() != TextCombineNone; }
 
     uint8_t snapHeightPosition() const { return rareInheritedData->m_snapHeightPosition; }
     uint8_t snapHeightUnit() const { return rareInheritedData->m_snapHeightUnit; }
 
-    TabSize tabSize() const { return rareInheritedData->m_tabSize; }
+    TabSize getTabSize() const { return rareInheritedData->m_tabSize; }
 
     RespectImageOrientationEnum respectImageOrientation() const { return static_cast<RespectImageOrientationEnum>(rareInheritedData->m_respectImageOrientation); }
 
     // End CSS3 Getters
 
     // Apple-specific property getter methods
     EPointerEvents pointerEvents() const { return static_cast<EPointerEvents>(inherited_flags._pointerEvents); }
     const CSSAnimationData* animations() const { return rareNonInheritedData->m_animations.get(); }
     const CSSTransitionData* transitions() const { return rareNonInheritedData->m_transitions.get(); }
 
     CSSAnimationData& accessAnimations();
     CSSTransitionData& accessTransitions();
 
     ETransformStyle3D transformStyle3D() const { return static_cast<ETransformStyle3D>(rareNonInheritedData->m_transformStyle3D); }
     bool preserves3D() const { return rareNonInheritedData->m_transformStyle3D == TransformStyle3DPreserve3D; }
 
     EBackfaceVisibility backfaceVisibility() const { return static_cast<EBackfaceVisibility>(rareNonInheritedData->m_backfaceVisibility); }
     float perspective() const { return rareNonInheritedData->m_perspective; }
     bool hasPerspective() const { return rareNonInheritedData->m_perspective > 0; }
     const LengthPoint& perspectiveOrigin() const { return rareNonInheritedData->m_perspectiveOrigin; }
     const Length& perspectiveOriginX() const { return perspectiveOrigin().x(); }
     const Length& perspectiveOriginY() const { return perspectiveOrigin().y(); }
     const FloatSize& pageSize() const { return rareNonInheritedData->m_pageSize; }
-    PageSizeType pageSizeType() const { return static_cast<PageSizeType>(rareNonInheritedData->m_pageSizeType); }
+    PageSizeType getPageSizeType() const { return static_cast<PageSizeType>(rareNonInheritedData->m_pageSizeType); }
 
     bool hasCurrentOpacityAnimation() const { return rareNonInheritedData->m_hasCurrentOpacityAnimation; }
     bool hasCurrentTransformAnimation() const { return rareNonInheritedData->m_hasCurrentTransformAnimation; }
     bool hasCurrentFilterAnimation() const { return rareNonInheritedData->m_hasCurrentFilterAnimation; }
     bool hasCurrentBackdropFilterAnimation() const { return rareNonInheritedData->m_hasCurrentBackdropFilterAnimation; }
     bool shouldCompositeForCurrentAnimations() const { return hasCurrentOpacityAnimation() || hasCurrentTransformAnimation() || hasCurrentFilterAnimation() || hasCurrentBackdropFilterAnimation(); }
 
     bool isRunningOpacityAnimationOnCompositor() const { return rareNonInheritedData->m_runningOpacityAnimationOnCompositor; }
     bool isRunningTransformAnimationOnCompositor() const { return rareNonInheritedData->m_runningTransformAnimationOnCompositor; }
     bool isRunningFilterAnimationOnCompositor() const { return rareNonInheritedData->m_runningFilterAnimationOnCompositor; }
     bool isRunningBackdropFilterAnimationOnCompositor() const { return rareNonInheritedData->m_runningBackdropFilterAnimationOnCompositor; }
     bool isRunningAnimationOnCompositor() const { return isRunningOpacityAnimationOnCompositor() || isRunningTransformAnimationOnCompositor() || isRunningFilterAnimationOnCompositor() || isRunningBackdropFilterAnimationOnCompositor(); }
 
     const LineClampValue& lineClamp() const { return rareNonInheritedData->lineClamp; }
     Color tapHighlightColor() const { return rareInheritedData->tapHighlightColor; }
     ETextSecurity textSecurity() const { return static_cast<ETextSecurity>(rareInheritedData->textSecurity); }
 
-    WritingMode writingMode() const { return static_cast<WritingMode>(inherited_flags.m_writingMode); }
-    bool isHorizontalWritingMode() const { return blink::isHorizontalWritingMode(writingMode()); }
-    bool isFlippedLinesWritingMode() const { return blink::isFlippedLinesWritingMode(writingMode()); }
-    bool isFlippedBlocksWritingMode() const { return blink::isFlippedBlocksWritingMode(writingMode()); }
+    WritingMode getWritingMode() const { return static_cast<WritingMode>(inherited_flags.m_writingMode); }
+    bool isHorizontalWritingMode() const { return blink::isHorizontalWritingMode(getWritingMode()); }
+    bool isFlippedLinesWritingMode() const { return blink::isFlippedLinesWritingMode(getWritingMode()); }
+    bool isFlippedBlocksWritingMode() const { return blink::isFlippedBlocksWritingMode(getWritingMode()); }
 
     EImageRendering imageRendering() const { return static_cast<EImageRendering>(rareInheritedData->m_imageRendering); }
 
     ESpeak speak() const { return static_cast<ESpeak>(rareInheritedData->speak); }
 
     FilterOperations& mutableFilter() { return rareNonInheritedData.access()->m_filter.access()->m_operations; }
     const FilterOperations& filter() const { return rareNonInheritedData->m_filter->m_operations; }
     bool hasFilter() const { return !rareNonInheritedData->m_filter->m_operations.operations().isEmpty(); }
 
     FilterOperations& mutableBackdropFilter() { return rareNonInheritedData.access()->m_backdropFilter.access()->m_operations; }
     const FilterOperations& backdropFilter() const { return rareNonInheritedData->m_backdropFilter->m_operations; }
     bool hasBackdropFilter() const { return !rareNonInheritedData->m_backdropFilter->m_operations.operations().isEmpty(); }
 
     WebBlendMode blendMode() const { return static_cast<WebBlendMode>(rareNonInheritedData->m_effectiveBlendMode); }
     void setBlendMode(WebBlendMode v) { rareNonInheritedData.access()->m_effectiveBlendMode = v; }
     bool hasBlendMode() const { return blendMode() != WebBlendModeNormal; }
 
     EIsolation isolation() const { return static_cast<EIsolation>(rareNonInheritedData->m_isolation); }
     void setIsolation(EIsolation v) { rareNonInheritedData.access()->m_isolation = v; }
     bool hasIsolation() const { return isolation() != IsolationAuto; }
 
     bool shouldPlaceBlockDirectionScrollbarOnLogicalLeft() const { return !isLeftToRightDirection() && isHorizontalWritingMode(); }
 
-    TouchAction touchAction() const { return static_cast<TouchAction>(rareNonInheritedData->m_touchAction); }
+    TouchAction getTouchAction() const { return static_cast<TouchAction>(rareNonInheritedData->m_touchAction); }
 
-    ScrollBehavior scrollBehavior() const { return static_cast<ScrollBehavior>(rareNonInheritedData->m_scrollBehavior); }
+    ScrollBehavior getScrollBehavior() const { return static_cast<ScrollBehavior>(rareNonInheritedData->m_scrollBehavior); }
 
-    ScrollSnapType scrollSnapType() const { return static_cast<ScrollSnapType>(rareNonInheritedData->m_scrollSnapType); }
+    ScrollSnapType getScrollSnapType() const { return static_cast<ScrollSnapType>(rareNonInheritedData->m_scrollSnapType); }
     ScrollSnapPoints scrollSnapPointsX() const { return rareNonInheritedData->m_scrollSnap->m_xPoints; }
     ScrollSnapPoints scrollSnapPointsY() const { return rareNonInheritedData->m_scrollSnap->m_yPoints; }
     Vector<LengthPoint> scrollSnapCoordinate() const { return rareNonInheritedData->m_scrollSnap->m_coordinates; }
     LengthPoint scrollSnapDestination() const { return rareNonInheritedData->m_scrollSnap->m_destination; }
 
     const Vector<CSSPropertyID>& willChangeProperties() const { return rareNonInheritedData->m_willChange->m_properties; }
     bool willChangeContents() const { return rareNonInheritedData->m_willChange->m_contents; }
     bool willChangeScrollPosition() const { return rareNonInheritedData->m_willChange->m_scrollPosition; }
     bool hasWillChangeCompositingHint() const;
     bool hasWillChangeTransformHint() const;
@@ skipping 232 matching lines @@
     void setPaddingRight(const Length& v) { SET_VAR(surround, padding.m_right, v); }
 
     void setCursor(ECursor c) { inherited_flags._cursor_style = c; }
     void addCursor(PassRefPtrWillBeRawPtr<StyleImage>, bool hotSpotSpecified, const IntPoint& hotSpot = IntPoint());
     void setCursorList(PassRefPtrWillBeRawPtr<CursorList>);
     void clearCursorList();
 
     void setInsideLink(EInsideLink insideLink) { inherited_flags._insideLink = insideLink; }
     void setIsLink(bool b) { noninherited_flags.isLink = b; }
 
-    PrintColorAdjust printColorAdjust() const { return static_cast<PrintColorAdjust>(inherited_flags.m_printColorAdjust); }
+    PrintColorAdjust getPrintColorAdjust() const { return static_cast<PrintColorAdjust>(inherited_flags.m_printColorAdjust); }
     void setPrintColorAdjust(PrintColorAdjust value) { inherited_flags.m_printColorAdjust = value; }
 
     // A stacking context is painted atomically and defines a stacking order, whereas
     // a containing stacking context defines in which order the stacking contexts
     // below are painted. In Blink, a stacking context is defined by non-auto
     // z-index'. This invariant is enforced by the logic in StyleAdjuster
     // See CSS 2.1, Appendix E for more details.
     bool isStackingContext() const { return !hasAutoZIndex(); }
 
     // Some elements are "treated as if they create a new stacking context" for
@@ skipping 321 matching lines @@
 
     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)
     {
-        if (v == writingMode())
+        if (v == getWritingMode())
             return false;
 
         inherited_flags.m_writingMode = v;
         return true;
     }
 
     // A unique style is one that has matches something that makes it impossible to share.
     bool unique() const { return noninherited_flags.unique; }
     void setUnique() { noninherited_flags.unique = true; }
 
@@ skipping 406 matching lines @@
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const
 {
     return noninherited_flags.pseudoBits & PSEUDO_ELEMENT_MASK;
 }
 
 } // namespace blink
 
 #endif // ComputedStyle_h