Give consistent names to subgroups of ComputedStyle.

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
@@ skipping 167 matching lines @@
   // 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> box_;
-  DataRef<StyleVisualData> visual_;
-  DataRef<StyleBackgroundData> background_;
-  DataRef<StyleSurroundData> surround_;
+  DataRef<StyleBoxData> box_data_;
+  DataRef<StyleVisualData> visual_data_;
+  DataRef<StyleBackgroundData> background_data_;
+  DataRef<StyleSurroundData> surround_data_;
   DataRef<StyleRareNonInheritedData> rare_non_inherited_data_;
 
   // inherited attributes
   DataRef<StyleRareInheritedData> rare_inherited_data_;
   DataRef<StyleInheritedData> style_inherited_data_;
 
   // list of associated pseudo styles
   std::unique_ptr<PseudoStyleCache> cached_pseudo_styles_;
 
   DataRef<SVGComputedStyle> svg_style_;
@@ skipping 210 matching lines @@
         rare_non_inherited_data_->backface_visibility_);
   }
   void SetBackfaceVisibility(EBackfaceVisibility b) {
     SET_VAR(rare_non_inherited_data_, backface_visibility_, b);
   }
 
   // Background properties.
   // background-color
   static Color InitialBackgroundColor() { return Color::kTransparent; }
   void SetBackgroundColor(const StyleColor& v) {
-    SET_VAR(background_, color_, v);
+    SET_VAR(background_data_, color_, v);
   }
 
   // background-image
   bool HasBackgroundImage() const {
-    return background_->Background().HasImage();
+    return background_data_->Background().HasImage();
   }
   bool HasFixedBackgroundImage() const {
-    return background_->Background().HasFixedImage();
+    return background_data_->Background().HasFixedImage();
   }
   bool HasEntirelyFixedBackground() const;
 
   // background-clip
   EFillBox BackgroundClip() const {
-    return static_cast<EFillBox>(background_->Background().Clip());
+    return static_cast<EFillBox>(background_data_->Background().Clip());
   }
 
   // Border properties.
   // -webkit-border-image
   static NinePieceImage InitialNinePieceImage() { return NinePieceImage(); }
   const NinePieceImage& BorderImage() const {
-    return surround_->border_.GetImage();
+    return surround_data_->border_.GetImage();
   }
   void SetBorderImage(const NinePieceImage& b) {
-    SET_VAR(surround_, border_.image_, b);
+    SET_VAR(surround_data_, border_.image_, b);
   }
 
   // border-image-slice
   const LengthBox& BorderImageSlices() const {
-    return surround_->border_.GetImage().ImageSlices();
+    return surround_data_->border_.GetImage().ImageSlices();
   }
   void SetBorderImageSlices(const LengthBox&);
 
   // border-image-source
   static StyleImage* InitialBorderImageSource() { return 0; }
   StyleImage* BorderImageSource() const {
-    return surround_->border_.GetImage().GetImage();
+    return surround_data_->border_.GetImage().GetImage();
   }
   void SetBorderImageSource(StyleImage*);
 
   // border-image-width
   const BorderImageLengthBox& BorderImageWidth() const {
-    return surround_->border_.GetImage().BorderSlices();
+    return surround_data_->border_.GetImage().BorderSlices();
   }
   void SetBorderImageWidth(const BorderImageLengthBox&);
 
   // border-image-outset
   const BorderImageLengthBox& BorderImageOutset() const {
-    return surround_->border_.GetImage().Outset();
+    return surround_data_->border_.GetImage().Outset();
   }
   void SetBorderImageOutset(const BorderImageLengthBox&);
 
   // Border width properties.
   static float InitialBorderWidth() { return 3; }
 
   // border-top-width
-  float BorderTopWidth() const { return surround_->border_.BorderTopWidth(); }
+  float BorderTopWidth() const {
+    return surround_data_->border_.BorderTopWidth();
+  }
   void SetBorderTopWidth(float v) {
-    SET_BORDER_WIDTH(surround_, border_.top_, v);
+    SET_BORDER_WIDTH(surround_data_, border_.top_, v);
   }
 
   // border-bottom-width
   float BorderBottomWidth() const {
-    return surround_->border_.BorderBottomWidth();
+    return surround_data_->border_.BorderBottomWidth();
   }
   void SetBorderBottomWidth(float v) {
-    SET_BORDER_WIDTH(surround_, border_.bottom_, v);
+    SET_BORDER_WIDTH(surround_data_, border_.bottom_, v);
   }
 
   // border-left-width
