Changed EPosition to an enum class and renamed its members

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 197 matching lines @@
       if (!oldStyle->hasOutOfFlowPosition() &&
           newStyle.hasOutOfFlowPosition()) {
         // We're about to go out of flow. Before that takes place, we need to
         // mark the current containing block chain for preferred widths
         // recalculation.
         setNeedsLayoutAndPrefWidthsRecalc(
             LayoutInvalidationReason::StyleChange);
       } else {
         markContainerChainForLayout();
       }
-      if (oldStyle->position() == StaticPosition)
+      if (oldStyle->position() == EPosition::kStatic)
         setShouldDoFullPaintInvalidation();
       else if (newStyle.hasOutOfFlowPosition())
         parent()->setChildNeedsLayout();
       if (isFloating() && !isOutOfFlowPositioned() &&
           newStyle.hasOutOfFlowPosition())
         removeFloatingOrPositionedChildFromBlockLists();
     }
     // FIXME: This branch runs when !oldStyle, which means that layout was never
     // called so what's the point in invalidating the whole view that we never
     // painted?
@@ skipping 463 matching lines @@
           } else {
             parentBox = nullptr;
           }
         }
       }
     }
   }
 
   // If we are fixed-position and stick to the viewport, it is useless to
   // scroll the parent.
-  if (style()->position() == FixedPosition &&
+  if (style()->position() == EPosition::kFixed &&
       containerForFixedPosition() == view()) {
     return;
   }
 
   if (frame()->page()->autoscrollController().autoscrollInProgress())
     parentBox = enclosingScrollableBox();
 
   if (parentBox)
     parentBox->scrollRectToVisible(newRect, alignX, alignY, scrollType,
                                    makeVisibleInVisualViewport);
@@ skipping 820 matching lines @@
     return false;
   if (hasClipPath())
     return false;
   if (style()->hasBlendMode())
     return false;
   return backgroundRect(BackgroundKnownOpaqueRect).contains(localRect);
 }
 
 static bool isCandidateForOpaquenessTest(const LayoutBox& childBox) {
   const ComputedStyle& childStyle = childBox.styleRef();
-  if (childStyle.position() != StaticPosition &&
+  if (childStyle.position() != EPosition::kStatic &&
       childBox.containingBlock() != childBox.parent())
     return false;
   if (childStyle.visibility() != EVisibility::kVisible ||
       childStyle.shapeOutside())
     return false;
   if (childBox.size().isZero())
     return false;
   if (PaintLayer* childLayer = childBox.layer()) {
     // FIXME: perhaps this could be less conservative?
     if (childLayer->compositingState() != NotComposited)
@@ skipping 354 matching lines @@
 
 LayoutUnit LayoutBox::containingBlockLogicalHeightForGetComputedStyle() const {
   if (hasOverrideContainingBlockLogicalHeight())
     return overrideContainingBlockContentLogicalHeight();
 
   if (!isPositioned())
     return containingBlockLogicalHeightForContent(ExcludeMarginBorderPadding);
 
   LayoutBoxModelObject* cb = toLayoutBoxModelObject(container());
   LayoutUnit height = containingBlockLogicalHeightForPositioned(cb);
-  if (styleRef().position() != AbsolutePosition)
+  if (styleRef().position() != EPosition::kAbsolute)
     height -= cb->paddingLogicalHeight();
   return height;
 }
 
 LayoutUnit LayoutBox::containingBlockLogicalWidthForContent() const {
   if (hasOverrideContainingBlockLogicalWidth())
     return overrideContainingBlockContentLogicalWidth();
 
   LayoutBlock* cb = containingBlock();
   if (isOutOfFlowPositioned())
@@ skipping 45 matching lines @@
   }
 
   // Use the content box logical height as specified by the style.
   return cb->adjustContentBoxLogicalHeightForBoxSizing(
       LayoutUnit(logicalHeightLength.value()));
 }
 
 void LayoutBox::mapLocalToAncestor(const LayoutBoxModelObject* ancestor,
                                    TransformState& transformState,
                                    MapCoordinatesFlags mode) const {
-  bool isFixedPos = style()->position() == FixedPosition;
+  bool isFixedPos = style()->position() == EPosition::kFixed;
 
   // If this box has a transform or contains paint, it acts as a fixed position
   // container for fixed descendants, and may itself also be fixed position. So
   // propagate 'fixed' up only if this box is fixed position.
   if (style()->canContainFixedPositionObjects() && !isFixedPos)
     mode &= ~IsFixed;
   else if (isFixedPos)
     mode |= IsFixed;
 
   LayoutBoxModelObject::mapLocalToAncestor(ancestor, transformState, mode);
 }
 
 void LayoutBox::mapAncestorToLocal(const LayoutBoxModelObject* ancestor,
                                    TransformState& transformState,
                                    MapCoordinatesFlags mode) const {
   if (this == ancestor)
     return;
 
-  bool isFixedPos = style()->position() == FixedPosition;
+  bool isFixedPos = style()->position() == EPosition::kFixed;
 
   // If this box has a transform or contains paint, it acts as a fixed position
   // container for fixed descendants, and may itself also be fixed position. So
   // propagate 'fixed' up only if this box is fixed position.
   if (style()->canContainFixedPositionObjects() && !isFixedPos)
     mode &= ~IsFixed;
   else if (isFixedPos)
     mode |= IsFixed;
 
   LayoutBoxModelObject::mapAncestorToLocal(ancestor, transformState, mode);
 }
 
 LayoutSize LayoutBox::offsetFromContainer(const LayoutObject* o) const {
   ASSERT(o == container());
 
   LayoutSize offset;
   if (isInFlowPositioned())
     offset += offsetForInFlowPosition();
 
   offset += physicalLocationOffset();
 
   if (o->hasOverflowClip())
     offset -= toLayoutBox(o)->scrolledContentOffset();
 
-  if (style()->position() == AbsolutePosition && o->isInFlowPositioned() &&
+  if (style()->position() == EPosition::kAbsolute && o->isInFlowPositioned() &&
       o->isLayoutInline())
     offset += toLayoutInline(o)->offsetForInFlowPositionedInline(*this);
 
   return offset;
 }
 
 InlineBox* LayoutBox::createInlineBox() {
   return new InlineBox(LineLayoutItem(this));
 }
 
@@ skipping 351 matching lines @@
     // TODO(wkorman): Generalize Ruby specialization and/or document more
     // clearly. See the accompanying specialization in
     // LayoutInline::mapToVisualRectInAncestorSpace.
     topLeft.moveBy(physicalLocation());
   } else {
     topLeft.moveBy(location());
   }
 
   const ComputedStyle& styleToUse = styleRef();
   EPosition position = styleToUse.position();
-  if (position == AbsolutePosition && container->isInFlowPositioned() &&
+  if (position == EPosition::kAbsolute && container->isInFlowPositioned() &&
       container->isLayoutInline()) {
     topLeft +=
         toLayoutInline(container)->offsetForInFlowPositionedInline(*this);
   } else if (styleToUse.hasInFlowPosition() && layer()) {
     // Apply the relative position offset when invalidating a rectangle. The
     // layer is translated, but the layout box isn't, so we need to do this to
     // get the right dirty rect.  Since this is called from
     // LayoutObject::setStyle, the relative position flag on the LayoutObject
     // has been cleared, so use the one on the style().
     topLeft += layer()->offsetForInFlowPosition();
@@ skipping 10 matching lines @@
     return false;
 
   if (skipInfo.ancestorSkipped()) {
     // If the ancestor is below the container, then we need to map the rect into
     // ancestor's coordinates.
     LayoutSize containerOffset =
         ancestor->offsetFromAncestorContainer(container);
     rect.move(-containerOffset);
     // If the ancestor is fixed, then the rect is already in its coordinates so
     // doesn't need viewport-adjusting.
-    if (ancestor->style()->position() != FixedPosition &&
-        container->isLayoutView() && position == FixedPosition)
+    if (ancestor->style()->position() != EPosition::kFixed &&
+        container->isLayoutView() && position == EPosition::kFixed)
       rect.move(toLayoutView(container)->offsetForFixedPosition(true));
     return true;
   }
 
   if (container->isLayoutView())
     return toLayoutView(container)->mapToVisualRectInAncestorSpace(
-        ancestor, rect, position == FixedPosition ? IsFixed : 0,
+        ancestor, rect, position == EPosition::kFixed ? IsFixed : 0,
         visualRectFlags);
   else
     return container->mapToVisualRectInAncestorSpace(ancestor, rect,
                                                      visualRectFlags);
 }
 
 void LayoutBox::inflateVisualRectForFilter(LayoutRect& visualRect) const {
   if (layer() && layer()->hasFilterInducingProperty())
     visualRect = layer()->mapLayoutRectForFilter(visualRect);
 }
@@ skipping 1150 matching lines @@
 }
 
 LayoutUnit LayoutBox::containingBlockLogicalWidthForPositioned(
     const LayoutBoxModelObject* containingBlock,
     bool checkForPerpendicularWritingMode) const {
   if (checkForPerpendicularWritingMode &&
       containingBlock->isHorizontalWritingMode() != isHorizontalWritingMode())
     return containingBlockLogicalHeightForPositioned(containingBlock, false);
 
   // Use viewport as container for top-level fixed-position elements.
-  if (style()->position() == FixedPosition && containingBlock->isLayoutView() &&
-      !document().printing()) {
+  if (style()->position() == EPosition::kFixed &&
+      containingBlock->isLayoutView() && !document().printing()) {
     const LayoutView* view = toLayoutView(containingBlock);
     if (FrameView* frameView = view->frameView()) {
       // Don't use visibleContentRect since the PaintLayer's size has not been
       // set yet.
       LayoutSize viewportSize(
           frameView->layoutViewportScrollableArea()->excludeScrollbars(
               frameView->frameRect().size()));
       return LayoutUnit(containingBlock->isHorizontalWritingMode()
                             ? viewportSize.width()
                             : viewportSize.height());
@@ skipping 39 matching lines @@
 }
 
 LayoutUnit LayoutBox::containingBlockLogicalHeightForPositioned(
     const LayoutBoxModelObject* containingBlock,
     bool checkForPerpendicularWritingMode) const {
   if (checkForPerpendicularWritingMode &&
       containingBlock->isHorizontalWritingMode() != isHorizontalWritingMode())
     return containingBlockLogicalWidthForPositioned(containingBlock, false);
 
   // Use viewport as container for top-level fixed-position elements.
-  if (style()->position() == FixedPosition && containingBlock->isLayoutView() &&
-      !document().printing()) {
+  if (style()->position() == EPosition::kFixed &&
+      containingBlock->isLayoutView() && !document().printing()) {
     const LayoutView* view = toLayoutView(containingBlock);
     if (FrameView* frameView = view->frameView()) {
       // Don't use visibleContentRect since the PaintLayer's size has not been
       // set yet.
       LayoutSize viewportSize(
           frameView->layoutViewportScrollableArea()->excludeScrollbars(
               frameView->frameRect().size()));
       return containingBlock->isHorizontalWritingMode() ? viewportSize.height()
                                                         : viewportSize.width();
     }
@@ skipping 1359 matching lines @@
           style()->logicalMinHeight().isPositive() &&
           (!style()->logicalMinHeight().isPercentOrCalc() ||
            percentageLogicalHeightIsResolvable()));
 }
 
 LayoutBox::PaginationBreakability LayoutBox::getPaginationBreakability() const {
   // TODO(mstensho): It is wrong to check isAtomicInlineLevel() as we
   // actually look for replaced elements.
   if (isAtomicInlineLevel() || hasUnsplittableScrollingOverflow() ||
       (parent() && isWritingModeRoot()) ||
-      (isOutOfFlowPositioned() && style()->position() == FixedPosition))
+      (isOutOfFlowPositioned() && style()->position() == EPosition::kFixed))
     return ForbidBreaks;
 
   EBreakInside breakValue = breakInside();
   if (breakValue == EBreakInside::kAvoid ||
       breakValue == EBreakInside::kAvoidPage ||
       breakValue == EBreakInside::kAvoidColumn)
     return AvoidBreaks;
   return AllowAnyBreaks;
 }
 
@@ skipping 651 matching lines @@
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 bool LayoutBox::shouldClipOverflow() const {
   return hasOverflowClip() || styleRef().containsPaint() || hasControlClip();
 }
 
 }  // namespace blink