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

third_party/WebKit/Source/core/style/ComputedStyle.h

 /*
  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
  * rights reserved.
  * 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
@@ skipping 3249 matching lines @@
   FloatRoundedRect getRoundedInnerBorderFor(
       const LayoutRect& borderRect,
       bool includeLogicalLeftEdge = true,
       bool includeLogicalRightEdge = true) const;
   FloatRoundedRect getRoundedInnerBorderFor(const LayoutRect& borderRect,
                                             const LayoutRectOutsets& insets,
                                             bool includeLogicalLeftEdge,
                                             bool includeLogicalRightEdge) const;
 
   // Float utility functions.
-  bool isFloating() const { return floating() != EFloat::None; }
+  bool isFloating() const { return floating() != EFloat::kNone; }
 
   // Mix-blend-mode utility functions.
   bool hasBlendMode() const { return blendMode() != WebBlendModeNormal; }
 
   // Motion utility functions.
   bool hasOffset() const {
     return (offsetPosition().x() != Length(Auto)) || offsetPath();
   }
 
   // Direction utility functions.
   bool isLeftToRightDirection() const {
-    return direction() == TextDirection::Ltr;
+    return direction() == TextDirection::kLtr;
   }
 
   // Perspective utility functions.
   bool hasPerspective() const {
     return m_rareNonInheritedData->m_perspective > 0;
   }
 
   // Page size utility functions.
   void resetPageSizeType() {
     SET_VAR(m_rareNonInheritedData, m_pageSizeType, PAGE_SIZE_AUTO);
@@ skipping 123 matching lines @@
   bool isOverflowVisible() const {
     DCHECK(overflowX() != EOverflow::Visible || overflowX() == overflowY());
     return overflowX() == EOverflow::Visible;
   }
   bool isOverflowPaged() const {
     return overflowY() == EOverflow::PagedX || overflowY() == EOverflow::PagedY;
   }
 
   // Visibility utility functions.
   bool visibleToHitTesting() const {
-    return visibility() == EVisibility::Visible &&
-           pointerEvents() != EPointerEvents::None;
+    return visibility() == EVisibility::kVisible &&
+           pointerEvents() != EPointerEvents::kNone;
   }
 
   // Animation utility functions.
   bool shouldCompositeForCurrentAnimations() const {
     return hasCurrentOpacityAnimation() || hasCurrentTransformAnimation() ||
            hasCurrentFilterAnimation() || hasCurrentBackdropFilterAnimation();
   }
   bool isRunningAnimationOnCompositor() const {
     return isRunningOpacityAnimationOnCompositor() ||
            isRunningTransformAnimationOnCompositor() ||
@@ skipping 123 matching lines @@
   bool canContainAbsolutePositionObjects() const {
     return position() != StaticPosition;
   }
   bool canContainFixedPositionObjects() const {
     return hasTransformRelatedProperty() || containsPaint();
   }
 
   // Whitespace utility functions.
   static bool autoWrap(EWhiteSpace ws) {
     // Nowrap and pre don't automatically wrap.
-    return ws != EWhiteSpace::Nowrap && ws != EWhiteSpace::Pre;
+    return ws != EWhiteSpace::kNowrap && ws != EWhiteSpace::kPre;
   }
 
   bool autoWrap() const { return autoWrap(whiteSpace()); }
 
   static bool preserveNewline(EWhiteSpace ws) {
     // Normal and nowrap do not preserve newlines.
-    return ws != EWhiteSpace::Normal && ws != EWhiteSpace::Nowrap;
+    return ws != EWhiteSpace::kNormal && ws != EWhiteSpace::kNowrap;
   }
 
   bool preserveNewline() const { return preserveNewline(whiteSpace()); }
 
   static bool collapseWhiteSpace(EWhiteSpace ws) {
     // Pre and prewrap do not collapse whitespace.
-    return ws != EWhiteSpace::Pre && ws != EWhiteSpace::PreWrap;
+    return ws != EWhiteSpace::kPre && ws != EWhiteSpace::kPreWrap;
   }
 
   bool collapseWhiteSpace() const { return collapseWhiteSpace(whiteSpace()); }
 
   bool isCollapsibleWhiteSpace(UChar c) const {
     switch (c) {
       case ' ':
       case '\t':
         return collapseWhiteSpace();
       case '\n':
         return !preserveNewline();
     }
     return false;
   }
   bool breakOnlyAfterWhiteSpace() const {
-    return whiteSpace() == EWhiteSpace::PreWrap ||
+    return whiteSpace() == EWhiteSpace::kPreWrap ||
            getLineBreak() == LineBreakAfterWhiteSpace;
   }
 
   bool breakWords() const {
     return (wordBreak() == BreakWordBreak ||
             overflowWrap() == BreakOverflowWrap) &&
-           whiteSpace() != EWhiteSpace::Pre &&
-           whiteSpace() != EWhiteSpace::Nowrap;
+           whiteSpace() != EWhiteSpace::kPre &&
+           whiteSpace() != EWhiteSpace::kNowrap;
   }
 
   // Text direction utility functions.
   bool shouldPlaceBlockDirectionScrollbarOnLogicalLeft() const {
     return !isLeftToRightDirection() && isHorizontalWritingMode();
   }
   bool hasInlinePaginationAxis() const {
     // If the pagination axis is parallel with the writing mode inline axis,
     // columns may be laid out along the inline axis, just like for regular
     // multicol. Otherwise, we need to lay out along the block axis.
@@ skipping 333 matching lines @@
   m_nonInheritedData.m_pseudoBits |= 1 << (pseudo - 1);
 }
 
 inline bool ComputedStyle::hasPseudoElementStyle() const {
   return m_nonInheritedData.m_pseudoBits & ElementPseudoIdMask;
 }
 
 }  // namespace blink
 
 #endif  // ComputedStyle_h