Split StyleSurroundData::padding into four individual Lengths.

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 1278 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_->padding_bottom_; }
   void SetPaddingBottom(const Length& v) {
-    SET_VAR(surround_, padding_.bottom_, v);
+    SET_VAR(surround_, 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_->padding_left_; }
+  void SetPaddingLeft(const Length& v) { SET_VAR(surround_, 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_->padding_right_; }
   void SetPaddingRight(const Length& v) {
-    SET_VAR(surround_, padding_.right_, v);
+    SET_VAR(surround_, 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_->padding_top_; }
+  void SetPaddingTop(const Length& v) { SET_VAR(surround_, 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 1538 matching lines @@
   void SetMarginStart(const Length&);
   void SetMarginEnd(const Length&);
   bool MarginEqual(const ComputedStyle& other) const {
     return MarginTop() == other.MarginTop() &&
            MarginLeft() == other.MarginLeft() &&
            MarginRight() == other.MarginRight() &&
            MarginBottom() == other.MarginBottom();
   }
 
   // Padding utility functions.
-  const LengthBox& Padding() const { return surround_->padding_; }
   const Length& PaddingBefore() const {
-    return Padding().Before(GetWritingMode());
+    return LengthBox::Before(GetWritingMode(), PaddingTop(), PaddingLeft(),
+                             PaddingRight());
   }
   const Length& PaddingAfter() const {
-    return Padding().After(GetWritingMode());
+    return LengthBox::After(GetWritingMode(), PaddingBottom(), PaddingLeft(),
+                            PaddingRight());
   }
   const Length& PaddingStart() const {
-    return Padding().Start(GetWritingMode(), Direction());
+    return LengthBox::Start(GetWritingMode(), Direction(), PaddingTop(),
+                            PaddingLeft(), PaddingRight(), PaddingBottom());
   }
   const Length& PaddingEnd() const {
-    return Padding().end(GetWritingMode(), Direction());
+    return LengthBox::End(GetWritingMode(), Direction(), PaddingTop(),
+                          PaddingLeft(), PaddingRight(), PaddingBottom());
   }
-  const Length& PaddingOver() const { return Padding().Over(GetWritingMode()); }
+  const Length& PaddingOver() const {
+    return LengthBox::Over(GetWritingMode(), PaddingTop(), PaddingRight());
+  }
   const Length& PaddingUnder() const {
-    return Padding().Under(GetWritingMode());
+    return LengthBox::Under(GetWritingMode(), PaddingBottom(), PaddingLeft());
   }
-  bool HasPadding() const { return Padding().NonZero(); }
-  void ResetPadding() { SET_VAR(surround_, padding_, LengthBox(kFixed)); }
-  void SetPadding(const LengthBox& b) { SET_VAR(surround_, padding_, b); }
+  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);
+  }
+  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_);
+  }
+  bool PaddingEqual(const ComputedStyle& other) const {
+    return PaddingTop() == other.PaddingTop() &&

[shend, 2017/04/20 07:07:20]

nit: could be: PaddingEqual(other.Padding());

[nainar, 2017/04/20 07:13:09]

How about I delete this and pass other.Padding() directly at the callsites?

[shend, 2017/04/20 07:20:56]

If you want.

[nainar, 2017/04/21 00:15:19]

Retaining as is because both the option shend@ and I mentioned require the copy
on construct cost. 

+           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(); }
@@ skipping 807 matching lines @@
   pseudo_bits_ |= 1 << (pseudo - kFirstPublicPseudoId);
 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
   return pseudo_bits_ & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h