Cleanup: Only need one bit (not two) to express flow thread state.

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
  * modify it under the terms of the GNU Library General Public
@@ skipping 185 matching lines @@
     // Convenience function for getting to the nearest enclosing box of a LayoutObject.
     LayoutBox* enclosingBox() const;
     LayoutBoxModelObject* enclosingBoxModelObject() const;
 
     LayoutBox* enclosingScrollableBox() const;
 
     // Function to return our enclosing flow thread if we are contained inside one. This
     // function follows the containing block chain.
     LayoutFlowThread* flowThreadContainingBlock() const
     {
-        if (flowThreadState() == NotInsideFlowThread)
+        if (!isInsideFlowThread())
             return 0;
         return locateFlowThreadContainingBlock();
     }
 
 #if ENABLE(ASSERT)
     void setHasAXObject(bool flag) { m_hasAXObject = flag; }
     bool hasAXObject() const { return m_hasAXObject; }
 
     // Helper class forbidding calls to setNeedsLayout() during its lifetime.
     class SetLayoutNeededForbiddenScope {
@@ skipping 63 matching lines @@
     // Helper functions. Dangerous to use!
     void setPreviousSibling(LayoutObject* previous) { m_previous = previous; }
     void setNextSibling(LayoutObject* next) { m_next = next; }
     void setParent(LayoutObject* parent)
     {
         m_parent = parent;
 
         // Only update if our flow thread state is different from our new parent and if we're not a LayoutFlowThread.
         // A LayoutFlowThread is always considered to be inside itself, so it never has to change its state
         // in response to parent changes.
-        FlowThreadState newState = parent ? parent->flowThreadState() : NotInsideFlowThread;
-        if (newState != flowThreadState() && !isLayoutFlowThread())
-            setFlowThreadStateIncludingDescendants(newState);
+        bool insideFlowThread = parent && parent->isInsideFlowThread();
+        if (insideFlowThread != isInsideFlowThread() && !isLayoutFlowThread())
+            setIsInsideFlowThreadIncludingDescendants(insideFlowThread);
     }
 
     //////////////////////////////////////////
 private:
 #if ENABLE(ASSERT)
     bool isSetNeedsLayoutForbidden() const { return m_setNeedsLayoutForbidden; }
     void setNeedsLayoutIsForbidden(bool flag) { m_setNeedsLayoutForbidden = flag; }
 #endif
 
     void addAbsoluteRectForLayer(IntRect& result);
@@ skipping 120 matching lines @@
     }
 
     bool ancestorLineBoxDirty() const { return m_bitfields.ancestorLineBoxDirty(); }
     void setAncestorLineBoxDirty(bool value = true)
     {
         m_bitfields.setAncestorLineBoxDirty(value);
         if (value)
             setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::LineBoxesChanged);
     }
 
-    enum FlowThreadState {
-        NotInsideFlowThread = 0,
-        InsideOutOfFlowThread = 1,
-        InsideInFlowThread = 2,
-    };
+    void setIsInsideFlowThreadIncludingDescendants(bool);
 
-    void setFlowThreadStateIncludingDescendants(FlowThreadState);
-
-    FlowThreadState flowThreadState() const { return m_bitfields.flowThreadState(); }
-    void setFlowThreadState(FlowThreadState state) { m_bitfields.setFlowThreadState(state); }
+    bool isInsideFlowThread() const { return m_bitfields.isInsideFlowThread(); }
+    void setIsInsideFlowThread(bool insideFlowThread) { m_bitfields.setIsInsideFlowThread(insideFlowThread); }
 
     // FIXME: Until all SVG layoutObjects can be subclasses of LayoutSVGModelObject we have
     // to add SVG layoutObject methods to LayoutObject with an ASSERT_NOT_REACHED() default implementation.
     bool isSVG() const { return isOfType(LayoutObjectSVG); }
     bool isSVGRoot() const { return isOfType(LayoutObjectSVGRoot); }
     bool isSVGContainer() const { return isOfType(LayoutObjectSVGContainer); }
     bool isSVGTransformableContainer() const { return isOfType(LayoutObjectSVGTransformableContainer); }
     bool isSVGViewportContainer() const { return isOfType(LayoutObjectSVGViewportContainer); }
     bool isSVGGradientStop() const { return isOfType(LayoutObjectSVGGradientStop); }
     bool isSVGHiddenContainer() const { return isOfType(LayoutObjectSVGHiddenContainer); }
@@ skipping 847 matching lines @@
             , m_isDragging(false)
             , m_hasLayer(false)
             , m_hasOverflowClip(false)
             , m_hasTransformRelatedProperty(false)
             , m_hasReflection(false)
             , m_hasCounterNodeMap(false)
             , m_everHadLayout(false)
             , m_ancestorLineBoxDirty(false)
             , m_layoutDidGetCalledSinceLastFrame(false)
             , m_hasPendingResourceUpdate(false)
+            , m_isInsideFlowThread(false)
             , m_childrenInline(false)
             , m_hasColumns(false)
             , m_alwaysCreateLineBoxesForLayoutInline(false)
             , m_lastBoxDecorationBackgroundObscured(false)
             , m_positionedState(IsStaticallyPositioned)
             , m_selectionState(SelectionNone)
-            , m_flowThreadState(NotInsideFlowThread)
             , m_boxDecorationBackgroundState(NoBoxDecorationBackground)
             , m_fullPaintInvalidationReason(PaintInvalidationNone)
         {
         }
 
         // 32 bits have been used in the first word, and 14 in the second.

[mstensho (USE GERRIT), 2015/05/05 19:09:09]

Note: I counted the bits over and over again, and came to the conclusion that
there used to be 15 bits in the second word, not 14. But _now_ there's going to
be 14. :)

         ADD_BOOLEAN_BITFIELD(selfNeedsLayout, SelfNeedsLayout);
         ADD_BOOLEAN_BITFIELD(shouldInvalidateOverflowForPaint, ShouldInvalidateOverflowForPaint);
         ADD_BOOLEAN_BITFIELD(mayNeedPaintInvalidation, MayNeedPaintInvalidation);
         ADD_BOOLEAN_BITFIELD(shouldInvalidateSelection, ShouldInvalidateSelection);
         ADD_BOOLEAN_BITFIELD(neededLayoutBecauseOfChildren, NeededLayoutBecauseOfChildren);
         ADD_BOOLEAN_BITFIELD(needsPositionedMovementLayout, NeedsPositionedMovementLayout);
         ADD_BOOLEAN_BITFIELD(normalChildNeedsLayout, NormalChildNeedsLayout);
         ADD_BOOLEAN_BITFIELD(posChildNeedsLayout, PosChildNeedsLayout);
         ADD_BOOLEAN_BITFIELD(needsSimplifiedNormalFlowLayout, NeedsSimplifiedNormalFlowLayout);
         ADD_BOOLEAN_BITFIELD(preferredLogicalWidthsDirty, PreferredLogicalWidthsDirty);
@@ skipping 15 matching lines @@
         ADD_BOOLEAN_BITFIELD(hasReflection, HasReflection);
 
         ADD_BOOLEAN_BITFIELD(hasCounterNodeMap, HasCounterNodeMap);
         ADD_BOOLEAN_BITFIELD(everHadLayout, EverHadLayout);
         ADD_BOOLEAN_BITFIELD(ancestorLineBoxDirty, AncestorLineBoxDirty);
 
         ADD_BOOLEAN_BITFIELD(layoutDidGetCalledSinceLastFrame, LayoutDidGetCalledSinceLastFrame);
 
         ADD_BOOLEAN_BITFIELD(hasPendingResourceUpdate, HasPendingResourceUpdate);
 
+        ADD_BOOLEAN_BITFIELD(isInsideFlowThread, IsInsideFlowThread);
+
         // from LayoutBlock
         ADD_BOOLEAN_BITFIELD(childrenInline, ChildrenInline);
         ADD_BOOLEAN_BITFIELD(hasColumns, HasColumns);
 
         // from LayoutInline
         ADD_BOOLEAN_BITFIELD(alwaysCreateLineBoxesForLayoutInline, AlwaysCreateLineBoxesForLayoutInline);
 
         // For slimming-paint.
         ADD_BOOLEAN_BITFIELD(lastBoxDecorationBackgroundObscured, LastBoxDecorationBackgroundObscured);
 
     private:
         unsigned m_positionedState : 2; // PositionedState
         unsigned m_selectionState : 3; // SelectionState
-        unsigned m_flowThreadState : 2; // FlowThreadState
         unsigned m_boxDecorationBackgroundState : 2; // BoxDecorationBackgroundState
         unsigned m_fullPaintInvalidationReason : 5; // PaintInvalidationReason
 
     public:
         bool isOutOfFlowPositioned() const { return m_positionedState == IsOutOfFlowPositioned; }
         bool isRelPositioned() const { return m_positionedState == IsRelativelyPositioned; }
         bool isPositioned() const { return m_positionedState != IsStaticallyPositioned; }
 
         void setPositionedState(int positionState)
         {
             // This mask maps FixedPosition and AbsolutePosition to IsOutOfFlowPositioned, saving one bit.
             m_positionedState = static_cast<PositionedState>(positionState & 0x3);
         }
         void clearPositionedState() { m_positionedState = StaticPosition; }
 
         ALWAYS_INLINE SelectionState selectionState() const { return static_cast<SelectionState>(m_selectionState); }
         ALWAYS_INLINE void setSelectionState(SelectionState selectionState) { m_selectionState = selectionState; }
 
-        ALWAYS_INLINE FlowThreadState flowThreadState() const { return static_cast<FlowThreadState>(m_flowThreadState); }
-        ALWAYS_INLINE void setFlowThreadState(FlowThreadState flowThreadState) { m_flowThreadState = flowThreadState; }
-
         ALWAYS_INLINE BoxDecorationBackgroundState boxDecorationBackgroundState() const { return static_cast<BoxDecorationBackgroundState>(m_boxDecorationBackgroundState); }
         ALWAYS_INLINE void setBoxDecorationBackgroundState(BoxDecorationBackgroundState s) { m_boxDecorationBackgroundState = s; }
 
         PaintInvalidationReason fullPaintInvalidationReason() const { return static_cast<PaintInvalidationReason>(m_fullPaintInvalidationReason); }
         void setFullPaintInvalidationReason(PaintInvalidationReason reason) { m_fullPaintInvalidationReason = reason; }
     };
 
 #undef ADD_BOOLEAN_BITFIELD
 
     LayoutObjectBitfields m_bitfields;
@@ skipping 246 matching lines @@
 void showTree(const blink::LayoutObject*);
 void showLineTree(const blink::LayoutObject*);
 void showLayoutTree(const blink::LayoutObject* object1);
 // We don't make object2 an optional parameter so that showLayoutTree
 // can be called from gdb easily.
 void showLayoutTree(const blink::LayoutObject* object1, const blink::LayoutObject* object2);
 
 #endif
 
 #endif // LayoutObject_h