Use generated getters/setters in ComputedStyle instead of directly accessing fields

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 239 matching lines @@
   StyleSelfAlignmentData ResolvedJustifySelf(
       ItemPosition normal_value_behaviour,
       const ComputedStyle* parent_style = nullptr) const;
 
   StyleDifference VisualInvalidationDiff(const ComputedStyle&) const;
 
   void InheritFrom(const ComputedStyle& inherit_parent,
                    IsAtShadowBoundary = kNotAtShadowBoundary);
   void CopyNonInheritedFromCached(const ComputedStyle&);
 
-  PseudoId StyleType() const { return static_cast<PseudoId>(style_type_); }
-  void SetStyleType(PseudoId style_type) { style_type_ = style_type; }
+  PseudoId StyleType() const { return StyleTypeInternal(); }
+  void SetStyleType(PseudoId style_type) { SetStyleTypeInternal(style_type); }
 
   ComputedStyle* GetCachedPseudoStyle(PseudoId) const;
   ComputedStyle* AddCachedPseudoStyle(PassRefPtr<ComputedStyle>);
   void RemoveCachedPseudoStyle(PseudoId);
 
   const PseudoStyleCache* CachedPseudoStyles() const {
     return cached_pseudo_styles_.get();
   }
 
   /**
@@ skipping 1354 matching lines @@
     return static_cast<TouchAction>(rare_non_inherited_data_->touch_action_);
   }
   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 static_cast<EVerticalAlign>(vertical_align_);
-  }
+  EVerticalAlign VerticalAlign() const { return VerticalAlignInternal(); }
   const Length& GetVerticalAlignLength() const { return box_->VerticalAlign(); }
-  void SetVerticalAlign(EVerticalAlign v) {
-    vertical_align_ = static_cast<unsigned>(v);
-  }
+  void SetVerticalAlign(EVerticalAlign v) { SetVerticalAlignInternal(v); }
   void SetVerticalAlignLength(const Length& length) {
-    SetVerticalAlign(EVerticalAlign::kLength);
+    SetVerticalAlignInternal(EVerticalAlign::kLength);
     SET_VAR(box_, 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_;
   }
@@ skipping 576 matching lines @@
   }
 
   bool InheritedEqual(const ComputedStyle&) const;
   bool NonInheritedEqual(const ComputedStyle&) const;
   inline bool IndependentInheritedEqual(const ComputedStyle&) const;
   inline bool NonIndependentInheritedEqual(const ComputedStyle&) const;
   bool LoadingCustomFontsEqual(const ComputedStyle&) const;
   bool InheritedDataShared(const ComputedStyle&) const;
 
   bool HasChildDependentFlags() const {
-    return EmptyState() || HasExplicitlyInheritedProperties();
+    return EmptyStateInternal() || HasExplicitlyInheritedProperties();
   }
   void CopyChildDependentFlagsFrom(const ComputedStyle&);
 
   // Counters.
   const CounterDirectiveMap* GetCounterDirectives() const;
   CounterDirectiveMap& AccessCounterDirectives();
   const CounterDirectives GetCounterDirectives(
       const AtomicString& identifier) const;
   void ClearIncrementDirectives();
   void ClearResetDirectives();
@@ skipping 48 matching lines @@
   }
   CSSTransitionData& AccessTransitions();
 
   // Callback selectors.
   const Vector<String>& CallbackSelectors() const {
     return rare_non_inherited_data_->callback_selectors_;
   }
   void AddCallbackSelector(const String& selector);
 
   // Non-property flags.
-  bool EmptyState() const { return empty_state_; }
+  bool EmptyState() const { return EmptyStateInternal(); }
   void SetEmptyState(bool b) {
     SetUnique();
-    empty_state_ = b;
+    SetEmptyStateInternal(b);
   }
 
   bool HasInlineTransform() const {
     return rare_non_inherited_data_->has_inline_transform_;
   }
   void SetHasInlineTransform(bool b) {
     SET_VAR(rare_non_inherited_data_, has_inline_transform_, b);
   }
 
   bool HasCompositorProxy() const {
@@ skipping 1367 matching lines @@
 inline bool ComputedStyle::SetTextOrientation(
     TextOrientation text_orientation) {
   if (compareEqual(rare_inherited_data_->text_orientation_, text_orientation))
     return false;
 
   rare_inherited_data_.Access()->text_orientation_ = text_orientation;
   return true;
 }
 
 inline bool ComputedStyle::HasAnyPublicPseudoStyles() const {
-  return pseudo_bits_;
+  return PseudoBitsInternal();

[suzyh_UTC10 (ex-contributor), 2017/04/20 00:30:46]

It looks like pseudo_bits_ is a PseudoId, not a bool. Now that there is an extra
layer of indirection here, is there value in making the conversion explicit?

[nainar, 2017/04/20 03:06:16]

Do you mean cast PseudoBitsInternal() to a bool? 

[suzyh_UTC10 (ex-contributor), 2017/04/20 03:40:26]

I'm actually not sure what the right way to do it is.

I suppose you could also do
return PseudoBitsInternal() != kPseudoIdNone
?

[nainar, 2017/04/20 05:21:49]

That works. Done

 }
 
 inline bool ComputedStyle::HasPseudoStyle(PseudoId pseudo) const {
   DCHECK(pseudo >= kFirstPublicPseudoId);
   DCHECK(pseudo < kFirstInternalPseudoId);
-  return (1 << (pseudo - kFirstPublicPseudoId)) & pseudo_bits_;
+  return (1 << (pseudo - kFirstPublicPseudoId)) & PseudoBitsInternal();
 }
 
 inline void ComputedStyle::SetHasPseudoStyle(PseudoId pseudo) {
   DCHECK(pseudo >= kFirstPublicPseudoId);
   DCHECK(pseudo < kFirstInternalPseudoId);
-  pseudo_bits_ |= 1 << (pseudo - kFirstPublicPseudoId);
+  SetPseudoBitsInternal(static_cast<PseudoId>(
+      PseudoBitsInternal() | 1 << (pseudo - kFirstPublicPseudoId)));

[suzyh_UTC10 (ex-contributor), 2017/04/20 00:30:46]

This is getting nasty. Consider adding a TODO to make the operations on these
enums easier to grok.

[nainar, 2017/04/20 03:06:16]

Added a comment explaining what the code represents here. 

[suzyh_UTC10 (ex-contributor), 2017/04/20 03:40:26]

Hmm nope that's not really much more helpful. Before your patch this code was
bit-twiddling black magic. Now it is obscured bit-twiddling black magic with a
comment that may get out of date with the code. I think remove the comment again
and just add a TODO to fix it up later. (I don't want to block this patch on
fixing it.)

[nainar, 2017/04/20 05:21:49]

Done.

 }
 
 inline bool ComputedStyle::HasPseudoElementStyle() const {
-  return pseudo_bits_ & kElementPseudoIdMask;
+  return PseudoBitsInternal() & kElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h