Change computed style enums to be prefixed with 'k'.

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 25 matching lines @@
 #include <algorithm>
 
 namespace blink {
 
 class FlexBoxIterator {
  public:
   FlexBoxIterator(LayoutDeprecatedFlexibleBox* parent)
       : m_box(parent), m_largestOrdinal(1) {
     if (m_box->style()->boxOrient() == HORIZONTAL &&
         !m_box->style()->isLeftToRightDirection())
-      m_forward = m_box->style()->boxDirection() != EBoxDirection::Normal;
+      m_forward = m_box->style()->boxDirection() != EBoxDirection::kNormal;
     else
-      m_forward = m_box->style()->boxDirection() == EBoxDirection::Normal;
+      m_forward = m_box->style()->boxDirection() == EBoxDirection::kNormal;
     if (!m_forward) {
       // No choice, since we're going backwards, we have to find out the highest
       // ordinal up front.
       LayoutBox* child = m_box->firstChildBox();
       while (child) {
         if (child->style()->boxOrdinalGroup() > m_largestOrdinal)
           m_largestOrdinal = child->style()->boxOrdinalGroup();
         child = child->nextSiblingBox();
       }
     }
@@ skipping 73 matching lines @@
 // (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() != EVisibility::Visible)
+  if (blockFlow->style()->visibility() != EVisibility::kVisible)
     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()))
             .toInt();
@@ skipping 21 matching lines @@
     return (normalFlowChildWithoutLines->location().y() +
             normalFlowChildWithoutLines->size().height())
         .toInt();
 
   return -1;
 }
 
 static RootInlineBox* lineAtIndex(const LayoutBlockFlow* blockFlow, int i) {
   ASSERT(i >= 0);
 
-  if (blockFlow->style()->visibility() != EVisibility::Visible)
+  if (blockFlow->style()->visibility() != EVisibility::kVisible)
     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() != EVisibility::Visible)
+  if (blockFlow->style()->visibility() != EVisibility::kVisible)
     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 13 matching lines @@
     if (recursiveFound) {
       if (found)
         *found = true;
       break;
     }
   }
   return count;
 }
 
 static void clearTruncation(LayoutBlockFlow* blockFlow) {
-  if (blockFlow->style()->visibility() != EVisibility::Visible)
+  if (blockFlow->style()->visibility() != EVisibility::kVisible)
     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()) {
@@ skipping 33 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() == EVisibility::Collapse;
+         child->style()->visibility() == EVisibility::kCollapse;
 }
 
 static LayoutUnit contentWidthForChild(LayoutBox* child) {
   if (child->hasOverrideLogicalContentWidth())
     return child->overrideLogicalContentWidth();
   return child->logicalWidth() - child->borderAndPaddingLogicalWidth();
 }
 
 static LayoutUnit contentHeightForChild(LayoutBox* child) {
   if (child->hasOverrideLogicalContentHeight())
@@ skipping 230 matching lines @@
         childLayer->setStaticInlinePosition(xPos);
         if (childLayer->staticBlockPosition() != yPos) {
           childLayer->setStaticBlockPosition(yPos);
           if (child->style()->hasStaticBlockPosition(
                   style()->isHorizontalWritingMode()))
             child->setChildNeedsLayout(MarkOnlyThis);
         }
         continue;
       }
 
-      if (child->style()->visibility() == EVisibility::Collapse) {
+      if (child->style()->visibility() == EVisibility::kCollapse) {
         // 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
@@ skipping 103 matching lines @@
             // 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() == EVisibility::Collapse)
+            if (child->style()->visibility() == EVisibility::kCollapse)
               continue;
 
             if (allowedChildFlex(child, expanding, i)) {
               LayoutUnit spaceAdd =
                   LayoutUnit(spaceAvailableThisPass *
                              (child->style()->boxFlex() / totalFlex));
               if (spaceAdd) {
                 child->setOverrideLogicalContentWidth(
                     contentWidthForChild(child) + spaceAdd);
                 flexingChildren = true;
@@ skipping 141 matching lines @@
         continue;
       }
 
       SubtreeLayoutScope layoutScope(*child);
       if (!haveLineClamp &&
           (relayoutChildren || (child->isAtomicInlineLevel() &&
                                 (child->style()->width().isPercentOrCalc() ||
                                  child->style()->height().isPercentOrCalc()))))
         layoutScope.setChildNeedsLayout(child);
 
-      if (child->style()->visibility() == EVisibility::Collapse) {
+      if (child->style()->visibility() == EVisibility::kCollapse) {
         // 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 282 matching lines @@
     LayoutUnit newHeight(
         getHeightForLineCount(blockChild, numVisibleLines, true, dummyCount));
     if (newHeight == child->size().height())
       continue;
 
     child->setOverrideLogicalContentHeight(newHeight -
                                            child->borderAndPaddingHeight());
     child->forceChildLayout();
 
     // FIXME: For now don't support RTL.
-    if (style()->direction() != TextDirection::Ltr)
+    if (style()->direction() != TextDirection::kLtr)
       continue;
 
     // Get the last line
     RootInlineBox* lastLine = lineAtIndex(blockChild, lineCount - 1);
     if (!lastLine)
       continue;
 
     RootInlineBox* lastVisibleLine =
         lineAtIndex(blockChild, numVisibleLines - 1);
     if (!lastVisibleLine)
@@ skipping 114 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