-  float BorderLeftWidth() const { return surround_->border_.BorderLeftWidth(); }
+  float BorderLeftWidth() const {
+    return surround_data_->border_.BorderLeftWidth();
+  }
   void SetBorderLeftWidth(float v) {
-    SET_BORDER_WIDTH(surround_, border_.left_, v);
+    SET_BORDER_WIDTH(surround_data_, border_.left_, v);
   }
 
   // border-right-width
   float BorderRightWidth() const {
-    return surround_->border_.BorderRightWidth();
+    return surround_data_->border_.BorderRightWidth();
   }
   void SetBorderRightWidth(float v) {
-    SET_BORDER_WIDTH(surround_, border_.right_, v);
+    SET_BORDER_WIDTH(surround_data_, border_.right_, v);
   }
 
   // Border style properties.
   static EBorderStyle InitialBorderStyle() { return kBorderStyleNone; }
 
   // border-top-style
   EBorderStyle BorderTopStyle() const {
-    return surround_->border_.Top().Style();
+    return surround_data_->border_.Top().Style();
   }
   void SetBorderTopStyle(EBorderStyle v) {
-    SET_VAR(surround_, border_.top_.style_, v);
+    SET_VAR(surround_data_, border_.top_.style_, v);
   }
 
   // border-right-style
   EBorderStyle BorderRightStyle() const {
-    return surround_->border_.Right().Style();
+    return surround_data_->border_.Right().Style();
   }
   void SetBorderRightStyle(EBorderStyle v) {
-    SET_VAR(surround_, border_.right_.style_, v);
+    SET_VAR(surround_data_, border_.right_.style_, v);
   }
 
   // border-left-style
   EBorderStyle BorderLeftStyle() const {
-    return surround_->border_.Left().Style();
+    return surround_data_->border_.Left().Style();
   }
   void SetBorderLeftStyle(EBorderStyle v) {
-    SET_VAR(surround_, border_.left_.style_, v);
+    SET_VAR(surround_data_, border_.left_.style_, v);
   }
 
   // border-bottom-style
   EBorderStyle BorderBottomStyle() const {
-    return surround_->border_.Bottom().Style();
+    return surround_data_->border_.Bottom().Style();
   }
   void SetBorderBottomStyle(EBorderStyle v) {
-    SET_VAR(surround_, border_.bottom_.style_, v);
+    SET_VAR(surround_data_, border_.bottom_.style_, v);
   }
 
   // Border color properties.
   // border-left-color
   void SetBorderLeftColor(const StyleColor& v) {
-    SET_BORDERVALUE_COLOR(surround_, border_.left_, v);
+    SET_BORDERVALUE_COLOR(surround_data_, border_.left_, v);
   }
 
   // border-right-color
   void SetBorderRightColor(const StyleColor& v) {
-    SET_BORDERVALUE_COLOR(surround_, border_.right_, v);
+    SET_BORDERVALUE_COLOR(surround_data_, border_.right_, v);
   }
 
   // border-top-color
   void SetBorderTopColor(const StyleColor& v) {
-    SET_BORDERVALUE_COLOR(surround_, border_.top_, v);
+    SET_BORDERVALUE_COLOR(surround_data_, border_.top_, v);
   }
 
   // border-bottom-color
   void SetBorderBottomColor(const StyleColor& v) {
-    SET_BORDERVALUE_COLOR(surround_, border_.bottom_, v);
+    SET_BORDERVALUE_COLOR(surround_data_, border_.bottom_, v);
   }
 
   // Border radius properties.
   static LengthSize InitialBorderRadius() {
     return LengthSize(Length(0, kFixed), Length(0, kFixed));
   }
 
   // border-top-left-radius (aka -webkit-border-top-left-radius)
   const LengthSize& BorderTopLeftRadius() const {
-    return surround_->border_.TopLeft();
+    return surround_data_->border_.TopLeft();
   }
   void SetBorderTopLeftRadius(const LengthSize& s) {
-    SET_VAR(surround_, border_.top_left_, s);
+    SET_VAR(surround_data_, border_.top_left_, s);
   }
 
   // border-top-right-radius (aka -webkit-border-top-right-radius)
   const LengthSize& BorderTopRightRadius() const {
-    return surround_->border_.TopRight();
+    return surround_data_->border_.TopRight();
   }
   void SetBorderTopRightRadius(const LengthSize& s) {
-    SET_VAR(surround_, border_.top_right_, s);
+    SET_VAR(surround_data_, border_.top_right_, s);
   }
 
   // border-bottom-left-radius (aka -webkit-border-bottom-left-radius)
   const LengthSize& BorderBottomLeftRadius() const {
-    return surround_->border_.BottomLeft();
+    return surround_data_->border_.BottomLeft();
   }
   void SetBorderBottomLeftRadius(const LengthSize& s) {
-    SET_VAR(surround_, border_.bottom_left_, s);
+    SET_VAR(surround_data_, border_.bottom_left_, s);
   }
 
   // border-bottom-right-radius (aka -webkit-border-bottom-right-radius)
   const LengthSize& BorderBottomRightRadius() const {
-    return surround_->border_.BottomRight();
+    return surround_data_->border_.BottomRight();
   }
   void SetBorderBottomRightRadius(const LengthSize& s) {
-    SET_VAR(surround_, border_.bottom_right_, s);
+    SET_VAR(surround_data_, border_.bottom_right_, s);
   }
 
   // Offset properties.
   // left
   static Length InitialLeft() { return Length(); }
-  const Length& Left() const { return surround_->left_; }
-  void SetLeft(const Length& v) { SET_VAR(surround_, left_, v); }
+  const Length& Left() const { return surround_data_->left_; }
+  void SetLeft(const Length& v) { SET_VAR(surround_data_, left_, v); }
 
   // right
   static Length InitialRight() { return Length(); }
