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

third_party/WebKit/Source/core/paint/InlineFlowBoxPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/InlineFlowBoxPainter.h"
 
 #include "core/layout/api/LineLayoutAPIShim.h"
 #include "core/layout/line/RootInlineBox.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/PaintInfo.h"
@@ skipping 163 matching lines @@
     TextDirection direction) const {
   // We have a fill/border/mask image that spans multiple lines.
   // We need to adjust the offset by the width of all previous lines.
   // Think of background painting on inlines as though you had one long line, a
   // single continuous strip. Even though that strip has been broken up across
   // multiple lines, you still paint it as though you had one single line. This
   // means each line has to pick up the background where the previous line left
   // off.
   LayoutUnit logicalOffsetOnLine;
   LayoutUnit totalLogicalWidth;
-  if (direction == TextDirection::Ltr) {
+  if (direction == TextDirection::kLtr) {
     for (const InlineFlowBox* curr = m_inlineFlowBox.prevLineBox(); curr;
          curr = curr->prevLineBox())
       logicalOffsetOnLine += curr->logicalWidth();
     totalLogicalWidth = logicalOffsetOnLine;
     for (const InlineFlowBox* curr = &m_inlineFlowBox; curr;
          curr = curr->nextLineBox())
       totalLogicalWidth += curr->logicalWidth();
   } else {
     for (const InlineFlowBox* curr = m_inlineFlowBox.nextLineBox(); curr;
          curr = curr->nextLineBox())
@@ skipping 43 matching lines @@
   }
   return DontPaintBorders;
 }
 
 void InlineFlowBoxPainter::paintBoxDecorationBackground(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset,
     const LayoutRect& cullRect) {
   DCHECK(paintInfo.phase == PaintPhaseForeground);
   if (m_inlineFlowBox.getLineLayoutItem().style()->visibility() !=
-      EVisibility::Visible)
+      EVisibility::kVisible)
     return;
 
   // You can use p::first-line to specify a background. If so, the root line
   // boxes for a line may actually have to paint a background.
   LayoutObject* inlineFlowBoxLayoutObject =
       LineLayoutAPIShim::layoutObjectFrom(m_inlineFlowBox.getLineLayoutItem());
   const ComputedStyle* styleToUse = m_inlineFlowBox.getLineLayoutItem().style(
       m_inlineFlowBox.isFirstLineStyle());
   bool shouldPaintBoxDecorationBackground;
   if (m_inlineFlowBox.parent())
@@ skipping 50 matching lines @@
           m_inlineFlowBox.getLineLayoutItem().styleRef(
               m_inlineFlowBox.isFirstLineStyle()),
           BackgroundBleedNone, m_inlineFlowBox.includeLogicalLeftEdge(),
           m_inlineFlowBox.includeLogicalRightEdge());
       break;
     case PaintBordersWithClip:
       // FIXME: What the heck do we do with RTL here? The math we're using is
       // obviously not right, but it isn't even clear how this should work at
       // all.
       LayoutRect imageStripPaintRect = paintRectForImageStrip(
-          adjustedPaintOffset, frameRect.size(), TextDirection::Ltr);
+          adjustedPaintOffset, frameRect.size(), TextDirection::kLtr);
       GraphicsContextStateSaver stateSaver(paintInfo.context);
       paintInfo.context.clip(adjustedClipRect);
       BoxPainter::paintBorder(
           *toLayoutBoxModelObject(LineLayoutAPIShim::layoutObjectFrom(
               m_inlineFlowBox.boxModelObject())),
           paintInfo, imageStripPaintRect,
           m_inlineFlowBox.getLineLayoutItem().styleRef(
               m_inlineFlowBox.isFirstLineStyle()));
       break;
   }
 }
 
 void InlineFlowBoxPainter::paintMask(const PaintInfo& paintInfo,
                                      const LayoutPoint& paintOffset) {
   if (m_inlineFlowBox.getLineLayoutItem().style()->visibility() !=
-          EVisibility::Visible ||
+          EVisibility::kVisible ||
       paintInfo.phase != PaintPhaseMask)
     return;
 
   LayoutRect frameRect = frameRectClampedToLineTopAndBottomIfNeeded();
 
   // Move x/y to our coordinates.
   LayoutRect localRect(frameRect);
   m_inlineFlowBox.flipForWritingMode(localRect);
   LayoutPoint adjustedPaintOffset = paintOffset + localRect.location();
 
@@ skipping 49 matching lines @@
   if (!m_inlineFlowBox.prevLineBox() && !m_inlineFlowBox.nextLineBox()) {
     BoxPainter::paintNinePieceImage(
         *boxModel, paintInfo.context, paintRect,
         m_inlineFlowBox.getLineLayoutItem().styleRef(), maskNinePieceImage,
         compositeOp);
   } else {
     // We have a mask image that spans multiple lines.
     // FIXME: What the heck do we do with RTL here? The math we're using is
     // obviously not right, but it isn't even clear how this should work at all.
     LayoutRect imageStripPaintRect = paintRectForImageStrip(
-        adjustedPaintOffset, frameRect.size(), TextDirection::Ltr);
+        adjustedPaintOffset, frameRect.size(), TextDirection::kLtr);
     FloatRect clipRect(clipRectForNinePieceImageStrip(
         m_inlineFlowBox, maskNinePieceImage, paintRect));
     GraphicsContextStateSaver stateSaver(paintInfo.context);
     // TODO(chrishtr): this should be pixel-snapped.
     paintInfo.context.clip(clipRect);
     BoxPainter::paintNinePieceImage(
         *boxModel, paintInfo.context, imageStripPaintRect,
         m_inlineFlowBox.getLineLayoutItem().styleRef(), maskNinePieceImage,
         compositeOp);
   }
@@ skipping 26 matching lines @@
       rect.setHeight(logicalHeight);
     } else {
       rect.setX(logicalTop);
       rect.setWidth(logicalHeight);
     }
   }
   return rect;
 }
 
 }  // namespace blink