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

third_party/WebKit/Source/core/layout/line/BreakingContextInlineHeaders.h

 /*
  * 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.
  * Copyright (C) 2013 Adobe Systems Incorporated.
  *
  * 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 55 matching lines @@
         m_current(resolver.position()),
         m_lineBreak(resolver.position()),
         m_block(block),
         m_lastObject(m_current.getLineLayoutItem()),
         m_nextObject(nullptr),
         m_currentStyle(nullptr),
         m_blockStyle(block.style()),
         m_lineInfo(inLineInfo),
         m_layoutTextInfo(inLayoutTextInfo),
         m_width(lineWidth),
-        m_currWS(EWhiteSpace::Normal),
-        m_lastWS(EWhiteSpace::Normal),
+        m_currWS(EWhiteSpace::kNormal),
+        m_lastWS(EWhiteSpace::kNormal),
         m_preservesNewline(false),
         m_atStart(true),
         m_ignoringSpaces(false),
         m_currentCharacterIsSpace(false),
         m_appliedStartWidth(appliedStartWidth),
         m_includeEndWidth(true),
         m_autoWrap(false),
         m_autoWrapWasEverTrueOnLine(false),
         m_floatsFitOnLine(true),
         m_collapseWhiteSpace(false),
@@ skipping 51 matching lines @@
                                       float& lastWidthMeasurement,
                                       float wordSpacingForWordMeasurement,
                                       const Font&,
                                       float wordTrailingSpaceWidth,
                                       UChar);
   void stopIgnoringSpaces(unsigned& lastSpace);
   void commitAndUpdateLineBreakIfNeeded();
   InlineIterator handleEndOfLine();
 
   void clearLineBreakIfFitsOnLine() {
-    if (m_width.fitsOnLine() || m_lastWS == EWhiteSpace::Nowrap)
+    if (m_width.fitsOnLine() || m_lastWS == EWhiteSpace::kNowrap)
       m_lineBreak.clear();
   }
 
  private:
   void setCurrentCharacterIsSpace(UChar);
   void skipTrailingWhitespace(InlineIterator&, const LineInfo&);
   bool shouldMidWordBreak(UChar,
                           LineLayoutText,
                           const Font&,
                           float& charWidth,
@@ skipping 76 matching lines @@
                                      WhitespacePosition whitespacePosition) {
   // CSS2 16.6.1
   // If a space (U+0020) at the beginning of a line has 'white-space' set to
   // 'normal', 'nowrap', or 'pre-line', it is removed.
   // If a space (U+0020) at the end of a line has 'white-space' set to 'normal',
   // 'nowrap', or 'pre-line', it is also removed.
   // If spaces (U+0020) or tabs (U+0009) at the end of a line have 'white-space'
   // set to 'pre-wrap', UAs may visually collapse them.
   return style.collapseWhiteSpace() ||
          (whitespacePosition == TrailingWhitespace &&
-          style.whiteSpace() == EWhiteSpace::PreWrap &&
+          style.whiteSpace() == EWhiteSpace::kPreWrap &&
           (!lineInfo.isEmpty() || !lineInfo.previousLineBrokeCleanly()));
 }
 
 inline bool requiresLineBoxForContent(LineLayoutInline flow,
                                       const LineInfo& lineInfo) {
   LineLayoutItem parent = flow.parent();
   if (flow.document().inNoQuirksMode() &&
       (flow.style(lineInfo.isFirstLine())->lineHeight() !=
            parent.style(lineInfo.isFirstLine())->lineHeight() ||
        flow.style()->verticalAlign() != parent.style()->verticalAlign() ||
@@ skipping 407 matching lines @@
     if (wordMeasurements[i].width > 0)
       return wordMeasurements[i].width;
   }
   return 0;
 }
 
 ALWAYS_INLINE TextDirection
 textDirectionFromUnicode(WTF::Unicode::CharDirection direction) {
   return direction == WTF::Unicode::RightToLeft ||
                  direction == WTF::Unicode::RightToLeftArabic
-             ? TextDirection::Rtl
-             : TextDirection::Ltr;
+             ? TextDirection::kRtl
+             : TextDirection::kLtr;
 }
 
 ALWAYS_INLINE float textWidth(
     LineLayoutText text,
     unsigned from,
     unsigned len,
     const Font& font,
     float xPos,
     bool collapseWhiteSpace,
     HashSet<const SimpleFontData*>* fallbackFonts = nullptr,
@@ skipping 250 matching lines @@
   float lastSpaceWordSpacing = 0;
   float wordSpacingForWordMeasurement = 0;
 
   float widthFromLastBreakingOpportunity = m_width.uncommittedWidth();
   float charWidth = 0;
   // Auto-wrapping text should wrap in the middle of a word only if it could not
   // wrap before the word, which is only possible if the word is the first thing
   // on the line, that is, if |w| is zero.
   bool breakWords = m_currentStyle->breakWords() &&
                     ((m_autoWrap && !m_width.committedWidth()) ||
-                     m_currWS == EWhiteSpace::Pre);
+                     m_currWS == EWhiteSpace::kPre);
   bool midWordBreak = false;
   bool breakAll =
       m_currentStyle->wordBreak() == BreakAllWordBreak && m_autoWrap;
   bool keepAll = m_currentStyle->wordBreak() == KeepAllWordBreak && m_autoWrap;
   bool prohibitBreakInside = m_currentStyle->hasTextCombine() &&
                              layoutText.isCombineText() &&
                              LineLayoutTextCombine(layoutText).isCombined();
 
   // This is currently only used for word-break: break-all, specifically for the
   // case where we have a break opportunity within a word, then a string of non-
@@ skipping 69 matching lines @@
     // Determine if we should try breaking in the middle of a word.
     if (canBreakMidWord && !midWordBreak && !U16_IS_TRAIL(c))
       midWordBreak = shouldMidWordBreak(
           c, layoutText, font, charWidth, widthFromLastBreakingOpportunity,
           breakAll, nextBreakablePositionForBreakAll);
 
     // Determine if we are in the whitespace between words.
     int nextBreakablePosition = m_current.nextBreakablePosition();
     bool betweenWords =
         c == newlineCharacter ||
-        (m_currWS != EWhiteSpace::Pre && !m_atStart &&
+        (m_currWS != EWhiteSpace::kPre && !m_atStart &&
          m_layoutTextInfo.m_lineBreakIterator.isBreakable(
              m_current.offset(), nextBreakablePosition, lineBreakType) &&
          (!disableSoftHyphen ||
           m_current.previousInSameNode() != softHyphenCharacter));
     m_current.setNextBreakablePosition(nextBreakablePosition);
 
     // If we're in the middle of a word or at the start of a new one and can't
     // break there, then continue to the next character.
     if (!betweenWords && !midWordBreak) {
       if (m_ignoringSpaces) {
@@ skipping 399 matching lines @@
       m_width.addUncommittedWidth(-hyphenWidth);
       hyphenWidth = 0;
     }
   }
   return false;
 }
 
 inline void BreakingContext::commitAndUpdateLineBreakIfNeeded() {
   bool checkForBreak = m_autoWrap;
   if (m_width.committedWidth() && !m_width.fitsOnLine() &&
-      m_lineBreak.getLineLayoutItem() && m_currWS == EWhiteSpace::Nowrap) {
+      m_lineBreak.getLineLayoutItem() && m_currWS == EWhiteSpace::kNowrap) {
     if (m_width.fitsOnLine(0, ExcludeWhitespace)) {
       m_width.commit();
       m_lineBreak.moveToStartOf(m_nextObject);
     }
     checkForBreak = true;
   } else if (m_nextObject && m_current.getLineLayoutItem().isText() &&
              m_nextObject.isText() && !m_nextObject.isBR() &&
              (m_autoWrap || m_nextObject.style()->autoWrap())) {
     if (m_autoWrap && m_currentCharacterIsSpace) {
       checkForBreak = true;
@@ skipping 75 matching lines @@
 
   if (style.getTextIndentType() == TextIndentHanging)
     indentText = indentText == IndentText ? DoNotIndentText : IndentText;
 
   return indentText;
 }
 
 }  // namespace blink
 
 #endif  // BreakingContextInlineHeaders_h