Blink rename follow-up: Rename remaining |m_...| field names in LayoutObject.

third_party/WebKit/Source/core/layout/LayoutObject.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2012 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 164 matching lines @@
 // ***** INTRINSIC SIZES / PREFERRED LOGICAL WIDTHS *****
 // The preferred logical widths are the intrinsic sizes of this element
 // (https://drafts.csswg.org/css-sizing-3/#intrinsic). Intrinsic sizes depend
 // mostly on the content and a limited set of style properties (e.g. any
 // font-related property for text, 'min-width'/'max-width',
 // 'min-height'/'max-height').
 //
 // Those widths are used to determine the final layout logical width, which
 // depends on the layout algorithm used and the available logical width.
 //
-// LayoutObject only has getters for the widths (minPreferredLogicalWidth and
-// maxPreferredLogicalWidth). However the storage for them is in LayoutBox
-// (see m_minPreferredLogicalWidth and m_maxPreferredLogicalWidth). This is
+// LayoutObject only has getters for the widths (MinPreferredLogicalWidth and
+// MaxPreferredLogicalWidth). However the storage for them is in LayoutBox (see
+// min_preferred_logical_width_ and max_preferred_logical_width_). This is
 // because only boxes implementing the full box model have a need for them.
 // Because LayoutBlockFlow's intrinsic widths rely on the underlying text
-// content, LayoutBlockFlow may call LayoutText::computePreferredLogicalWidths.
+// content, LayoutBlockFlow may call LayoutText::ComputePreferredLogicalWidths.
 //
 // The 2 widths are computed lazily during layout when the getters are called.
-// The computation is done by calling computePreferredLogicalWidths() behind the
+// The computation is done by calling ComputePreferredLogicalWidths() behind the
 // scene. The boolean used to control the lazy recomputation is
-// preferredLogicalWidthsDirty.
+// PreferredLogicalWidthsDirty.
 //
 // See the individual getters below for more details about what each width is.
 class CORE_EXPORT LayoutObject : public ImageResourceObserver,
                                  public DisplayItemClient {
   friend class LayoutObjectChildList;
   FRIEND_TEST_ALL_PREFIXES(LayoutObjectTest, MutableForPaintingClearPaintFlags);
   friend class VisualRectMappingTest;
   WTF_MAKE_NONCOPYABLE(LayoutObject);
 
  public:
@@ skipping 191 matching lines @@
   // For SlimmingPaintInvalidation/SPv2 only.
   // The ObjectPaintProperties structure holds references to the property tree
   // nodes that are created by the layout object. The property nodes should only
   // be updated during InPrePaint phase of the document lifecycle.
   const ObjectPaintProperties* PaintProperties() const {
     DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
     return rare_paint_data_ ? rare_paint_data_->PaintProperties() : nullptr;
   }
 
   // The complete set of property nodes that should be used as a starting point
-  // to paint this LayoutObject. See: m_localBorderBoxProperties comment.
+  // to paint this LayoutObject. See also the comment for
+  // RarePaintData::local_border_box_properties_.
   const PropertyTreeState* LocalBorderBoxProperties() const {
     DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
     if (rare_paint_data_)
       return rare_paint_data_->LocalBorderBoxProperties();
     return nullptr;
   }
 
   // The complete set of property nodes that should be used as a starting point
   // to paint contents of this LayoutObject.
   PropertyTreeState ContentsProperties() const;
@@ skipping 48 matching lines @@
                              unsigned depth = 0) const;
 #endif
 
   // This function is used to create the appropriate LayoutObject based
   // on the style, in particular 'display' and 'content'.
   // "display: none" or "display: contents" are the only times this function
   // will return nullptr.
   //
   // For renderer creation, the inline-* values create the same renderer
   // as the non-inline version. The difference is that inline-* sets
-  // m_isInline during initialization. This means that
+  // is_inline_ during initialization. This means that
   // "display: inline-table" creates a LayoutTable, like "display: table".
   //
   // Ideally every Element::createLayoutObject would call this function to
   // respond to 'display' but there are deep rooted assumptions about
   // which LayoutObject is created on a fair number of Elements. This
   // function also doesn't handle the default association between a tag
   // and its renderer (e.g. <iframe> creates a LayoutIFrame even if the
   // initial 'display' value is inline).
   static LayoutObject* CreateObject(Element*, const ComputedStyle&);
 