-  const Length& Right() const { return surround_->right_; }
-  void SetRight(const Length& v) { SET_VAR(surround_, right_, v); }
+  const Length& Right() const { return surround_data_->right_; }
+  void SetRight(const Length& v) { SET_VAR(surround_data_, right_, v); }
 
   // top
   static Length InitialTop() { return Length(); }
-  const Length& Top() const { return surround_->top_; }
-  void SetTop(const Length& v) { SET_VAR(surround_, top_, v); }
+  const Length& Top() const { return surround_data_->top_; }
+  void SetTop(const Length& v) { SET_VAR(surround_data_, top_, v); }
 
   // bottom
   static Length InitialBottom() { return Length(); }
-  const Length& Bottom() const { return surround_->bottom_; }
-  void SetBottom(const Length& v) { SET_VAR(surround_, bottom_, v); }
+  const Length& Bottom() const { return surround_data_->bottom_; }
+  void SetBottom(const Length& v) { SET_VAR(surround_data_, bottom_, v); }
 
   // box-shadow (aka -webkit-box-shadow)
   static ShadowList* InitialBoxShadow() { return 0; }
   ShadowList* BoxShadow() const {
     return rare_non_inherited_data_->box_shadow_.Get();
   }
   void SetBoxShadow(PassRefPtr<ShadowList>);
 
   // box-sizing (aka -webkit-box-sizing)
   static EBoxSizing InitialBoxSizing() { return EBoxSizing::kContentBox; }
-  EBoxSizing BoxSizing() const { return box_->BoxSizing(); }
+  EBoxSizing BoxSizing() const { return box_data_->BoxSizing(); }
   void SetBoxSizing(EBoxSizing s) {
-    SET_VAR(box_, box_sizing_, static_cast<unsigned>(s));
+    SET_VAR(box_data_, box_sizing_, static_cast<unsigned>(s));
   }
 
   // clip
   static LengthBox InitialClip() { return LengthBox(); }
-  const LengthBox& Clip() const { return visual_->clip; }
+  const LengthBox& Clip() const { return visual_data_->clip; }
   void SetClip(const LengthBox& box) {
-    SET_VAR(visual_, has_auto_clip, false);
-    SET_VAR(visual_, clip, box);
+    SET_VAR(visual_data_, has_auto_clip, false);
+    SET_VAR(visual_data_, clip, box);
   }
