Use getters for StyleSurroundData members in ComputedStyle.cpp

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 2811 matching lines @@
     return IsHorizontalWritingMode() ? MaxHeight() : MaxWidth();
   }
   const Length& LogicalMinWidth() const {
     return IsHorizontalWritingMode() ? MinWidth() : MinHeight();
   }
   const Length& LogicalMinHeight() const {
     return IsHorizontalWritingMode() ? MinHeight() : MinWidth();
   }
 
   // Margin utility functions.
-  bool HasMargin() const { return surround_->margin_.NonZero(); }
+  bool HasMargin() const { return Margin().NonZero(); }
   bool HasMarginBeforeQuirk() const { return MarginBefore().Quirk(); }
   bool HasMarginAfterQuirk() const { return MarginAfter().Quirk(); }
   const LengthBox& Margin() const { return surround_->margin_; }
   const Length& MarginBefore() const {
-    return surround_->margin_.Before(GetWritingMode());
+    return Margin().Before(GetWritingMode());
   }
-  const Length& MarginAfter() const {
-    return surround_->margin_.After(GetWritingMode());
-  }
+  const Length& MarginAfter() const { return Margin().After(GetWritingMode()); }
   const Length& MarginStart() const {
-    return surround_->margin_.Start(GetWritingMode(), Direction());
+    return Margin().Start(GetWritingMode(), Direction());
   }
   const Length& MarginEnd() const {
-    return surround_->margin_.end(GetWritingMode(), Direction());
+    return Margin().end(GetWritingMode(), Direction());
   }
-  const Length& MarginOver() const {
-    return surround_->margin_.Over(GetWritingMode());
-  }
-  const Length& MarginUnder() const {
-    return surround_->margin_.Under(GetWritingMode());
-  }
+  const Length& MarginOver() const { return Margin().Over(GetWritingMode()); }
+  const Length& MarginUnder() const { return Margin().Under(GetWritingMode()); }
   const Length& MarginStartUsing(const ComputedStyle* other_style) const {
-    return surround_->margin_.Start(other_style->GetWritingMode(),
-                                    other_style->Direction());
+    return Margin().Start(other_style->GetWritingMode(),
+                          other_style->Direction());
   }
   const Length& MarginEndUsing(const ComputedStyle* other_style) const {
-    return surround_->margin_.end(other_style->GetWritingMode(),
-                                  other_style->Direction());
+    return Margin().end(other_style->GetWritingMode(),
+                        other_style->Direction());
   }
   const Length& MarginBeforeUsing(const ComputedStyle* other_style) const {
-    return surround_->margin_.Before(other_style->GetWritingMode());
+    return Margin().Before(other_style->GetWritingMode());
   }
   const Length& MarginAfterUsing(const ComputedStyle* other_style) const {
-    return surround_->margin_.After(other_style->GetWritingMode());
+    return Margin().After(other_style->GetWritingMode());
   }
   void SetMarginStart(const Length&);
   void SetMarginEnd(const Length&);
 
   // Padding utility functions.
   const LengthBox& Padding() const { return surround_->padding_; }
   const Length& PaddingBefore() const {
-    return surround_->padding_.Before(GetWritingMode());
+    return Padding().Before(GetWritingMode());
   }
   const Length& PaddingAfter() const {
-    return surround_->padding_.After(GetWritingMode());
+    return Padding().After(GetWritingMode());
   }
   const Length& PaddingStart() const {
-    return surround_->padding_.Start(GetWritingMode(), Direction());
+    return Padding().Start(GetWritingMode(), Direction());
   }
   const Length& PaddingEnd() const {
-    return surround_->padding_.end(GetWritingMode(), Direction());
+    return Padding().end(GetWritingMode(), Direction());
   }
-  const Length& PaddingOver() const {
-    return surround_->padding_.Over(GetWritingMode());
+  const Length& PaddingOver() const { return Padding().Over(GetWritingMode()); }
+  const Length& PaddingUnder() const {
+    return Padding().Under(GetWritingMode());
   }
-  const Length& PaddingUnder() const {
-    return surround_->padding_.Under(GetWritingMode());
-  }
-  bool HasPadding() const { return surround_->padding_.NonZero(); }
+  bool HasPadding() const { return Padding().NonZero(); }
   void ResetPadding() { SET_VAR(surround_, padding_, LengthBox(kFixed)); }
   void SetPadding(const LengthBox& b) { SET_VAR(surround_, padding_, b); }
 
   // 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 surround_->border_.GetImage().Fill();
-  }
+  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 BorderValue& BorderBottom() const {
     return surround_->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 surround_->border_.HasBorderFill(); }
-  bool HasBorder() const { return surround_->border_.HasBorder(); }
+  bool HasBorderFill() const { return Border().HasBorderFill(); }
+  bool HasBorder() const { return Border().HasBorder(); }
   bool HasBorderDecoration() const { return HasBorder() || HasBorderFill(); }
-  bool HasBorderRadius() const { return surround_->border_.HasBorderRadius(); }
+  bool HasBorderRadius() const { return Border().HasBorderRadius(); }
 
   void ResetBorder() {
     ResetBorderImage();
     ResetBorderTop();
     ResetBorderRight();
     ResetBorderBottom();
     ResetBorderLeft();
     ResetBorderTopLeftRadius();
     ResetBorderTopRightRadius();
     ResetBorderBottomLeftRadius();
@@ skipping 773 matching lines @@
   pseudo_bits_ |= 1 << (pseudo - kFirstPublicPseudoId);
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return pseudo_bits_ & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h