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

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 1518 matching lines @@
   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 &&
       childBox.containingBlock() != childBox.parent())
     return false;
-  if (childStyle.visibility() != EVisibility::Visible ||
+  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)
       return false;
     // FIXME: Deal with z-index.
     if (childStyle.isStackingContext())
@@ skipping 731 matching lines @@
   // may have some effect. For example, honoring the border-radius clip on
   // a composited child paints into a mask for an otherwise non-painting
   // element, because children of that element will require the mask.
   if (hasLayer() && layer()->compositingState() == PaintsIntoOwnBacking)
     return false;
 
   return true;
 }
 
 LayoutRect LayoutBox::localVisualRect() const {
-  if (style()->visibility() != EVisibility::Visible)
+  if (style()->visibility() != EVisibility::kVisible)
     return LayoutRect();
 
   if (hasMask() && !RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     return LayoutRect(layer()->boxForFilterOrMask());
   return selfVisualOverflowRect();
 }
 
 void LayoutBox::inflateVisualRectForFilterUnderContainer(
     LayoutRect& rect,
     const LayoutObject& container,
@@ skipping 548 matching lines @@
                         ? marginStartWidth + marginEndWidth
                         : LayoutUnit());
 
   if (marginBoxWidth < availableWidth) {
     // CSS 2.1: "If both 'margin-left' and 'margin-right' are 'auto', their used
     // values are equal. This horizontally centers the element with respect to
     // the edges of the containing block."
     const ComputedStyle& containingBlockStyle = containingBlock->styleRef();
     if ((marginStartLength.isAuto() && marginEndLength.isAuto()) ||
         (!marginStartLength.isAuto() && !marginEndLength.isAuto() &&
-         containingBlockStyle.textAlign() == ETextAlign::WebkitCenter)) {
+         containingBlockStyle.textAlign() == ETextAlign::kWebkitCenter)) {
       // Other browsers center the margin box for align=center elements so we
       // match them here.
       LayoutUnit centeredMarginBoxStart = std::max(
           LayoutUnit(),
           (availableWidth - childWidth - marginStartWidth - marginEndWidth) /
               2);
       marginStart = centeredMarginBoxStart + marginStartWidth;
       marginEnd = availableWidth - childWidth - marginStart + marginEndWidth;
       return;
     }
 
     // Adjust margins for the align attribute
     if ((!containingBlockStyle.isLeftToRightDirection() &&
-         containingBlockStyle.textAlign() == ETextAlign::WebkitLeft) ||
+         containingBlockStyle.textAlign() == ETextAlign::kWebkitLeft) ||
         (containingBlockStyle.isLeftToRightDirection() &&
-         containingBlockStyle.textAlign() == ETextAlign::WebkitRight)) {
+         containingBlockStyle.textAlign() == ETextAlign::kWebkitRight)) {
       if (containingBlockStyle.isLeftToRightDirection() !=
           styleRef().isLeftToRightDirection()) {
         if (!marginStartLength.isAuto())
           marginEndLength = Length(Auto);
       } else {
         if (!marginEndLength.isAuto())
           marginStartLength = Length(Auto);
       }
     }
 
