Changed EPosition to an enum class and renamed its members

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 559 matching lines @@
   void setHasCounterNodeMap(bool hasCounterNodeMap) {
     m_bitfields.setHasCounterNodeMap(hasCounterNodeMap);
   }
 
   bool everHadLayout() const { return m_bitfields.everHadLayout(); }
 
   bool childrenInline() const { return m_bitfields.childrenInline(); }
   void setChildrenInline(bool b) { m_bitfields.setChildrenInline(b); }
 
   bool alwaysCreateLineBoxesForLayoutInline() const {
-    ASSERT(isLayoutInline());
+    DCHECK(isLayoutInline());
     return m_bitfields.alwaysCreateLineBoxesForLayoutInline();
   }
   void setAlwaysCreateLineBoxesForLayoutInline(bool alwaysCreateLineBoxes) {
-    ASSERT(isLayoutInline());
+    DCHECK(isLayoutInline());
     m_bitfields.setAlwaysCreateLineBoxesForLayoutInline(alwaysCreateLineBoxes);
   }
 
   bool ancestorLineBoxDirty() const {
     return m_bitfields.ancestorLineBoxDirty();
   }
   void setAncestorLineBoxDirty(bool value = true) {
     m_bitfields.setAncestorLineBoxDirty(value);
     if (value)
       setNeedsLayoutAndFullPaintInvalidation(
@@ skipping 148 matching lines @@
   bool isInFlowPositioned() const {
     return m_bitfields.isInFlowPositioned();
   }
   bool isRelPositioned() const {
     return m_bitfields.isRelPositioned();
   }
   bool isStickyPositioned() const {
     return m_bitfields.isStickyPositioned();
   }
   bool isFixedPositioned() const {
-    return isOutOfFlowPositioned() && style()->position() == FixedPosition;
+    return isOutOfFlowPositioned() && style()->position() == EPosition::kFixed;
   }
   bool isAbsolutePositioned() const {
-    return isOutOfFlowPositioned() && style()->position() == AbsolutePosition;
+    return isOutOfFlowPositioned() &&
+           style()->position() == EPosition::kAbsolute;
   }
   bool isPositioned() const { return m_bitfields.isPositioned(); }
 
   bool isText() const { return m_bitfields.isText(); }
   bool isBox() const { return m_bitfields.isBox(); }
   bool isInline() const { return m_bitfields.isInline(); }  // inline object
   bool isAtomicInlineLevel() const { return m_bitfields.isAtomicInlineLevel(); }
   bool isHorizontalWritingMode() const {
     return m_bitfields.horizontalWritingMode();
   }
@@ skipping 107 matching lines @@
   void clearNode() { m_node = nullptr; }
 
   // Returns the styled node that caused the generation of this layoutObject.
   // This is the same as node() except for layoutObjects of :before, :after and
   // :first-letter pseudo elements for which their parent node is returned.
   Node* generatingNode() const {
     return isPseudoElement() ? node()->parentOrShadowHostNode() : node();
   }
 
   Document& document() const {
-    ASSERT(m_node || parent());  // crbug.com/402056
+    DCHECK(m_node || parent());  // crbug.com/402056
     return m_node ? m_node->document() : parent()->document();
   }
   LocalFrame* frame() const { return document().frame(); }
 
   virtual LayoutMultiColumnSpannerPlaceholder* spannerPlaceholder() const {
     return nullptr;
   }
   bool isColumnSpanAll() const {
     return style()->getColumnSpan() == ColumnSpanAll && spannerPlaceholder();
   }
@@ skipping 109 matching lines @@
     setNeedsLayout(reason);
     setPreferredLogicalWidthsDirty();
   }
   void setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
       LayoutInvalidationReasonForTracing reason) {
     setNeedsLayoutAndFullPaintInvalidation(reason);
     setPreferredLogicalWidthsDirty();
   }
 
   void setPositionState(EPosition position) {
-    ASSERT((position != AbsolutePosition && position != FixedPosition) ||
-           isBox());
+    DCHECK(
+        (position != EPosition::kAbsolute && position != EPosition::kFixed) ||
+        isBox());
     m_bitfields.setPositionedState(position);
   }
   void clearPositionedState() { m_bitfields.clearPositionedState(); }
 
   void setFloating(bool isFloating) { m_bitfields.setFloating(isFloating); }
   void setInline(bool isInline) { m_bitfields.setIsInline(isInline); }
 
   void setHasBoxDecorationBackground(bool);
 
   enum BackgroundObscurationState {
@@ skipping 286 matching lines @@
   virtual LayoutUnit maxPreferredLogicalWidth() const { return LayoutUnit(); }
 
   const ComputedStyle* style() const { return m_style.get(); }
   ComputedStyle* mutableStyle() const { return m_style.get(); }
 
   // m_style can only be nullptr before the first style is set, thus most
   // callers will never see a nullptr style and should use styleRef().
   // FIXME: It would be better if style() returned a const reference.
   const ComputedStyle& styleRef() const { return mutableStyleRef(); }
   ComputedStyle& mutableStyleRef() const {
-    ASSERT(m_style);
+    DCHECK(m_style);
     return *m_style;
   }
 
   /* The following methods are inlined in LayoutObjectInlines.h */
   inline const ComputedStyle* firstLineStyle() const;
   inline const ComputedStyle& firstLineStyleRef() const;
   inline const ComputedStyle* style(bool firstLine) const;
   inline const ComputedStyle& styleRef(bool firstLine) const;
 
   static inline Color resolveColor(const ComputedStyle& styleToUse,
@@ skipping 648 matching lines @@
   // handled in the code by checking if documentBeingDestroyed() returns 'true'.
   // In this case, the code skips some unneeded expensive operations as we know
   // the tree is not reused (e.g. avoid clearing the containing block's line
   // box).
   virtual void willBeDestroyed();
 
   virtual void insertedIntoTree();
   virtual void willBeRemovedFromTree();
 
   void setDocumentForAnonymous(Document* document) {
-    ASSERT(isAnonymous());
+    DCHECK(isAnonymous());
     m_node = document;
   }
 
   // Add hit-test rects for the layout tree rooted at this node to the provided
   // collection on a per-Layer basis.
   // currentLayer must be the enclosing layer, and layerOffset is the current
   // offset within this layer. Subclass implementations will add any offset for
   // this layoutObject within it's container, so callers should provide only the
   // offset of the container within it's layer.
   // containerRect is a rect that has already been added for the currentLayer
@@ skipping 450 matching lines @@
       return m_positionedState == IsStickyPositioned;
     }
     bool isInFlowPositioned() const {
       return m_positionedState == IsRelativelyPositioned ||
              m_positionedState == IsStickyPositioned;
     }
     bool isPositioned() const {
       return m_positionedState != IsStaticallyPositioned;
     }
 
-    void setPositionedState(int positionState) {
+    void setPositionedState(EPosition positionState) {
       // This maps FixedPosition and AbsolutePosition to
       // IsOutOfFlowPositioned, saving one bit.
       switch (positionState) {
-        case StaticPosition:
+        case EPosition::kStatic:
           m_positionedState = IsStaticallyPositioned;
           break;
-        case RelativePosition:
+        case EPosition::kRelative:
           m_positionedState = IsRelativelyPositioned;
           break;
-        case AbsolutePosition:
-        case FixedPosition:
+        case EPosition::kAbsolute:
+        case EPosition::kFixed:
           m_positionedState = IsOutOfFlowPositioned;
           break;
-        case StickyPosition:
+        case EPosition::kSticky:
           m_positionedState = IsStickyPositioned;
           break;
         default:
           NOTREACHED();
           break;
       }
     }
-    void clearPositionedState() { m_positionedState = StaticPosition; }
+    void clearPositionedState() {
+      m_positionedState = static_cast<unsigned>(EPosition::kStatic);
+    }
 
     ALWAYS_INLINE SelectionState getSelectionState() const {
       return static_cast<SelectionState>(m_selectionState);
     }
     ALWAYS_INLINE void setSelectionState(SelectionState selectionState) {
       m_selectionState = selectionState;
     }
 
     ALWAYS_INLINE BackgroundObscurationState
     getBackgroundObscurationState() const {
@@ skipping 232 matching lines @@
   if (!has3DRendering)
     matrix.makeAffine();
 }
 
 inline int adjustForAbsoluteZoom(int value, LayoutObject* layoutObject) {
   return adjustForAbsoluteZoom(value, layoutObject->style());
 }
 
 inline LayoutUnit adjustLayoutUnitForAbsoluteZoom(LayoutUnit value,
                                                   LayoutObject& layoutObject) {
-  ASSERT(layoutObject.style());
+  DCHECK(layoutObject.style());
   return adjustLayoutUnitForAbsoluteZoom(value, *layoutObject.style());
 }
 
 inline void adjustFloatQuadForAbsoluteZoom(FloatQuad& quad,
                                            LayoutObject& layoutObject) {
   float zoom = layoutObject.style()->effectiveZoom();
   if (zoom != 1)
     quad.scale(1 / zoom, 1 / zoom);
 }
 
 inline void adjustFloatRectForAbsoluteZoom(FloatRect& rect,
                                            LayoutObject& layoutObject) {
   float zoom = layoutObject.style()->effectiveZoom();
   if (zoom != 1)
     rect.scale(1 / zoom, 1 / zoom);
 }
 
 inline double adjustScrollForAbsoluteZoom(double value,
                                           LayoutObject& layoutObject) {
-  ASSERT(layoutObject.style());
+  DCHECK(layoutObject.style());
   return adjustScrollForAbsoluteZoom(value, *layoutObject.style());
 }
 
 #define DEFINE_LAYOUT_OBJECT_TYPE_CASTS(thisType, predicate)           \
   DEFINE_TYPE_CASTS(thisType, LayoutObject, object, object->predicate, \
                     object.predicate)
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the blink namespace for ease of invocation from gdb.
 CORE_EXPORT void showTree(const blink::LayoutObject*);
 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