@@ skipping 1632 matching lines @@
   }
 
   RarePaintData& EnsureRarePaintData();
   RarePaintData* GetRarePaintData() const { return rare_paint_data_.get(); }
 
  private:
   // Used only by applyFirstLineChanges to get a first line style based off of a
   // given new style, without accessing the cache.
   PassRefPtr<ComputedStyle> UncachedFirstLineStyle() const;
 
-  // Adjusts a visual rect in the space of |m_visualRect| to be in the
-  // space of the |paintInvalidationContainer|, if needed. They can be different
-  // only if |paintInvalidationContainer| is a composited scroller.
+  // Adjusts a visual rect in the space of |visual_rect_| to be in the space of
+  // the |paint_invalidation_container|, if needed. They can be different only
+  // if |paint_invalidation_container| is a composited scroller.
   void AdjustVisualRectForCompositedScrolling(
       LayoutRect&,
       const LayoutBoxModelObject& paint_invalidation_container) const;
 
   FloatQuad LocalToAncestorQuadInternal(const FloatQuad&,
                                         const LayoutBoxModelObject* ancestor,
                                         MapCoordinatesFlags = 0) const;
 
   void ClearLayoutRootIfNeeded() const;
 
@@ skipping 65 matching lines @@
 
   LayoutObject* parent_;
   LayoutObject* previous_;
   LayoutObject* next_;
 
 #if DCHECK_IS_ON()
   unsigned has_ax_object_ : 1;
   unsigned set_needs_layout_forbidden_ : 1;
 #endif
 