@@ skipping 840 matching lines @@
     LayoutUnit containerLogicalWidth) {
   if (!logicalLeft.isAuto() || !logicalRight.isAuto())
     return;
 
   // For multicol we also need to keep track of the block position, since that
   // determines which column we're in and thus affects the inline position.
   LayoutUnit staticBlockPosition = child->layer()->staticBlockPosition();
 
   // FIXME: The static distance computation has not been patched for mixed
   // writing modes yet.
-  if (child->parent()->style()->direction() == TextDirection::Ltr) {
+  if (child->parent()->style()->direction() == TextDirection::kLtr) {
     LayoutUnit staticPosition = child->layer()->staticInlinePosition() -
                                 containerBlock->borderLogicalLeft();
     for (LayoutObject* curr = child->parent(); curr && curr != containerBlock;
          curr = curr->container()) {
       if (curr->isBox()) {
         staticPosition += toLayoutBox(curr)->logicalLeft();
         if (toLayoutBox(curr)->isInFlowPositioned())
           staticPosition +=
               toLayoutBox(curr)->offsetForInFlowPosition().width();
         if (curr->isInsideFlowThread())
@@ skipping 277 matching lines @@
     if (marginLogicalLeft.isAuto() && marginLogicalRight.isAuto()) {
       // Both margins auto, solve for equality
       if (availableSpace >= 0) {
         marginLogicalLeftValue = availableSpace / 2;  // split the difference
         marginLogicalRightValue =
             availableSpace -
             marginLogicalLeftValue;  // account for odd valued differences
       } else {
         // Use the containing block's direction rather than the parent block's
         // per CSS 2.1 reference test abspos-non-replaced-width-margin-000.
-        if (containerDirection == TextDirection::Ltr) {
+        if (containerDirection == TextDirection::kLtr) {
           marginLogicalLeftValue = LayoutUnit();
           marginLogicalRightValue = availableSpace;  // will be negative
         } else {
           marginLogicalLeftValue = availableSpace;  // will be negative
           marginLogicalRightValue = LayoutUnit();
         }
       }
     } else if (marginLogicalLeft.isAuto()) {
       // Solve for left margin
       marginLogicalRightValue =
           valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
       marginLogicalLeftValue = availableSpace - marginLogicalRightValue;
     } else if (marginLogicalRight.isAuto()) {
       // Solve for right margin
       marginLogicalLeftValue =
           valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
       marginLogicalRightValue = availableSpace - marginLogicalLeftValue;
     } else {
       // Over-constrained, solve for left if direction is RTL
       marginLogicalLeftValue =
           valueForLength(marginLogicalLeft, containerRelativeLogicalWidth);
       marginLogicalRightValue =
           valueForLength(marginLogicalRight, containerRelativeLogicalWidth);
 
       // Use the containing block's direction rather than the parent block's
       // per CSS 2.1 reference test abspos-non-replaced-width-margin-000.
-      if (containerDirection == TextDirection::Rtl)
+      if (containerDirection == TextDirection::kRtl)
         logicalLeftValue = (availableSpace + logicalLeftValue) -
                            marginLogicalLeftValue - marginLogicalRightValue;
     }
   } else {
     // -------------------------------------------------------------------------
     // Otherwise, set 'auto' values for 'margin-left' and 'margin-right'
     // to 0, and pick the one of the following six rules that applies.
     //
     // 1. 'left' and 'width' are 'auto' and 'right' is not 'auto', then the
     //    width is shrink-to-fit. Then solve for 'left'
@@ skipping 542 matching lines @@
   LayoutUnit minDist = LayoutUnit::max();
   LayoutBox* closestLayoutObject = nullptr;
   LayoutPoint adjustedPoint = point;
   if (isTableRow())
     adjustedPoint.moveBy(location());
 
   for (LayoutObject* layoutObject = firstChild; layoutObject;
        layoutObject = layoutObject->nextSibling()) {
     if ((!layoutObject->slowFirstChild() && !layoutObject->isInline() &&
          !layoutObject->isLayoutBlockFlow()) ||
-        layoutObject->style()->visibility() != EVisibility::Visible)
+        layoutObject->style()->visibility() != EVisibility::kVisible)
       continue;
 
     if (!layoutObject->isBox())
       continue;
 
     LayoutBox* layoutBox = toLayoutBox(layoutObject);
 
     LayoutUnit top = layoutBox->borderTop() + layoutBox->paddingTop() +
                      (isTableRow() ? LayoutUnit() : layoutBox->location().y());
     LayoutUnit bottom = top + layoutBox->contentHeight();
@@ skipping 1060 matching lines @@
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 bool LayoutBox::shouldClipOverflow() const {
   return hasOverflowClip() || styleRef().containsPaint() || hasControlClip();
 }
 
 }  // namespace blink