-  bool HasAutoClip() const { return visual_->has_auto_clip; }
+  bool HasAutoClip() const { return visual_data_->has_auto_clip; }
   void SetHasAutoClip() {
-    SET_VAR(visual_, has_auto_clip, true);
-    SET_VAR(visual_, clip, ComputedStyle::InitialClip());
+    SET_VAR(visual_data_, has_auto_clip, true);
+    SET_VAR(visual_data_, clip, ComputedStyle::InitialClip());
   }
 
   // Column properties.
   // column-count (aka -webkit-column-count)
   static unsigned short InitialColumnCount() { return 1; }
   unsigned short ColumnCount() const {
     return rare_non_inherited_data_->multi_col_->count_;
   }
   void SetColumnCount(unsigned short c) {
     SET_NESTED_VAR(rare_non_inherited_data_, multi_col_, auto_count_, false);
@@ skipping 176 matching lines @@
   void SetBoxAlign(EBoxAlignment a) {
     SET_NESTED_VAR(rare_non_inherited_data_, deprecated_flexible_box_, align,
                    a);
   }
 
   // -webkit-box-decoration-break
   static EBoxDecorationBreak InitialBoxDecorationBreak() {
     return kBoxDecorationBreakSlice;
   }
   EBoxDecorationBreak BoxDecorationBreak() const {
-    return box_->BoxDecorationBreak();
+    return box_data_->BoxDecorationBreak();
   }
   void SetBoxDecorationBreak(EBoxDecorationBreak b) {
-    SET_VAR(box_, box_decoration_break_, b);
+    SET_VAR(box_data_, box_decoration_break_, b);
   }
 
   // -webkit-box-lines
   static EBoxLines InitialBoxLines() { return SINGLE; }
   EBoxLines BoxLines() const {
     return static_cast<EBoxLines>(
         rare_non_inherited_data_->deprecated_flexible_box_->lines);
   }
   void SetBoxLines(EBoxLines lines) {
     SET_NESTED_VAR(rare_non_inherited_data_, deprecated_flexible_box_, lines,
@@ skipping 176 matching lines @@
     SET_NESTED_VAR(rare_non_inherited_data_, grid_, grid_template_rows_,
                    lengths);
   }
 
   // Width/height properties.
   static Length InitialSize() { return Length(); }
   static Length InitialMaxSize() { return Length(kMaxSizeNone); }
   static Length InitialMinSize() { return Length(); }
 
   // width
-  const Length& Width() const { return box_->Width(); }
-  void SetWidth(const Length& v) { SET_VAR(box_, width_, v); }
+  const Length& Width() const { return box_data_->Width(); }
+  void SetWidth(const Length& v) { SET_VAR(box_data_, width_, v); }
 
   // height
-  const Length& Height() const { return box_->Height(); }
-  void SetHeight(const Length& v) { SET_VAR(box_, height_, v); }
+  const Length& Height() const { return box_data_->Height(); }
+  void SetHeight(const Length& v) { SET_VAR(box_data_, height_, v); }
 
   // max-width
-  const Length& MaxWidth() const { return box_->MaxWidth(); }
-  void SetMaxWidth(const Length& v) { SET_VAR(box_, max_width_, v); }
+  const Length& MaxWidth() const { return box_data_->MaxWidth(); }
+  void SetMaxWidth(const Length& v) { SET_VAR(box_data_, max_width_, v); }
 
   // max-height
-  const Length& MaxHeight() const { return box_->MaxHeight(); }
-  void SetMaxHeight(const Length& v) { SET_VAR(box_, max_height_, v); }
+  const Length& MaxHeight() const { return box_data_->MaxHeight(); }
+  void SetMaxHeight(const Length& v) { SET_VAR(box_data_, max_height_, v); }
 
   // min-width
-  const Length& MinWidth() const { return box_->MinWidth(); }
-  void SetMinWidth(const Length& v) { SET_VAR(box_, min_width_, v); }
+  const Length& MinWidth() const { return box_data_->MinWidth(); }
+  void SetMinWidth(const Length& v) { SET_VAR(box_data_, min_width_, v); }
 
   // min-height
-  const Length& MinHeight() const { return box_->MinHeight(); }
-  void SetMinHeight(const Length& v) { SET_VAR(box_, min_height_, v); }
+  const Length& MinHeight() const { return box_data_->MinHeight(); }
+  void SetMinHeight(const Length& v) { SET_VAR(box_data_, min_height_, v); }
 
   // image-orientation
   static RespectImageOrientationEnum InitialRespectImageOrientation() {
     return kDoNotRespectImageOrientation;
   }
   RespectImageOrientationEnum RespectImageOrientation() const {
     return static_cast<RespectImageOrientationEnum>(
         rare_inherited_data_->respect_image_orientation_);
   }
   void SetRespectImageOrientation(RespectImageOrientationEnum v) {
@@ skipping 15 matching lines @@
     return static_cast<EIsolation>(rare_non_inherited_data_->isolation_);
   }
   void SetIsolation(EIsolation v) {
     rare_non_inherited_data_.Access()->isolation_ = v;
   }
 
   // Margin properties.
 
   // margin-top
   static Length InitialMarginTop() { return Length(kFixed); }
-  const Length& MarginTop() const { return surround_->margin_top_; }
-  void SetMarginTop(const Length& v) { SET_VAR(surround_, margin_top_, v); }
+  const Length& MarginTop() const { return surround_data_->margin_top_; }
+  void SetMarginTop(const Length& v) {
+    SET_VAR(surround_data_, margin_top_, v);
+  }
 
   // margin-bottom
   static Length InitialMarginBottom() { return Length(kFixed); }
-  const Length& MarginBottom() const { return surround_->margin_bottom_; }
+  const Length& MarginBottom() const { return surround_data_->margin_bottom_; }
   void SetMarginBottom(const Length& v) {
-    SET_VAR(surround_, margin_bottom_, v);
+    SET_VAR(surround_data_, margin_bottom_, v);
   }
 
   // margin-left
   static Length InitialMarginLeft() { return Length(kFixed); }
-  const Length& MarginLeft() const { return surround_->margin_left_; }
-  void SetMarginLeft(const Length& v) { SET_VAR(surround_, margin_left_, v); }
+  const Length& MarginLeft() const { return surround_data_->margin_left_; }
+  void SetMarginLeft(const Length& v) {
+    SET_VAR(surround_data_, margin_left_, v);
+  }
 
   // margin-right
   static Length InitialMarginRight() { return Length(kFixed); }
-  const Length& MarginRight() const { return surround_->margin_right_; }
-  void SetMarginRight(const Length& v) { SET_VAR(surround_, margin_right_, v); }
+  const Length& MarginRight() const { return surround_data_->margin_right_; }
+  void SetMarginRight(const Length& v) {
+    SET_VAR(surround_data_, margin_right_, v);
+  }
 
   // -webkit-margin-before-collapse (aka -webkit-margin-top-collapse)
   static EMarginCollapse InitialMarginBeforeCollapse() {
     return kMarginCollapseCollapse;
   }
   EMarginCollapse MarginAfterCollapse() const {
     return static_cast<EMarginCollapse>(
         rare_non_inherited_data_->margin_after_collapse);
   }
   void SetMarginBeforeCollapse(EMarginCollapse c) {
@@ skipping 163 matching lines @@
     return rare_non_inherited_data_->outline_.Offset();
   }
   void SetOutlineOffset(int v) {
     SET_VAR(rare_non_inherited_data_, outline_.offset_, v);
   }
 
   // Padding properties.
 
   // padding-bottom
   static Length InitialPaddingBottom() { return Length(kFixed); }
-  const Length& PaddingBottom() const { return surround_->padding_bottom_; }
+  const Length& PaddingBottom() const {
+    return surround_data_->padding_bottom_;
+  }
   void SetPaddingBottom(const Length& v) {
-    SET_VAR(surround_, padding_bottom_, v);
+    SET_VAR(surround_data_, padding_bottom_, v);
   }
 
   // padding-left
   static Length InitialPaddingLeft() { return Length(kFixed); }
-  const Length& PaddingLeft() const { return surround_->padding_left_; }
-  void SetPaddingLeft(const Length& v) { SET_VAR(surround_, padding_left_, v); }
+  const Length& PaddingLeft() const { return surround_data_->padding_left_; }
+  void SetPaddingLeft(const Length& v) {
+    SET_VAR(surround_data_, padding_left_, v);
+  }
 
   // padding-right
   static Length InitialPaddingRight() { return Length(kFixed); }
-  const Length& PaddingRight() const { return surround_->padding_right_; }
+  const Length& PaddingRight() const { return surround_data_->padding_right_; }
   void SetPaddingRight(const Length& v) {
-    SET_VAR(surround_, padding_right_, v);
+    SET_VAR(surround_data_, padding_right_, v);
   }
 
   // padding-top
   static Length InitialPaddingTop() { return Length(kFixed); }
-  const Length& PaddingTop() const { return surround_->padding_top_; }
-  void SetPaddingTop(const Length& v) { SET_VAR(surround_, padding_top_, v); }
+  const Length& PaddingTop() const { return surround_data_->padding_top_; }
+  void SetPaddingTop(const Length& v) {
+    SET_VAR(surround_data_, padding_top_, v);
+  }
 
   // perspective (aka -webkit-perspective)
   static float InitialPerspective() { return 0; }
   float Perspective() const { return rare_non_inherited_data_->perspective_; }
   void SetPerspective(float p) {
     SET_VAR(rare_non_inherited_data_, perspective_, p);
   }
 
   // perspective-origin (aka -webkit-perspective-origin)
   static LengthPoint InitialPerspectiveOrigin() {
@@ skipping 229 matching lines @@
     SET_VAR(rare_non_inherited_data_, page_size_, s);
   }
   void SetPageSizeType(PageSizeType t) {
     SET_VAR(rare_non_inherited_data_, page_size_type_, t);
   }
 
   // Text decoration properties.
   // text-decoration-line
   static TextDecoration InitialTextDecoration() { return kTextDecorationNone; }
   TextDecoration GetTextDecoration() const {
-    return static_cast<TextDecoration>(visual_->text_decoration);
+    return static_cast<TextDecoration>(visual_data_->text_decoration);
   }
   void SetTextDecoration(TextDecoration v) {
-    SET_VAR(visual_, text_decoration, v);
+    SET_VAR(visual_data_, text_decoration, v);
   }
 
   // text-decoration-color
   void SetTextDecorationColor(const StyleColor& c) {
     SET_VAR(rare_non_inherited_data_, text_decoration_color_, c);
   }
 
   // text-decoration-style
   static TextDecorationStyle InitialTextDecorationStyle() {
     return kTextDecorationStyleSolid;
@@ skipping 46 matching lines @@
   }
   void SetTouchAction(TouchAction t) {
     SET_VAR(rare_non_inherited_data_, touch_action_, t);
   }
 
   // vertical-align
   static EVerticalAlign InitialVerticalAlign() {
     return EVerticalAlign::kBaseline;
   }
   EVerticalAlign VerticalAlign() const { return VerticalAlignInternal(); }
-  const Length& GetVerticalAlignLength() const { return box_->VerticalAlign(); }
+  const Length& GetVerticalAlignLength() const {
+    return box_data_->VerticalAlign();
+  }
   void SetVerticalAlign(EVerticalAlign v) { SetVerticalAlignInternal(v); }
   void SetVerticalAlignLength(const Length& length) {
     SetVerticalAlignInternal(EVerticalAlign::kLength);
-    SET_VAR(box_, vertical_align_, length);
+    SET_VAR(box_data_, vertical_align_, length);
   }
 
   // will-change
   const Vector<CSSPropertyID>& WillChangeProperties() const {
     return rare_non_inherited_data_->will_change_->properties_;
   }
   bool WillChangeContents() const {
     return rare_non_inherited_data_->will_change_->contents_;
   }
   bool WillChangeScrollPosition() const {
@@ skipping 10 matching lines @@
     SET_NESTED_VAR(rare_non_inherited_data_, will_change_, contents_, b);
   }
   void SetWillChangeScrollPosition(bool b) {
     SET_NESTED_VAR(rare_non_inherited_data_, will_change_, scroll_position_, b);
   }
   void SetSubtreeWillChangeContents(bool b) {
     SET_VAR(rare_inherited_data_, subtree_will_change_contents_, b);
   }
 
   // z-index
-  int ZIndex() const { return box_->ZIndex(); }
-  bool HasAutoZIndex() const { return box_->HasAutoZIndex(); }
+  int ZIndex() const { return box_data_->ZIndex(); }
+  bool HasAutoZIndex() const { return box_data_->HasAutoZIndex(); }
   void SetZIndex(int v) {
-    SET_VAR(box_, has_auto_z_index_, false);
-    SET_VAR(box_, z_index_, v);
+    SET_VAR(box_data_, has_auto_z_index_, false);
+    SET_VAR(box_data_, z_index_, v);
   }
   void SetHasAutoZIndex() {
-    SET_VAR(box_, has_auto_z_index_, true);
-    SET_VAR(box_, z_index_, 0);
+    SET_VAR(box_data_, has_auto_z_index_, true);
+    SET_VAR(box_data_, z_index_, 0);
   }
 
   // zoom
   static float InitialZoom() { return 1.0f; }
-  float Zoom() const { return visual_->zoom_; }
+  float Zoom() const { return visual_data_->zoom_; }
   float EffectiveZoom() const { return rare_inherited_data_->effective_zoom_; }
   bool SetZoom(float);
   bool SetEffectiveZoom(float);
 
   // -webkit-app-region
   DraggableRegionMode GetDraggableRegionMode() const {
     return rare_non_inherited_data_->draggable_region_mode_;
   }
   void SetDraggableRegionMode(DraggableRegionMode v) {
     SET_VAR(rare_non_inherited_data_, draggable_region_mode_, v);
@@ skipping 1095 matching lines @@
 
   // Width/height utility functions.
   const Length& LogicalWidth() const {
     return IsHorizontalWritingMode() ? Width() : Height();
   }
   const Length& LogicalHeight() const {
     return IsHorizontalWritingMode() ? Height() : Width();
   }
   void SetLogicalWidth(const Length& v) {
     if (IsHorizontalWritingMode()) {
-      SET_VAR(box_, width_, v);
+      SET_VAR(box_data_, width_, v);
     } else {
-      SET_VAR(box_, height_, v);
+      SET_VAR(box_data_, height_, v);
     }
   }
 
   void SetLogicalHeight(const Length& v) {
     if (IsHorizontalWritingMode()) {
-      SET_VAR(box_, height_, v);
+      SET_VAR(box_data_, height_, v);
     } else {
-      SET_VAR(box_, width_, v);
+      SET_VAR(box_data_, width_, v);
     }
   }
   const Length& LogicalMaxWidth() const {
     return IsHorizontalWritingMode() ? MaxWidth() : MaxHeight();
   }
   const Length& LogicalMaxHeight() const {
     return IsHorizontalWritingMode() ? MaxHeight() : MaxWidth();
   }
   const Length& LogicalMinWidth() const {
     return IsHorizontalWritingMode() ? MinWidth() : MinHeight();
@@ skipping 67 matching lines @@
     return LengthBox::Over(GetWritingMode(), PaddingTop(), PaddingRight());
   }
   const Length& PaddingUnder() const {
     return LengthBox::Under(GetWritingMode(), PaddingBottom(), PaddingLeft());
   }
   bool HasPadding() const {
     return !PaddingLeft().IsZero() || !PaddingRight().IsZero() ||
            !PaddingTop().IsZero() || !PaddingBottom().IsZero();
   }
   void ResetPadding() {
-    SET_VAR(surround_, padding_top_, kFixed);
-    SET_VAR(surround_, padding_bottom_, kFixed);
-    SET_VAR(surround_, padding_left_, kFixed);
-    SET_VAR(surround_, padding_right_, kFixed);
+    SET_VAR(surround_data_, padding_top_, kFixed);
+    SET_VAR(surround_data_, padding_bottom_, kFixed);
+    SET_VAR(surround_data_, padding_left_, kFixed);
+    SET_VAR(surround_data_, padding_right_, kFixed);
   }
   void SetPadding(const LengthBox& b) {
-    SET_VAR(surround_, padding_top_, b.top_);
-    SET_VAR(surround_, padding_bottom_, b.bottom_);
-    SET_VAR(surround_, padding_left_, b.left_);
-    SET_VAR(surround_, padding_right_, b.right_);
+    SET_VAR(surround_data_, padding_top_, b.top_);
+    SET_VAR(surround_data_, padding_bottom_, b.bottom_);
+    SET_VAR(surround_data_, padding_left_, b.left_);
+    SET_VAR(surround_data_, padding_right_, b.right_);
   }
   bool PaddingEqual(const ComputedStyle& other) const {
     return PaddingTop() == other.PaddingTop() &&
            PaddingLeft() == other.PaddingLeft() &&
            PaddingRight() == other.PaddingRight() &&
            PaddingBottom() == other.PaddingBottom();
   }
   bool PaddingEqual(const LengthBox& other) const {
     return PaddingTop() == other.Top() && PaddingLeft() == other.Left() &&
            PaddingRight() == other.Right() && PaddingBottom() == other.Bottom();
   }
 
   // Border utility functions
   LayoutRectOutsets ImageOutsets(const NinePieceImage&) const;
   bool HasBorderImageOutsets() const {
     return BorderImage().HasImage() && BorderImage().Outset().NonZero();
   }
   LayoutRectOutsets BorderImageOutsets() const {
     return ImageOutsets(BorderImage());
   }
   bool BorderImageSlicesFill() const { return Border().GetImage().Fill(); }
 
   void SetBorderImageSlicesFill(bool);
-  const BorderData& Border() const { return surround_->border_; }
-  const BorderValue& BorderLeft() const { return surround_->border_.Left(); }
-  const BorderValue& BorderRight() const { return surround_->border_.Right(); }
-  const BorderValue& BorderTop() const { return surround_->border_.Top(); }
+  const BorderData& Border() const { return surround_data_->border_; }
+  const BorderValue& BorderLeft() const {
+    return surround_data_->border_.Left();
+  }
+  const BorderValue& BorderRight() const {
+    return surround_data_->border_.Right();
+  }
+  const BorderValue& BorderTop() const { return surround_data_->border_.Top(); }
   const BorderValue& BorderBottom() const {
-    return surround_->border_.Bottom();
+    return surround_data_->border_.Bottom();
   }
   const BorderValue& BorderBefore() const;
   const BorderValue& BorderAfter() const;
   const BorderValue& BorderStart() const;
   const BorderValue& BorderEnd() const;
   float BorderAfterWidth() const;
   float BorderBeforeWidth() const;
   float BorderEndWidth() const;
   float BorderStartWidth() const;
   float BorderOverWidth() const;
   float BorderUnderWidth() const;
 
   bool HasBorderFill() const { return Border().HasBorderFill(); }
   bool HasBorder() const { return Border().HasBorder(); }
   bool HasBorderDecoration() const { return HasBorder() || HasBorderFill(); }
   bool HasBorderRadius() const { return Border().HasBorderRadius(); }
 
   void ResetBorder() {
     ResetBorderImage();
     ResetBorderTop();
     ResetBorderRight();
     ResetBorderBottom();
     ResetBorderLeft();
     ResetBorderTopLeftRadius();
     ResetBorderTopRightRadius();
     ResetBorderBottomLeftRadius();
     ResetBorderBottomRightRadius();
   }
-  void ResetBorderTop() { SET_VAR(surround_, border_.top_, BorderValue()); }
-  void ResetBorderRight() { SET_VAR(surround_, border_.right_, BorderValue()); }
+  void ResetBorderTop() {
+    SET_VAR(surround_data_, border_.top_, BorderValue());
+  }
+  void ResetBorderRight() {
+    SET_VAR(surround_data_, border_.right_, BorderValue());
+  }
   void ResetBorderBottom() {
-    SET_VAR(surround_, border_.bottom_, BorderValue());
+    SET_VAR(surround_data_, border_.bottom_, BorderValue());
   }
-  void ResetBorderLeft() { SET_VAR(surround_, border_.left_, BorderValue()); }
+  void ResetBorderLeft() {
+    SET_VAR(surround_data_, border_.left_, BorderValue());
+  }
   void ResetBorderImage() {
-    SET_VAR(surround_, border_.image_, NinePieceImage());
+    SET_VAR(surround_data_, border_.image_, NinePieceImage());
   }
   void ResetBorderTopLeftRadius() {
-    SET_VAR(surround_, border_.top_left_, InitialBorderRadius());
+    SET_VAR(surround_data_, border_.top_left_, InitialBorderRadius());
   }
   void ResetBorderTopRightRadius() {
-    SET_VAR(surround_, border_.top_right_, InitialBorderRadius());
+    SET_VAR(surround_data_, border_.top_right_, InitialBorderRadius());
   }
   void ResetBorderBottomLeftRadius() {
-    SET_VAR(surround_, border_.bottom_left_, InitialBorderRadius());
+    SET_VAR(surround_data_, border_.bottom_left_, InitialBorderRadius());
   }
   void ResetBorderBottomRightRadius() {
-    SET_VAR(surround_, border_.bottom_right_, InitialBorderRadius());
+    SET_VAR(surround_data_, border_.bottom_right_, InitialBorderRadius());
   }
 
   void SetBorderRadius(const LengthSize& s) {
     SetBorderTopLeftRadius(s);
     SetBorderTopRightRadius(s);
     SetBorderBottomLeftRadius(s);
     SetBorderBottomRightRadius(s);
   }
   void SetBorderRadius(const IntSize& s) {
     SetBorderRadius(
@@ skipping 55 matching lines @@
   bool HasInFlowPosition() const {
     return GetPosition() == EPosition::kRelative ||
            GetPosition() == EPosition::kSticky;
   }
   bool HasViewportConstrainedPosition() const {
     return GetPosition() == EPosition::kFixed ||
            GetPosition() == EPosition::kSticky;
   }
 
   // Clip utility functions.
-  const Length& ClipLeft() const { return visual_->clip.Left(); }
-  const Length& ClipRight() const { return visual_->clip.Right(); }
-  const Length& ClipTop() const { return visual_->clip.Top(); }
-  const Length& ClipBottom() const { return visual_->clip.Bottom(); }
+  const Length& ClipLeft() const { return visual_data_->clip.Left(); }
+  const Length& ClipRight() const { return visual_data_->clip.Right(); }
+  const Length& ClipTop() const { return visual_data_->clip.Top(); }
+  const Length& ClipBottom() const { return visual_data_->clip.Bottom(); }
 
   // Offset utility functions.
   // Accessors for positioned object edges that take into account writing mode.
   const Length& LogicalLeft() const {
     return LengthBox::LogicalLeft(GetWritingMode(), Left(), Top());
   }
   const Length& LogicalRight() const {
     return LengthBox::LogicalRight(GetWritingMode(), Right(), Bottom());
   }
   const Length& LogicalTop() const {
@@ skipping 159 matching lines @@
   enum ApplyTransformOrigin {
     kIncludeTransformOrigin,
     kExcludeTransformOrigin
   };
   enum ApplyMotionPath { kIncludeMotionPath, kExcludeMotionPath };
   enum ApplyIndependentTransformProperties {
     kIncludeIndependentTransformProperties,
     kExcludeIndependentTransformProperties
   };
   void ApplyTransform(TransformationMatrix&,
-                      const LayoutSize& border_box_size,
+                      const LayoutSize& border_box_data_size,
                       ApplyTransformOrigin,
                       ApplyMotionPath,
                       ApplyIndependentTransformProperties) const;
   void ApplyTransform(TransformationMatrix&,
                       const FloatRect& bounding_box,
                       ApplyTransformOrigin,
                       ApplyMotionPath,
                       ApplyIndependentTransformProperties) const;
 
   // Returns |true| if any property that renders using filter operations is
@@ skipping 149 matching lines @@
   // "Box decoration background" includes all box decorations and backgrounds
   // that are painted as the background of the object. It includes borders,
   // box-shadows, background-color and background-image, etc.
   bool HasBoxDecorationBackground() const {
     return HasBackground() || HasBorderDecoration() || HasAppearance() ||
            BoxShadow();
   }
 
   // Background utility functions.
   FillLayer& AccessBackgroundLayers() {
-    return background_.Access()->background_;
+    return background_data_.Access()->background_;
   }
   const FillLayer& BackgroundLayers() const {
-    return background_->Background();
+    return background_data_->Background();
   }
   void AdjustBackgroundLayers() {
     if (BackgroundLayers().Next()) {
       AccessBackgroundLayers().CullEmptyLayers();
       AccessBackgroundLayers().FillUnsetProperties();
     }
   }
   bool HasBackgroundRelatedColorReferencingCurrentColor() const {
     if (BackgroundColor().IsCurrentColor() ||
         VisitedLinkBackgroundColor().IsCurrentColor())
@@ skipping 103 matching lines @@
            display == EDisplay::kTableRow ||
            display == EDisplay::kTableColumnGroup ||
            display == EDisplay::kTableColumn ||
            display == EDisplay::kTableCell ||
            display == EDisplay::kTableCaption;
   }
 
   // Color accessors are all private to make sure callers use
   // VisitedDependentColor instead to access them.
   StyleColor BorderLeftColor() const {
-    return surround_->border_.Left().GetColor();
+    return surround_data_->border_.Left().GetColor();
   }
   StyleColor BorderRightColor() const {
-    return surround_->border_.Right().GetColor();
+    return surround_data_->border_.Right().GetColor();
   }
   StyleColor BorderTopColor() const {
-    return surround_->border_.Top().GetColor();
+    return surround_data_->border_.Top().GetColor();
   }
   StyleColor BorderBottomColor() const {
-    return surround_->border_.Bottom().GetColor();
+    return surround_data_->border_.Bottom().GetColor();
   }
-  StyleColor BackgroundColor() const { return background_->GetColor(); }
+  StyleColor BackgroundColor() const { return background_data_->GetColor(); }
   StyleAutoColor CaretColor() const {
     return rare_inherited_data_->CaretColor();
   }
   Color GetColor() const;
   StyleColor ColumnRuleColor() const {
     return rare_non_inherited_data_->multi_col_->rule_.GetColor();
   }
   StyleColor OutlineColor() const {
     return rare_non_inherited_data_->outline_.GetColor();
   }
@@ skipping 116 matching lines @@
                                          float zoom_factor) {
   return scroll_offset / zoom_factor;
 }
 
 inline float AdjustScrollForAbsoluteZoom(float scroll_offset,
                                          const ComputedStyle& style) {
   return AdjustScrollForAbsoluteZoom(scroll_offset, style.EffectiveZoom());
 }
 
 inline bool ComputedStyle::SetZoom(float f) {
-  if (compareEqual(visual_->zoom_, f))
+  if (compareEqual(visual_data_->zoom_, f))
     return false;
-  visual_.Access()->zoom_ = f;
+  visual_data_.Access()->zoom_ = f;
   SetEffectiveZoom(EffectiveZoom() * Zoom());
   return true;
 }
 
 inline bool ComputedStyle::SetEffectiveZoom(float f) {
   // Clamp the effective zoom value to a smaller (but hopeful still large
   // enough) range, to avoid overflow in derived computations.
   float clamped_effective_zoom = clampTo<float>(f, 1e-6, 1e6);
   if (compareEqual(rare_inherited_data_->effective_zoom_,
                    clamped_effective_zoom))
@@ skipping 37 matching lines @@
       PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h