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

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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 186 matching lines @@
   // of a text run, since we already did this for the parent of the text run.
   // We do have to schedule layouts, though, since a style change can force us
   // to need to relayout.
   if (diff.needsFullLayout()) {
     setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::StyleChange);
     m_knownToHaveNoOverflowAndNoFallbackFonts = false;
   }
 
   const ComputedStyle& newStyle = styleRef();
   ETextTransform oldTransform =
-      oldStyle ? oldStyle->textTransform() : ETextTransform::None;
+      oldStyle ? oldStyle->textTransform() : ETextTransform::kNone;
   ETextSecurity oldSecurity = oldStyle ? oldStyle->textSecurity() : TSNONE;
   if (oldTransform != newStyle.textTransform() ||
       oldSecurity != newStyle.textSecurity())
     transformText();
 
   // This is an optimization that kicks off font load before layout.
   if (!text().containsOnlyWhitespace())
     newStyle.font().willUseFontData(text());
 
   TextAutosizer* textAutosizer = document().textAutosizer();
@@ skipping 549 matching lines @@
   LayoutBlock* cb = containingBlock();
   const ComputedStyle& cbStyle = cb->styleRef();
 
   LayoutUnit leftEdge;
   LayoutUnit rightEdge;
   leftEdge = std::min(LayoutUnit(), rootLeft);
   rightEdge = std::max(cb->logicalWidth(), rootRight);
 
   bool rightAligned = false;
   switch (cbStyle.textAlign()) {
-    case ETextAlign::Right:
-    case ETextAlign::WebkitRight:
+    case ETextAlign::kRight:
+    case ETextAlign::kWebkitRight:
       rightAligned = true;
       break;
-    case ETextAlign::Left:
-    case ETextAlign::WebkitLeft:
-    case ETextAlign::Center:
-    case ETextAlign::WebkitCenter:
+    case ETextAlign::kLeft:
+    case ETextAlign::kWebkitLeft:
+    case ETextAlign::kCenter:
+    case ETextAlign::kWebkitCenter:
       break;
-    case ETextAlign::Justify:
-    case ETextAlign::Start:
+    case ETextAlign::kJustify:
+    case ETextAlign::kStart:
       rightAligned = !cbStyle.isLeftToRightDirection();
       break;
-    case ETextAlign::End:
+    case ETextAlign::kEnd:
       rightAligned = cbStyle.isLeftToRightDirection();
       break;
   }
 
   // for unicode-bidi: plaintext, use inlineBoxBidiLevel() to test the correct
   // direction for the cursor.
   if (rightAligned && style()->unicodeBidi() == Plaintext) {
     if (inlineBox->bidiLevel() % 2 != 1)
       rightAligned = false;
   }
@@ skipping 286 matching lines @@
   Hyphenation* hyphenation =
       styleToUse.autoWrap() ? styleToUse.getHyphenation() : nullptr;
   bool disableSoftHyphen = styleToUse.getHyphens() == HyphensNone;
   float maxWordWidth = 0;
   if (!hyphenation)
     maxWordWidth = std::numeric_limits<float>::infinity();
 
   BidiResolver<TextRunIterator, BidiCharacterRun> bidiResolver;
   BidiCharacterRun* run;
   TextDirection textDirection = styleToUse.direction();
-  if ((is8Bit() && textDirection == TextDirection::Ltr) ||
+  if ((is8Bit() && textDirection == TextDirection::kLtr) ||
       isOverride(styleToUse.unicodeBidi())) {
     run = 0;
   } else {
     TextRun textRun(text());
     BidiStatus status(textDirection, false);
     bidiResolver.setStatus(status);
     bidiResolver.setPositionIgnoringNestedIsolates(
         TextRunIterator(&textRun, 0));
     bool hardLineBreak = false;
     bool reorderRuns = false;
@@ skipping 241 matching lines @@
 
   if ((needsWordSpacing && len > 1) || (ignoringSpaces && !firstWord))
     currMaxWidth += wordSpacing;
 
   m_minWidth = std::max(currMinWidth, m_minWidth);
   m_maxWidth = std::max(currMaxWidth, m_maxWidth);
 
   if (!styleToUse.autoWrap())
     m_minWidth = m_maxWidth;
 
-  if (styleToUse.whiteSpace() == EWhiteSpace::Pre) {
+  if (styleToUse.whiteSpace() == EWhiteSpace::kPre) {
     if (firstLine)
       m_firstLineMinWidth = m_maxWidth;
     m_lastLineLineMinWidth = currMaxWidth;
   }
 
   const SimpleFontData* fontData = f.primaryFont();
   DCHECK(fontData);
 
   GlyphOverflow glyphOverflow;
   if (fontData) {
@@ skipping 221 matching lines @@
   // Text nodes aren't event targets, so don't descend any further.
 }
 
 void applyTextTransform(const ComputedStyle* style,
                         String& text,
                         UChar previousCharacter) {
   if (!style)
     return;
 
   switch (style->textTransform()) {
-    case ETextTransform::None:
+    case ETextTransform::kNone:
       break;
-    case ETextTransform::Capitalize:
+    case ETextTransform::kCapitalize:
       makeCapitalized(&text, previousCharacter);
       break;
-    case ETextTransform::Uppercase:
+    case ETextTransform::kUppercase:
       text = text.upper(style->locale());
       break;
-    case ETextTransform::Lowercase:
+    case ETextTransform::kLowercase:
       text = text.lower(style->locale());
       break;
   }
 }
 
 void LayoutText::setTextInternal(PassRefPtr<StringImpl> text) {
   ASSERT(text);
   m_text = std::move(text);
 
   if (style()) {
@@ skipping 238 matching lines @@
   LayoutUnit logicalHeight =
       lastTextBox()->logicalBottomVisualOverflow() - logicalTop;
 
   LayoutRect rect(logicalLeftSide, logicalTop, logicalWidth, logicalHeight);
   if (!style()->isHorizontalWritingMode())
     rect = rect.transposedRect();
   return rect;
 }
 
 LayoutRect LayoutText::localVisualRect() const {
-  if (style()->visibility() != EVisibility::Visible)
+  if (style()->visibility() != EVisibility::kVisible)
     return LayoutRect();
 
   return unionRect(visualOverflowRect(), localSelectionRect());
 }
 
 LayoutRect LayoutText::localSelectionRect() const {
   ASSERT(!needsLayout());
 
   if (getSelectionState() == SelectionNone)
     return LayoutRect();
@@ skipping 114 matching lines @@
   LayoutRect rect = LayoutRect(
       IntRect(firstRunX(), firstRunY(), linesBox.width(), linesBox.height()));
   LayoutBlock* block = containingBlock();
   if (block && hasTextBoxes())
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink