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

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

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2003, 2004, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  *               All right reserved.
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * 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
  * version 2 of the License, or (at your option) any later version.
@@ skipping 81 matching lines @@
     for (BidiRun* r = firstRun; r; r = r->next()) {
       if (!r->m_box || r == trailingSpaceRun)
         continue;
 
       if (r->m_lineLayoutItem.isText()) {
         unsigned opportunitiesInRun = m_runsWithExpansions[i++];
 
         RELEASE_ASSERT(opportunitiesInRun <= m_totalOpportunities);
 
         // Don't justify for white-space: pre.
-        if (r->m_lineLayoutItem.style()->whiteSpace() != EWhiteSpace::Pre) {
+        if (r->m_lineLayoutItem.style()->whiteSpace() != EWhiteSpace::kPre) {
           InlineTextBox* textBox = toInlineTextBox(r->m_box);
           RELEASE_ASSERT(m_totalOpportunities);
           int expansion = ((availableLogicalWidth - totalLogicalWidth) *
                            opportunitiesInRun / m_totalOpportunities)
                               .toInt();
           textBox->setExpansion(expansion);
           totalLogicalWidth += expansion;
         }
         m_totalOpportunities -= opportunitiesInRun;
         if (!m_totalOpportunities)
@@ skipping 243 matching lines @@
 }
 
 ETextAlign LayoutBlockFlow::textAlignmentForLine(bool endsWithSoftBreak) const {
   ETextAlign alignment = style()->textAlign();
   if (endsWithSoftBreak)
     return alignment;
 
   TextAlignLast alignmentLast = style()->getTextAlignLast();
   switch (alignmentLast) {
     case TextAlignLastStart:
-      return ETextAlign::Start;
+      return ETextAlign::kStart;
     case TextAlignLastEnd:
-      return ETextAlign::End;
+      return ETextAlign::kEnd;
     case TextAlignLastLeft:
-      return ETextAlign::Left;
+      return ETextAlign::kLeft;
     case TextAlignLastRight:
-      return ETextAlign::Right;
+      return ETextAlign::kRight;
     case TextAlignLastCenter:
-      return ETextAlign::Center;
+      return ETextAlign::kCenter;
     case TextAlignLastJustify:
-      return ETextAlign::Justify;
+      return ETextAlign::kJustify;
     case TextAlignLastAuto:
-      if (alignment == ETextAlign::Justify)
-        return ETextAlign::Start;
+      if (alignment == ETextAlign::kJustify)
+        return ETextAlign::kStart;
       return alignment;
   }
 
   return alignment;
 }
 
 static void updateLogicalWidthForLeftAlignedBlock(
     bool isLeftToRightDirection,
     BidiRun* trailingSpaceRun,
     LayoutUnit& logicalLeft,
@@ skipping 273 matching lines @@
       rootInlineBox->getLineLayoutItem().style()->unicodeBidi() == Plaintext)
     direction = rootInlineBox->direction();
   else
     direction = style()->direction();
 
   // Armed with the total width of the line (without justification),
   // we now examine our text-align property in order to determine where to
   // position the objects horizontally. The total width of the line can be
   // increased if we end up justifying text.
   switch (textAlign) {
-    case ETextAlign::Left:
-    case ETextAlign::WebkitLeft:
+    case ETextAlign::kLeft:
+    case ETextAlign::kWebkitLeft:
       updateLogicalWidthForLeftAlignedBlock(
           style()->isLeftToRightDirection(), trailingSpaceRun, logicalLeft,
           totalLogicalWidth, availableLogicalWidth);
       break;
-    case ETextAlign::Right:
-    case ETextAlign::WebkitRight:
+    case ETextAlign::kRight:
+    case ETextAlign::kWebkitRight:
       updateLogicalWidthForRightAlignedBlock(
           style()->isLeftToRightDirection(), trailingSpaceRun, logicalLeft,
           totalLogicalWidth, availableLogicalWidth);
       break;
-    case ETextAlign::Center:
-    case ETextAlign::WebkitCenter:
+    case ETextAlign::kCenter:
+    case ETextAlign::kWebkitCenter:
       updateLogicalWidthForCenterAlignedBlock(
           style()->isLeftToRightDirection(), trailingSpaceRun, logicalLeft,
           totalLogicalWidth, availableLogicalWidth);
       break;
-    case ETextAlign::Justify:
+    case ETextAlign::kJustify:
       adjustInlineDirectionLineBounds(expansionOpportunityCount, logicalLeft,
                                       availableLogicalWidth);
       if (expansionOpportunityCount) {
         if (trailingSpaceRun) {
           totalLogicalWidth -= trailingSpaceRun->m_box->logicalWidth();
           trailingSpaceRun->m_box->setLogicalWidth(LayoutUnit());
         }
         break;
       }
     // Fall through
-    case ETextAlign::Start:
-      if (direction == TextDirection::Ltr)
+    case ETextAlign::kStart:
+      if (direction == TextDirection::kLtr)
         updateLogicalWidthForLeftAlignedBlock(
             style()->isLeftToRightDirection(), trailingSpaceRun, logicalLeft,
             totalLogicalWidth, availableLogicalWidth);
       else
         updateLogicalWidthForRightAlignedBlock(
             style()->isLeftToRightDirection(), trailingSpaceRun, logicalLeft,
             totalLogicalWidth, availableLogicalWidth);
       break;
-    case ETextAlign::End:
-      if (direction == TextDirection::Ltr)
+    case ETextAlign::kEnd:
+      if (direction == TextDirection::kLtr)
         updateLogicalWidthForRightAlignedBlock(
             style()->isLeftToRightDirection(), trailingSpaceRun, logicalLeft,
             totalLogicalWidth, availableLogicalWidth);
       else
         updateLogicalWidthForLeftAlignedBlock(
             style()->isLeftToRightDirection(), trailingSpaceRun, logicalLeft,
             totalLogicalWidth, availableLogicalWidth);
       break;
   }
   if (shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
@@ skipping 89 matching lines @@
   for (; r; r = r->next()) {
     if (!r->m_box || r->m_lineLayoutItem.isOutOfFlowPositioned() ||
         r->m_box->isLineBreak()) {
       continue;  // Positioned objects are only participating to figure out
                  // their correct static x position. They have no effect on the
                  // width. Similarly, line break boxes have no effect on the
                  // width.
     }
     if (r->m_lineLayoutItem.isText()) {
       LineLayoutText rt(r->m_lineLayoutItem);
-      if (textAlign == ETextAlign::Justify && r != trailingSpaceRun &&
+      if (textAlign == ETextAlign::kJustify && r != trailingSpaceRun &&
           textJustify != TextJustifyNone) {
         if (!isAfterExpansion)
           toInlineTextBox(r->m_box)->setCanHaveLeadingExpansion(true);
         expansions.addRunWithExpansions(*r, isAfterExpansion, textJustify);
       }
 
       if (rt.textLength()) {
         if (!r->m_start && needsWordSpacing &&
             isSpaceOrNewline(rt.characterAt(r->m_start)))
           totalLogicalWidth += rt.style(lineInfo.isFirstLine())
@@ skipping 299 matching lines @@
     // This is a short-cut for empty lines.
     if (layoutState.lineInfo().isEmpty()) {
       ASSERT(!paginationStrutFromDeletedLine);
       if (lastRootBox())
         lastRootBox()->setLineBreakInfo(endOfLine.getLineLayoutItem(),
                                         endOfLine.offset(), resolver.status());
       resolver.runs().deleteRuns();
     } else {
       VisualDirectionOverride override =
           (styleToUse.rtlOrdering() == EOrder::Visual
-               ? (styleToUse.direction() == TextDirection::Ltr
+               ? (styleToUse.direction() == TextDirection::kLtr
                       ? VisualLeftToRightOverride
                       : VisualRightToLeftOverride)
                : NoVisualOverride);
       if (isNewUBAParagraph && styleToUse.unicodeBidi() == Plaintext &&
           !resolver.context()->parent()) {
         TextDirection direction = determinePlaintextDirectionality(
             resolver.position().root(), resolver.position().getLineLayoutItem(),
             resolver.position().offset());
         resolver.setStatus(
             BidiStatus(direction, isOverride(styleToUse.unicodeBidi())));
@@ skipping 511 matching lines @@
                                            childMinPreferredLogicalWidth,
                                            childMaxPreferredLogicalWidth);
         childMin += childMinPreferredLogicalWidth;
         childMax += childMaxPreferredLogicalWidth;
 
         bool clearPreviousFloat;
         if (child->isFloating()) {
           const ComputedStyle& childStyle = child->styleRef();
           clearPreviousFloat =
               (prevFloat &&
-               ((prevFloat->styleRef().floating() == EFloat::Left &&
+               ((prevFloat->styleRef().floating() == EFloat::kLeft &&
                  (childStyle.clear() & ClearLeft)) ||
-                (prevFloat->styleRef().floating() == EFloat::Right &&
+                (prevFloat->styleRef().floating() == EFloat::kRight &&
                  (childStyle.clear() & ClearRight))));
           prevFloat = child;
         } else {
           clearPreviousFloat = false;
         }
 
         bool canBreakReplacedElement = !child->isImage() || allowImagesToBreak;
         if ((canBreakReplacedElement && (autoWrap || oldAutoWrap) &&
              (!isPrevChildInlineFlow || shouldBreakLineAfterText)) ||
             clearPreviousFloat) {
@@ skipping 662 matching lines @@
                                   fullstopCharacter};
   DEFINE_STATIC_LOCAL(AtomicString, fullstopCharacterStr,
                       (fullStopString, fullStopStringLength));
   DEFINE_STATIC_LOCAL(AtomicString, ellipsisStr,
                       (&horizontalEllipsisCharacter, 1));
   AtomicString& selectedEllipsisStr = ellipsisStr;
 
   const Font& firstLineFont = firstLineStyle()->font();
   // FIXME: We should probably not hard-code the direction here.
   // https://crbug.com/333004
-  TextDirection ellipsisDirection = TextDirection::Ltr;
+  TextDirection ellipsisDirection = TextDirection::kLtr;
   float firstLineEllipsisWidth = 0;
   float ellipsisWidth = 0;
 
   // As per CSS3 http://www.w3.org/TR/2003/CR-css3-text-20030514/ sequence of
   // three Full Stops (002E) can be used.
   const SimpleFontData* fontData = firstLineFont.primaryFont();
   DCHECK(fontData);
   if (fontData && fontData->glyphForCharacter(horizontalEllipsisCharacter)) {
     firstLineEllipsisWidth = firstLineFont.width(
         constructTextRun(firstLineFont, &horizontalEllipsisCharacter, 1,
@@ skipping 92 matching lines @@
   }
 }
 
 LayoutUnit LayoutBlockFlow::startAlignedOffsetForLine(
     LayoutUnit position,
     IndentTextOrNot indentText) {
   ETextAlign textAlign = style()->textAlign();
 
   bool applyIndentText;
   switch (textAlign) {  // FIXME: Handle TAEND here
-    case ETextAlign::Left:
-    case ETextAlign::WebkitLeft:
+    case ETextAlign::kLeft:
+    case ETextAlign::kWebkitLeft:
       applyIndentText = style()->isLeftToRightDirection();
       break;
-    case ETextAlign::Right:
-    case ETextAlign::WebkitRight:
+    case ETextAlign::kRight:
+    case ETextAlign::kWebkitRight:
       applyIndentText = !style()->isLeftToRightDirection();
       break;
-    case ETextAlign::Start:
+    case ETextAlign::kStart:
       applyIndentText = true;
       break;
     default:
       applyIndentText = false;
   }
 
   if (applyIndentText)
     return startOffsetForLine(position, indentText);
 
   // updateLogicalWidthForAlignment() handles the direction of the block so no
@@ skipping 19 matching lines @@
 
 bool LayoutBlockFlow::paintedOutputOfObjectHasNoEffectRegardlessOfSize() const {
   // LayoutBlockFlow is in charge of paint invalidation of the first line.
   if (firstLineBox())
     return false;
 
   return LayoutBlock::paintedOutputOfObjectHasNoEffectRegardlessOfSize();
 }
 
 }  // namespace blink