-#define ADD_BOOLEAN_BITFIELD(name, Name) \
- private:                                \
-  unsigned m_##name : 1;                 \
-                                         \
- public:                                 \
-  bool name() const { return m_##name; } \
-  void Set##Name(bool name) { m_##name = name; }
+#define ADD_BOOLEAN_BITFIELD(field_name_, MethodNameBase) \
+ private:                                                 \
+  unsigned field_name_ : 1;                               \
+                                                          \
+ public:                                                  \
+  bool MethodNameBase() const { return field_name_; }     \
+  void Set##MethodNameBase(bool new_value) { field_name_ = new_value; }
 
   class LayoutObjectBitfields {
     enum PositionedState {
       kIsStaticallyPositioned = 0,
       kIsRelativelyPositioned = 1,
       kIsOutOfFlowPositioned = 2,
       kIsStickyPositioned = 3,
     };
 
    public:
     // LayoutObjectBitfields holds all the boolean values for LayoutObject.
     //
     // This is done to promote better packing on LayoutObject (at the expense of
     // preventing bit field packing for the subclasses). Classes concerned about
     // packing and memory use should hoist their boolean to this class. See
     // below the field from sub-classes (e.g. childrenInline).
     //
     // Some of those booleans are caches of ComputedStyle values (e.g.
     // positionState). This enables better memory locality and thus better
     // performance.
     //
     // This class is an artifact of the WebKit era where LayoutObject wasn't
     // allowed to grow and each sub-class was strictly monitored for memory
     // increase. Our measurements indicate that the size of LayoutObject and
     // subsequent classes do not impact memory or speed in a significant
     // manner. This is based on growing LayoutObject in
     // https://codereview.chromium.org/44673003 and subsequent relaxations
     // of the memory constraints on layout objects.
     LayoutObjectBitfields(Node* node)
-        : m_SelfNeedsLayout(false),
-          m_NeedsPositionedMovementLayout(false),
-          m_NormalChildNeedsLayout(false),
-          m_PosChildNeedsLayout(false),
-          m_NeedsSimplifiedNormalFlowLayout(false),
-          m_SelfNeedsOverflowRecalcAfterStyleChange(false),
-          m_ChildNeedsOverflowRecalcAfterStyleChange(false),
-          m_PreferredLogicalWidthsDirty(false),
-          m_MayNeedPaintInvalidation(false),
-          m_MayNeedPaintInvalidationSubtree(false),
-          m_MayNeedPaintInvalidationAnimatedBackgroundImage(false),
-          m_NeedsPaintOffsetAndVisualRectUpdate(false),
-          m_ShouldInvalidateSelection(false),
-          m_Floating(false),
-          m_IsAnonymous(!node),
-          m_IsText(false),
-          m_IsBox(false),
-          m_IsInline(true),
-          m_IsAtomicInlineLevel(false),
-          m_HorizontalWritingMode(true),
-          m_HasLayer(false),
-          m_HasOverflowClip(false),
-          m_HasTransformRelatedProperty(false),
-          m_HasReflection(false),
-          m_CanContainFixedPositionObjects(false),
-          m_HasCounterNodeMap(false),
-          m_EverHadLayout(false),
-          m_AncestorLineBoxDirty(false),
-          m_IsInsideFlowThread(false),
-          m_SubtreeChangeListenerRegistered(false),
-          m_NotifiedOfSubtreeChange(false),
-          m_ConsumesSubtreeChangeNotification(false),
-          m_ChildrenInline(false),
-          m_ContainsInlineWithOutlineAndContinuation(false),
-          m_AlwaysCreateLineBoxesForLayoutInline(false),
-          m_PreviousBackgroundObscured(false),
-          m_IsBackgroundAttachmentFixedObject(false),
-          m_IsScrollAnchorObject(false),
-          m_ScrollAnchorDisablingStyleChanged(false),
-          m_HasBoxDecorationBackground(false),
-          m_HasPreviousLocationInBacking(false),
-          m_HasPreviousSelectionVisualRect(false),
-          m_NeedsPaintPropertyUpdate(true),
-          m_SubtreeNeedsPaintPropertyUpdate(true),
-          m_DescendantNeedsPaintPropertyUpdate(true),
-          m_BackgroundChangedSinceLastPaintInvalidation(false),
-          m_OutlineMayBeAffectedByDescendants(false),
-          m_PreviousOutlineMayBeAffectedByDescendants(false),
+        : self_needs_layout_(false),
+          needs_positioned_movement_layout_(false),
+          normal_child_needs_layout_(false),
+          pos_child_needs_layout_(false),
+          needs_simplified_normal_flow_layout_(false),
+          self_needs_overflow_recalc_after_style_change_(false),
+          child_needs_overflow_recalc_after_style_change_(false),
+          preferred_logical_widths_dirty_(false),
+          may_need_paint_invalidation_(false),
+          may_need_paint_invalidation_subtree_(false),
+          may_need_paint_invalidation_animated_background_image_(false),
+          needs_paint_offset_and_visual_rect_update_(false),
+          should_invalidate_selection_(false),
+          floating_(false),
+          is_anonymous_(!node),
+          is_text_(false),
+          is_box_(false),
+          is_inline_(true),
+          is_atomic_inline_level_(false),
+          horizontal_writing_mode_(true),
+          has_layer_(false),
+          has_overflow_clip_(false),
+          has_transform_related_property_(false),
+          has_reflection_(false),
+          can_contain_fixed_position_objects_(false),
+          has_counter_node_map_(false),
+          ever_had_layout_(false),
+          ancestor_line_box_dirty_(false),
+          is_inside_flow_thread_(false),
+          subtree_change_listener_registered_(false),
+          notified_of_subtree_change_(false),
+          consumes_subtree_change_notification_(false),
+          children_inline_(false),
+          contains_inline_with_outline_and_continuation_(false),
+          always_create_line_boxes_for_layout_inline_(false),
+          previous_background_obscured_(false),
+          is_background_attachment_fixed_object_(false),
+          is_scroll_anchor_object_(false),
+          scroll_anchor_disabling_style_changed_(false),
+          has_box_decoration_background_(false),
+          has_previous_location_in_backing_(false),
+          has_previous_selection_visual_rect_(false),
+          needs_paint_property_update_(true),
+          subtree_needs_paint_property_update_(true),
+          descendant_needs_paint_property_update_(true),
+          background_changed_since_last_paint_invalidation_(false),
+          outline_may_be_affected_by_descendants_(false),
+          previous_outline_may_be_affected_by_descendants_(false),
           positioned_state_(kIsStaticallyPositioned),
           selection_state_(SelectionNone),
           background_obscuration_state_(kBackgroundObscurationStatusInvalid),
           full_paint_invalidation_reason_(kPaintInvalidationNone) {}
 
     // Self needs layout means that this layout object is marked for a full
     // layout. This is the default layout but it is expensive as it recomputes
     // everything. For CSS boxes, this includes the width (laying out the line
     // boxes again), the margins (due to block collapsing margins), the
     // positions, the height and the potential overflow.
-    ADD_BOOLEAN_BITFIELD(SelfNeedsLayout, SelfNeedsLayout);
+    ADD_BOOLEAN_BITFIELD(self_needs_layout_, SelfNeedsLayout);
 
     // A positioned movement layout is a specialized type of layout used on
     // positioned objects that only visually moved. This layout is used when
     // changing 'top'/'left' on a positioned element or margins on an
     // out-of-flow one. Because the following operations don't impact the size
     // of the object or sibling LayoutObjects, this layout is very lightweight.
     //
     // Positioned movement layout is implemented in
     // LayoutBlock::simplifiedLayout.
-    ADD_BOOLEAN_BITFIELD(NeedsPositionedMovementLayout,
+    ADD_BOOLEAN_BITFIELD(needs_positioned_movement_layout_,
                          NeedsPositionedMovementLayout);
 
     // This boolean is set when a normal flow ('position' == static || relative)
     // child requires layout (but this object doesn't). Due to the nature of
     // CSS, laying out a child can cause the parent to resize (e.g., if 'height'
     // is auto).
-    ADD_BOOLEAN_BITFIELD(NormalChildNeedsLayout, NormalChildNeedsLayout);
+    ADD_BOOLEAN_BITFIELD(normal_child_needs_layout_, NormalChildNeedsLayout);
 
     // This boolean is set when an out-of-flow positioned ('position' == fixed
     // || absolute) child requires layout (but this object doesn't).
-    ADD_BOOLEAN_BITFIELD(PosChildNeedsLayout, PosChildNeedsLayout);
+    ADD_BOOLEAN_BITFIELD(pos_child_needs_layout_, PosChildNeedsLayout);
 
     // Simplified normal flow layout only relayouts the normal flow children,
     // ignoring the out-of-flow descendants.
     //
     // The implementation of this layout is in
     // LayoutBlock::simplifiedNormalFlowLayout.
-    ADD_BOOLEAN_BITFIELD(NeedsSimplifiedNormalFlowLayout,
+    ADD_BOOLEAN_BITFIELD(needs_simplified_normal_flow_layout_,
                          NeedsSimplifiedNormalFlowLayout);
 
     // Some properties only have a visual impact and don't impact the actual
     // layout position and sizes of the object. An example of this is the
     // 'transform' property, who doesn't modify the layout but gets applied at
     // paint time. Setting this flag only recomputes the overflow information.
-    ADD_BOOLEAN_BITFIELD(SelfNeedsOverflowRecalcAfterStyleChange,
+    ADD_BOOLEAN_BITFIELD(self_needs_overflow_recalc_after_style_change_,
                          SelfNeedsOverflowRecalcAfterStyleChange);
 
     // This flag is set on the ancestor of a LayoutObject needing
     // selfNeedsOverflowRecalcAfterStyleChange. This is needed as a descendant
     // overflow can bleed into its containing block's so we have to recompute it
     // in some cases.
-    ADD_BOOLEAN_BITFIELD(ChildNeedsOverflowRecalcAfterStyleChange,
+    ADD_BOOLEAN_BITFIELD(child_needs_overflow_recalc_after_style_change_,
                          ChildNeedsOverflowRecalcAfterStyleChange);
 
     // This boolean marks preferred logical widths for lazy recomputation.
     //
     // See INTRINSIC SIZES / PREFERRED LOGICAL WIDTHS above about those
     // widths.
-    ADD_BOOLEAN_BITFIELD(PreferredLogicalWidthsDirty,
+    ADD_BOOLEAN_BITFIELD(preferred_logical_widths_dirty_,
                          PreferredLogicalWidthsDirty);
 
-    ADD_BOOLEAN_BITFIELD(MayNeedPaintInvalidation, MayNeedPaintInvalidation);
-    ADD_BOOLEAN_BITFIELD(MayNeedPaintInvalidationSubtree,
+    ADD_BOOLEAN_BITFIELD(may_need_paint_invalidation_,
+                         MayNeedPaintInvalidation);
+    ADD_BOOLEAN_BITFIELD(may_need_paint_invalidation_subtree_,
                          MayNeedPaintInvalidationSubtree);
-    ADD_BOOLEAN_BITFIELD(MayNeedPaintInvalidationAnimatedBackgroundImage,
+    ADD_BOOLEAN_BITFIELD(may_need_paint_invalidation_animated_background_image_,
                          MayNeedPaintInvalidationAnimatedBackgroundImage);
-    ADD_BOOLEAN_BITFIELD(NeedsPaintOffsetAndVisualRectUpdate,
+    ADD_BOOLEAN_BITFIELD(needs_paint_offset_and_visual_rect_update_,
                          NeedsPaintOffsetAndVisualRectUpdate);
-    ADD_BOOLEAN_BITFIELD(ShouldInvalidateSelection, ShouldInvalidateSelection);
+    ADD_BOOLEAN_BITFIELD(should_invalidate_selection_,
+                         ShouldInvalidateSelection);
 
     // This boolean is the cached value of 'float'
     // (see ComputedStyle::isFloating).
-    ADD_BOOLEAN_BITFIELD(Floating, Floating);
+    ADD_BOOLEAN_BITFIELD(floating_, Floating);
 
-    ADD_BOOLEAN_BITFIELD(IsAnonymous, IsAnonymous);
-    ADD_BOOLEAN_BITFIELD(IsText, IsText);
-    ADD_BOOLEAN_BITFIELD(IsBox, IsBox);
+    ADD_BOOLEAN_BITFIELD(is_anonymous_, IsAnonymous);
+    ADD_BOOLEAN_BITFIELD(is_text_, IsText);
+    ADD_BOOLEAN_BITFIELD(is_box_, IsBox);
 
     // This boolean represents whether the LayoutObject is 'inline-level'
     // (a CSS concept). Inline-level boxes are laid out inside a line. If
     // unset, the box is 'block-level' and thus stack on top of its
     // siblings (think of paragraphs).
-    ADD_BOOLEAN_BITFIELD(IsInline, IsInline);
+    ADD_BOOLEAN_BITFIELD(is_inline_, IsInline);
 
     // This boolean is set if the element is an atomic inline-level box.
     //
     // In CSS, atomic inline-level boxes are laid out on a line but they
     // are opaque from the perspective of line layout. This means that they
     // can't be split across lines like normal inline boxes (LayoutInline).
     // Examples of atomic inline-level elements: inline tables, inline
     // blocks and replaced inline elements.
     // See http://www.w3.org/TR/CSS2/visuren.html#inline-boxes.
     //
     // Our code is confused about the use of this boolean and confuses it
     // with being replaced (see LayoutReplaced about this).
     // TODO(jchaffraix): We should inspect callers and clarify their use.
     // TODO(jchaffraix): We set this boolean for replaced elements that are
     // not inline but shouldn't (crbug.com/567964). This should be enforced.
-    ADD_BOOLEAN_BITFIELD(IsAtomicInlineLevel, IsAtomicInlineLevel);
-    ADD_BOOLEAN_BITFIELD(HorizontalWritingMode, HorizontalWritingMode);
+    ADD_BOOLEAN_BITFIELD(is_atomic_inline_level_, IsAtomicInlineLevel);
+    ADD_BOOLEAN_BITFIELD(horizontal_writing_mode_, HorizontalWritingMode);
 
-    ADD_BOOLEAN_BITFIELD(HasLayer, HasLayer);
+    ADD_BOOLEAN_BITFIELD(has_layer_, HasLayer);
 
     // This boolean is set if overflow != 'visible'.
     // This means that this object may need an overflow clip to be applied
     // at paint time to its visual overflow (see OverflowModel for more
     // details). Only set for LayoutBoxes and descendants.
-    ADD_BOOLEAN_BITFIELD(HasOverflowClip, HasOverflowClip);
+    ADD_BOOLEAN_BITFIELD(has_overflow_clip_, HasOverflowClip);
 
     // This boolean is the cached value from
     // ComputedStyle::hasTransformRelatedProperty.
-    ADD_BOOLEAN_BITFIELD(HasTransformRelatedProperty,
+    ADD_BOOLEAN_BITFIELD(has_transform_related_property_,
                          HasTransformRelatedProperty);
-    ADD_BOOLEAN_BITFIELD(HasReflection, HasReflection);
+    ADD_BOOLEAN_BITFIELD(has_reflection_, HasReflection);
 
     // This boolean is used to know if this LayoutObject is a container for
     // fixed position descendants.
-    ADD_BOOLEAN_BITFIELD(CanContainFixedPositionObjects,
+    ADD_BOOLEAN_BITFIELD(can_contain_fixed_position_objects_,
                          CanContainFixedPositionObjects);
 
     // This boolean is used to know if this LayoutObject has one (or more)
     // associated CounterNode(s).
     // See class comment in LayoutCounter.h for more detail.
-    ADD_BOOLEAN_BITFIELD(HasCounterNodeMap, HasCounterNodeMap);
+    ADD_BOOLEAN_BITFIELD(has_counter_node_map_, HasCounterNodeMap);
 
-    ADD_BOOLEAN_BITFIELD(EverHadLayout, EverHadLayout);
-    ADD_BOOLEAN_BITFIELD(AncestorLineBoxDirty, AncestorLineBoxDirty);
+    ADD_BOOLEAN_BITFIELD(ever_had_layout_, EverHadLayout);
+    ADD_BOOLEAN_BITFIELD(ancestor_line_box_dirty_, AncestorLineBoxDirty);
 
-    ADD_BOOLEAN_BITFIELD(IsInsideFlowThread, IsInsideFlowThread);
+    ADD_BOOLEAN_BITFIELD(is_inside_flow_thread_, IsInsideFlowThread);
 
-    ADD_BOOLEAN_BITFIELD(SubtreeChangeListenerRegistered,
+    ADD_BOOLEAN_BITFIELD(subtree_change_listener_registered_,
                          SubtreeChangeListenerRegistered);
-    ADD_BOOLEAN_BITFIELD(NotifiedOfSubtreeChange, NotifiedOfSubtreeChange);
-    ADD_BOOLEAN_BITFIELD(ConsumesSubtreeChangeNotification,
+    ADD_BOOLEAN_BITFIELD(notified_of_subtree_change_, NotifiedOfSubtreeChange);
+    ADD_BOOLEAN_BITFIELD(consumes_subtree_change_notification_,
                          ConsumesSubtreeChangeNotification);
 
     // from LayoutBlock
-    ADD_BOOLEAN_BITFIELD(ChildrenInline, ChildrenInline);
+    ADD_BOOLEAN_BITFIELD(children_inline_, ChildrenInline);
 
     // from LayoutBlockFlow
-    ADD_BOOLEAN_BITFIELD(ContainsInlineWithOutlineAndContinuation,
+    ADD_BOOLEAN_BITFIELD(contains_inline_with_outline_and_continuation_,
                          ContainsInlineWithOutlineAndContinuation);
 
     // from LayoutInline
-    ADD_BOOLEAN_BITFIELD(AlwaysCreateLineBoxesForLayoutInline,
+    ADD_BOOLEAN_BITFIELD(always_create_line_boxes_for_layout_inline_,
                          AlwaysCreateLineBoxesForLayoutInline);
 
     // Background obscuration status of the previous frame.
-    ADD_BOOLEAN_BITFIELD(PreviousBackgroundObscured,
+    ADD_BOOLEAN_BITFIELD(previous_background_obscured_,
                          PreviousBackgroundObscured);
 
-    ADD_BOOLEAN_BITFIELD(IsBackgroundAttachmentFixedObject,
+    ADD_BOOLEAN_BITFIELD(is_background_attachment_fixed_object_,
                          IsBackgroundAttachmentFixedObject);
-    ADD_BOOLEAN_BITFIELD(IsScrollAnchorObject, IsScrollAnchorObject);
+    ADD_BOOLEAN_BITFIELD(is_scroll_anchor_object_, IsScrollAnchorObject);
 
     // Whether changes in this LayoutObject's CSS properties since the last
     // layout should suppress any adjustments that would be made during the next
     // layout by ScrollAnchor objects for which this LayoutObject is on the path
     // from the anchor node to the scroller.
     // See http://bit.ly/sanaclap for more info.
-    ADD_BOOLEAN_BITFIELD(ScrollAnchorDisablingStyleChanged,
+    ADD_BOOLEAN_BITFIELD(scroll_anchor_disabling_style_changed_,
                          ScrollAnchorDisablingStyleChanged);
 
-    ADD_BOOLEAN_BITFIELD(HasBoxDecorationBackground,
+    ADD_BOOLEAN_BITFIELD(has_box_decoration_background_,
                          HasBoxDecorationBackground);
 
-    ADD_BOOLEAN_BITFIELD(HasPreviousLocationInBacking,
+    ADD_BOOLEAN_BITFIELD(has_previous_location_in_backing_,
                          HasPreviousLocationInBacking);
-    ADD_BOOLEAN_BITFIELD(HasPreviousSelectionVisualRect,
+    ADD_BOOLEAN_BITFIELD(has_previous_selection_visual_rect_,
                          HasPreviousSelectionVisualRect);
 
     // Whether the paint properties need to be updated. For more details, see
     // LayoutObject::needsPaintPropertyUpdate().
-    ADD_BOOLEAN_BITFIELD(NeedsPaintPropertyUpdate, NeedsPaintPropertyUpdate);
+    ADD_BOOLEAN_BITFIELD(needs_paint_property_update_,
+                         NeedsPaintPropertyUpdate);
     // Whether paint properties of the whole subtree need to be updated.
-    ADD_BOOLEAN_BITFIELD(SubtreeNeedsPaintPropertyUpdate,
+    ADD_BOOLEAN_BITFIELD(subtree_needs_paint_property_update_,
                          SubtreeNeedsPaintPropertyUpdate)
     // Whether the paint properties of a descendant need to be updated. For more
     // details, see LayoutObject::descendantNeedsPaintPropertyUpdate().
-    ADD_BOOLEAN_BITFIELD(DescendantNeedsPaintPropertyUpdate,
+    ADD_BOOLEAN_BITFIELD(descendant_needs_paint_property_update_,
                          DescendantNeedsPaintPropertyUpdate);
 
-    ADD_BOOLEAN_BITFIELD(BackgroundChangedSinceLastPaintInvalidation,
+    ADD_BOOLEAN_BITFIELD(background_changed_since_last_paint_invalidation_,
                          BackgroundChangedSinceLastPaintInvalidation);
 
     // Whether shape of outline may be affected by any descendants. This is
     // updated before paint invalidation, checked during paint invalidation.
-    ADD_BOOLEAN_BITFIELD(OutlineMayBeAffectedByDescendants,
+    ADD_BOOLEAN_BITFIELD(outline_may_be_affected_by_descendants_,
                          OutlineMayBeAffectedByDescendants);
     // The outlineMayBeAffectedByDescendants status of the last paint
     // invalidation.
-    ADD_BOOLEAN_BITFIELD(PreviousOutlineMayBeAffectedByDescendants,
+    ADD_BOOLEAN_BITFIELD(previous_outline_may_be_affected_by_descendants_,
                          PreviousOutlineMayBeAffectedByDescendants);
 
    protected:
     // Use protected to avoid warning about unused variable.
     unsigned unused_bits_ : 4;
 
    private:
     // This is the cached 'position' value of this object
     // (see ComputedStyle::position).
     unsigned positioned_state_ : 2;  // PositionedState
@@ skipping 321 matching lines @@
 CORE_EXPORT void showLineTree(const blink::LayoutObject*);
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 CORE_EXPORT void showLayoutTree(const blink::LayoutObject* object1,
                                 const blink::LayoutObject* object2);
 
 #endif
 
 #endif  // LayoutObject_h