Changed ComputedStyle's EVisibility to be an enum class and fixed naming

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

 /*
  * This file is part of the layout object implementation for KHTML.
  *
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003 Apple Computer, Inc.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 112 matching lines @@
 
 // Helper methods for obtaining the last line, computing line counts and heights for line counts
 // (crawling into blocks).
 static bool shouldCheckLines(LayoutBlockFlow* blockFlow)
 {
     return !blockFlow->isFloatingOrOutOfFlowPositioned() && blockFlow->style()->height().isAuto();
 }
 
 static int getHeightForLineCount(const LayoutBlockFlow* blockFlow, int lineCount, bool includeBottom, int& count)
 {
-    if (blockFlow->style()->visibility() != VISIBLE)
+    if (blockFlow->style()->visibility() != EVisibility::Visible)
         return -1;
     if (blockFlow->childrenInline()) {
         for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox()) {
             if (++count == lineCount)
                 return box->lineBottom() + (includeBottom ? (blockFlow->borderBottom() + blockFlow->paddingBottom()) : LayoutUnit());
         }
         return -1;
     }
 
     LayoutBox* normalFlowChildWithoutLines = nullptr;
     for (LayoutBox* obj = blockFlow->firstChildBox(); obj; obj = obj->nextSiblingBox()) {
         if (obj->isLayoutBlockFlow() && shouldCheckLines(toLayoutBlockFlow(obj))) {
             int result = getHeightForLineCount(toLayoutBlockFlow(obj), lineCount, false, count);
             if (result != -1)
                 return result + obj->location().y() + (includeBottom ? (blockFlow->borderBottom() + blockFlow->paddingBottom()) : LayoutUnit());
         } else if (!obj->isFloatingOrOutOfFlowPositioned()) {
             normalFlowChildWithoutLines = obj;
         }
     }
     if (normalFlowChildWithoutLines && lineCount == 0)
         return normalFlowChildWithoutLines->location().y() + normalFlowChildWithoutLines->size().height();
 
     return -1;
 }
 
 static RootInlineBox* lineAtIndex(const LayoutBlockFlow* blockFlow, int i)
 {
     ASSERT(i >= 0);
 
-    if (blockFlow->style()->visibility() != VISIBLE)
+    if (blockFlow->style()->visibility() != EVisibility::Visible)
         return nullptr;
 
     if (blockFlow->childrenInline()) {
         for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox()) {
             if (!i--)
                 return box;
         }
         return nullptr;
     }
     for (LayoutObject* child = blockFlow->firstChild(); child; child = child->nextSibling()) {
         if (!child->isLayoutBlockFlow())
             continue;
         LayoutBlockFlow* childBlockFlow = toLayoutBlockFlow(child);
         if (!shouldCheckLines(childBlockFlow))
             continue;
         if (RootInlineBox* box = lineAtIndex(childBlockFlow, i))
             return box;
     }
 
     return nullptr;
 }
 
 static int lineCount(const LayoutBlockFlow* blockFlow, const RootInlineBox* stopRootInlineBox = nullptr, bool* found = nullptr)
 {
-    if (blockFlow->style()->visibility() != VISIBLE)
+    if (blockFlow->style()->visibility() != EVisibility::Visible)
         return 0;
     int count = 0;
     if (blockFlow->childrenInline()) {
         for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox()) {
             count++;
             if (box == stopRootInlineBox) {
                 if (found)
                     *found = true;
                 break;
             }
@@ skipping 12 matching lines @@
             if (found)
                 *found = true;
             break;
         }
     }
     return count;
 }
 
 static void clearTruncation(LayoutBlockFlow* blockFlow)
 {
-    if (blockFlow->style()->visibility() != VISIBLE)
+    if (blockFlow->style()->visibility() != EVisibility::Visible)
         return;
     if (blockFlow->childrenInline() && blockFlow->hasMarkupTruncation()) {
         blockFlow->setHasMarkupTruncation(false);
         for (RootInlineBox* box = blockFlow->firstRootBox(); box; box = box->nextRootBox())
             box->clearTruncation();
         return;
     }
     for (LayoutObject* obj = blockFlow->firstChild(); obj; obj = obj->nextSibling()) {
         if (!obj->isLayoutBlockFlow())
             continue;
@@ skipping 34 matching lines @@
     if (marginLeft.isFixed())
         margin += marginLeft.value();
     if (marginRight.isFixed())
         margin += marginRight.value();
     return margin;
 }
 
 static bool childDoesNotAffectWidthOrFlexing(LayoutObject* child)
 {
     // Positioned children and collapsed children don't affect the min/max width.
-    return child->isOutOfFlowPositioned() || child->style()->visibility() == COLLAPSE;
+    return child->isOutOfFlowPositioned() || child->style()->visibility() == EVisibility::Collapse;
 }
 
 static LayoutUnit contentWidthForChild(LayoutBox* child)
 {
     if (child->hasOverrideLogicalContentWidth())
         return child->overrideLogicalContentWidth();
     return child->logicalWidth() - child->borderAndPaddingLogicalWidth();
 }
 
 static LayoutUnit contentHeightForChild(LayoutBox* child)
@@ skipping 211 matching lines @@
                 PaintLayer* childLayer = child->layer();
                 childLayer->setStaticInlinePosition(xPos);
                 if (childLayer->staticBlockPosition() != yPos) {
                     childLayer->setStaticBlockPosition(yPos);
                     if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
                         child->setChildNeedsLayout(MarkOnlyThis);
                 }
                 continue;
             }
 
-            if (child->style()->visibility() == COLLAPSE) {
+            if (child->style()->visibility() == EVisibility::Collapse) {
                 // visibility: collapsed children do not participate in our positioning.
                 // But we need to lay them down.
                 child->layoutIfNeeded();
                 continue;
             }
 
             SubtreeLayoutScope layoutScope(*child);
 
             // We need to see if this child's height will change, since we make block elements fill
             // the height of a containing box by default. We cannot actually *set* the new height
@@ skipping 80 matching lines @@
 
                     // The flex groups may not have any flexible objects this time around.
                     if (!spaceAvailableThisPass || totalFlex == 0.0f) {
                         // If we just couldn't grow/shrink any more, then it's time to transition to the next flex group.
                         groupRemainingSpace = LayoutUnit();
                         continue;
                     }
 
                     // Now distribute the space to objects.
                     for (LayoutBox* child = iterator.first(); child && spaceAvailableThisPass && totalFlex; child = iterator.next()) {
-                        if (child->style()->visibility() == COLLAPSE)
+                        if (child->style()->visibility() == EVisibility::Collapse)
                             continue;
 
                         if (allowedChildFlex(child, expanding, i)) {
                             LayoutUnit spaceAdd = LayoutUnit(spaceAvailableThisPass * (child->style()->boxFlex() / totalFlex));
                             if (spaceAdd) {
                                 child->setOverrideLogicalContentWidth(contentWidthForChild(child) + spaceAdd);
                                 flexingChildren = true;
                                 relayoutChildren = true;
                             }
 
@@ skipping 121 matching lines @@
                     if (child->style()->hasStaticBlockPosition(style()->isHorizontalWritingMode()))
                         child->setChildNeedsLayout(MarkOnlyThis);
                 }
                 continue;
             }
 
             SubtreeLayoutScope layoutScope(*child);
             if (!haveLineClamp && (relayoutChildren || (child->isAtomicInlineLevel() && (child->style()->width().hasPercent() || child->style()->height().hasPercent()))))
                 layoutScope.setChildNeedsLayout(child);
 
-            if (child->style()->visibility() == COLLAPSE) {
+            if (child->style()->visibility() == EVisibility::Collapse) {
                 // visibility: collapsed children do not participate in our positioning.
                 // But we need to lay them down.
                 child->layoutIfNeeded();
                 continue;
             }
 
             // Compute the child's vertical margins.
             child->computeAndSetBlockDirectionMargins(this);
 
             // Add in the child's marginTop to our height.
@@ skipping 346 matching lines @@
     if (minHeight.isFixed() || minHeight.isAuto()) {
         LayoutUnit minHeight(child->style()->minHeight().value());
         LayoutUnit height = contentHeightForChild(child);
         LayoutUnit allowedShrinkage = (minHeight - height).clampPositiveToZero();
         return allowedShrinkage;
     }
     return LayoutUnit();
 }
 
 } // namespace blink