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

third_party/WebKit/Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights
  * reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 689 matching lines @@
 
     if (!iter)
       break;
 
     iter->first();
     int offsetInIterator = offsetInBox - textBox->start() + previousBoxLength;
 
     bool isWordBreak;
     bool boxHasSameDirectionalityAsBlock = box->direction() == blockDirection;
     bool movingBackward =
-        (direction == MoveLeft && box->direction() == TextDirection::Ltr) ||
-        (direction == MoveRight && box->direction() == TextDirection::Rtl);
+        (direction == MoveLeft && box->direction() == TextDirection::kLtr) ||
+        (direction == MoveRight && box->direction() == TextDirection::kRtl);
     if ((skipsSpaceWhenMovingRight && boxHasSameDirectionalityAsBlock) ||
         (!skipsSpaceWhenMovingRight && movingBackward)) {
       bool logicalStartInLayoutObject =
           offsetInBox == static_cast<int>(textBox->start()) &&
           previousBoxInDifferentBlock;
       isWordBreak = isLogicalStartOfWord(iter, offsetInIterator,
                                          logicalStartInLayoutObject);
     } else {
       bool logicalEndInLayoutObject =
           offsetInBox == static_cast<int>(textBox->start() + textBox->len()) &&
@@ skipping 16 matching lines @@
   VisiblePosition leftWordBreak =
       visualWordPosition(visiblePosition, MoveLeft, skipsSpaceWhenMovingRight);
   leftWordBreak = honorEditingBoundaryAtOrBefore(
       leftWordBreak, visiblePosition.deepEquivalent());
 
   // FIXME: How should we handle a non-editable position?
   if (leftWordBreak.isNull() &&
       isEditablePosition(visiblePosition.deepEquivalent())) {
     TextDirection blockDirection =
         directionOfEnclosingBlock(visiblePosition.deepEquivalent());
-    leftWordBreak = blockDirection == TextDirection::Ltr
+    leftWordBreak = blockDirection == TextDirection::kLtr
                         ? startOfEditableContent(visiblePosition)
                         : endOfEditableContent(visiblePosition);
   }
   return leftWordBreak;
 }
 
 VisiblePosition rightWordPosition(const VisiblePosition& visiblePosition,
                                   bool skipsSpaceWhenMovingRight) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   VisiblePosition rightWordBreak =
       visualWordPosition(visiblePosition, MoveRight, skipsSpaceWhenMovingRight);
   rightWordBreak = honorEditingBoundaryAtOrBefore(
       rightWordBreak, visiblePosition.deepEquivalent());
 
   // FIXME: How should we handle a non-editable position?
   if (rightWordBreak.isNull() &&
       isEditablePosition(visiblePosition.deepEquivalent())) {
     TextDirection blockDirection =
         directionOfEnclosingBlock(visiblePosition.deepEquivalent());
-    rightWordBreak = blockDirection == TextDirection::Ltr
+    rightWordBreak = blockDirection == TextDirection::kLtr
                          ? endOfEditableContent(visiblePosition)
                          : startOfEditableContent(visiblePosition);
   }
   return rightWordBreak;
 }
 
 template <typename Strategy>
 static ContainerNode* nonShadowBoundaryParentNode(Node* node) {
   ContainerNode* parent = Strategy::parent(*node);
   return parent && !parent->isShadowRoot() ? parent : nullptr;
@@ skipping 1003 matching lines @@
     }
 
     const LayoutItem layoutItem =
         LayoutItem(prevousNodeIterator->layoutObject());
     if (layoutItem.isNull()) {
       prevousNodeIterator =
           Strategy::previousPostOrder(*prevousNodeIterator, startBlock);
       continue;
     }
     const ComputedStyle& style = layoutItem.styleRef();
-    if (style.visibility() != EVisibility::Visible) {
+    if (style.visibility() != EVisibility::kVisible) {
       prevousNodeIterator =
           Strategy::previousPostOrder(*prevousNodeIterator, startBlock);
       continue;
     }
 
     if (layoutItem.isBR() || isEnclosingBlock(prevousNodeIterator))
       break;
 
     if (layoutItem.isText() &&
         toLayoutText(prevousNodeIterator->layoutObject())
@@ skipping 92 matching lines @@
       if (!nextNodeItreator || !nextNodeItreator->isDescendantOf(highestRoot))
         break;
     }
 
     LayoutObject* const layoutObject = nextNodeItreator->layoutObject();
     if (!layoutObject) {
       nextNodeItreator = Strategy::next(*nextNodeItreator, startBlock);
       continue;
     }
     const ComputedStyle& style = layoutObject->styleRef();
-    if (style.visibility() != EVisibility::Visible) {
+    if (style.visibility() != EVisibility::kVisible) {
       nextNodeItreator = Strategy::next(*nextNodeItreator, startBlock);
       continue;
     }
 
     if (layoutObject->isBR() || isEnclosingBlock(nextNodeItreator))
       break;
 
     // FIXME: We avoid returning a position where the layoutObject can't accept
     // the caret.
     if (layoutObject->isText() &&
@@ skipping 290 matching lines @@
   // of INPUT/TEXTAREA element, by |nextPosition().isNull()|, because of
   // an inner editor is an only leaf node.
   if (!nextPosition.deepEquivalent().isAfterAnchor())
     return false;
   return isTextControlElement(nextPosition.deepEquivalent().anchorNode());
 }
 
 VisiblePosition leftBoundaryOfLine(const VisiblePosition& c,
                                    TextDirection direction) {
   DCHECK(c.isValid()) << c;
-  return direction == TextDirection::Ltr ? logicalStartOfLine(c)
-                                         : logicalEndOfLine(c);
+  return direction == TextDirection::kLtr ? logicalStartOfLine(c)
+                                          : logicalEndOfLine(c);
 }
 
 VisiblePosition rightBoundaryOfLine(const VisiblePosition& c,
                                     TextDirection direction) {
   DCHECK(c.isValid()) << c;
-  return direction == TextDirection::Ltr ? logicalEndOfLine(c)
-                                         : logicalStartOfLine(c);
+  return direction == TextDirection::kLtr ? logicalEndOfLine(c)
+                                          : logicalStartOfLine(c);
 }
 
 static bool isNonTextLeafChild(LayoutObject* object) {
   if (object->slowFirstChild())
     return false;
   if (object->isText())
     return false;
   return true;
 }
 
@@ skipping 586 matching lines @@
     // saved position. There is code below that terminates early if we're
     // *about* to move to a visually distinct position.
     if (endsOfNodeAreVisuallyDistinctPositions(currentNode) &&
         currentNode != boundary)
       return lastVisible.deprecatedComputePosition();
 
     // skip position in non-laid out or invisible node
     LayoutObject* layoutObject =
         associatedLayoutObjectOf(*currentNode, currentPos.offsetInLeafNode());
     if (!layoutObject ||
-        layoutObject->style()->visibility() != EVisibility::Visible)
+        layoutObject->style()->visibility() != EVisibility::kVisible)
       continue;
 
     if (rule == CanCrossEditingBoundary && boundaryCrossed) {
       lastVisible = currentPos;
       break;
     }
 
     // track last visible streamer position
     if (isStreamer<Strategy>(currentPos))
       lastVisible = currentPos;
@@ skipping 43 matching lines @@
                   ->isRemainingTextLayoutObject()) {
             // |currentPos| is at start of remaining text of
             // |Text| node with :first-letter.
             DCHECK_GE(currentPos.offsetInLeafNode(), 1);
             LayoutObject* firstLetterLayoutObject =
                 toLayoutTextFragment(layoutObject)
                     ->firstLetterPseudoElement()
                     ->layoutObject();
             if (firstLetterLayoutObject &&
                 firstLetterLayoutObject->style()->visibility() ==
-                    EVisibility::Visible)
+                    EVisibility::kVisible)
               return currentPos.computePosition();
           }
           continue;
         }
         if (textOffset <= box->start() + box->len()) {
           if (textOffset > box->start())
             return currentPos.computePosition();
           continue;
         }
 
@@ skipping 99 matching lines @@
     // Note: The first position after the last in a node whose ends are visually
     // distinct positions will be [boundary->parentNode(),
     // originalBlock->nodeIndex() + 1].
     if (boundary && Strategy::parent(*boundary) == currentNode)
       return lastVisible.deprecatedComputePosition();
 
     // skip position in non-laid out or invisible node
     LayoutObject* layoutObject =
         associatedLayoutObjectOf(*currentNode, currentPos.offsetInLeafNode());
     if (!layoutObject ||
-        layoutObject->style()->visibility() != EVisibility::Visible)
+        layoutObject->style()->visibility() != EVisibility::kVisible)
       continue;
 
     if (rule == CanCrossEditingBoundary && boundaryCrossed) {
       lastVisible = currentPos;
       break;
     }
 
     // track last visible streamer position
     if (isStreamer<Strategy>(currentPos))
       lastVisible = currentPos;
@@ skipping 116 matching lines @@
 static bool isVisuallyEquivalentCandidateAlgorithm(
     const PositionTemplate<Strategy>& position) {
   Node* const anchorNode = position.anchorNode();
   if (!anchorNode)
     return false;
 
   LayoutObject* layoutObject = anchorNode->layoutObject();
   if (!layoutObject)
     return false;
 
-  if (layoutObject->style()->visibility() != EVisibility::Visible)
+  if (layoutObject->style()->visibility() != EVisibility::kVisible)
     return false;
 
   if (layoutObject->isBR()) {
     // TODO(leviw) The condition should be
     // m_anchorType == PositionAnchorType::BeforeAnchor, but for now we
     // still need to support legacy positions.
     if (position.isAfterAnchor())
       return false;
     if (position.computeEditingOffset())
       return false;
@@ skipping 165 matching lines @@
       mostForwardCaretPosition(p);
   TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
   const TextAffinity affinity = visiblePosition.affinity();
 
   while (true) {
     InlineBoxPosition boxPosition =
         computeInlineBoxPosition(p, affinity, primaryDirection);
     InlineBox* box = boxPosition.inlineBox;
     int offset = boxPosition.offsetInBox;
     if (!box)
-      return primaryDirection == TextDirection::Ltr
+      return primaryDirection == TextDirection::kLtr
                  ? previousVisuallyDistinctCandidate(deepPosition)
                  : nextVisuallyDistinctCandidate(deepPosition);
 
     LineLayoutItem lineLayoutItem = box->getLineLayoutItem();
 
     while (true) {
       if ((lineLayoutItem.isAtomicInlineLevel() || lineLayoutItem.isBR()) &&
           offset == box->caretRightmostOffset())
         return box->isLeftToRightDirection()
                    ? previousVisuallyDistinctCandidate(deepPosition)
                    : nextVisuallyDistinctCandidate(deepPosition);
 
       if (!lineLayoutItem.node()) {
         box = box->prevLeafChild();
         if (!box)
-          return primaryDirection == TextDirection::Ltr
+          return primaryDirection == TextDirection::kLtr
                      ? previousVisuallyDistinctCandidate(deepPosition)
                      : nextVisuallyDistinctCandidate(deepPosition);
         lineLayoutItem = box->getLineLayoutItem();
         offset = box->caretRightmostOffset();
         continue;
       }
 
       offset = box->isLeftToRightDirection()
                    ? previousGraphemeBoundaryOf(lineLayoutItem.node(), offset)
                    : nextGraphemeBoundaryOf(lineLayoutItem.node(), offset);
 
       int caretMinOffset = box->caretMinOffset();
       int caretMaxOffset = box->caretMaxOffset();
 
       if (offset > caretMinOffset && offset < caretMaxOffset)
         break;
 
       if (box->isLeftToRightDirection() ? offset < caretMinOffset
                                         : offset > caretMaxOffset) {
         // Overshot to the left.
         InlineBox* prevBox = box->prevLeafChildIgnoringLineBreak();
         if (!prevBox) {
           PositionTemplate<Strategy> positionOnLeft =
-              primaryDirection == TextDirection::Ltr
+              primaryDirection == TextDirection::kLtr
                   ? previousVisuallyDistinctCandidate(
                         visiblePosition.deepEquivalent())
                   : nextVisuallyDistinctCandidate(
                         visiblePosition.deepEquivalent());
           if (positionOnLeft.isNull())
             return PositionTemplate<Strategy>();
 
           InlineBox* boxOnLeft = computeInlineBoxPosition(
                                      positionOnLeft, affinity, primaryDirection)
                                      .inlineBox;
@@ skipping 11 matching lines @@
       }
 
       DCHECK_EQ(offset, box->caretLeftmostOffset());
 
       unsigned char level = box->bidiLevel();
       InlineBox* prevBox = box->prevLeafChild();
 
       if (box->direction() == primaryDirection) {
         if (!prevBox) {
           InlineBox* logicalStart = 0;
-          if (primaryDirection == TextDirection::Ltr
+          if (primaryDirection == TextDirection::kLtr
                   ? box->root().getLogicalStartBoxWithNode(logicalStart)
                   : box->root().getLogicalEndBoxWithNode(logicalStart)) {
             box = logicalStart;
             lineLayoutItem = box->getLineLayoutItem();
-            offset = primaryDirection == TextDirection::Ltr
+            offset = primaryDirection == TextDirection::kLtr
                          ? box->caretMinOffset()
                          : box->caretMaxOffset();
           }
           break;
         }
         if (prevBox->bidiLevel() >= level)
           break;
 
         level = prevBox->bidiLevel();
 
@@ skipping 43 matching lines @@
           while (InlineBox* prevBox = box->prevLeafChild()) {
             if (prevBox->bidiLevel() < level)
               break;
             box = prevBox;
           }
           if (box->bidiLevel() == level)
             break;
           level = box->bidiLevel();
         }
         lineLayoutItem = box->getLineLayoutItem();
-        offset = primaryDirection == TextDirection::Ltr ? box->caretMinOffset()
-                                                        : box->caretMaxOffset();
+        offset = primaryDirection == TextDirection::kLtr
+                     ? box->caretMinOffset()
+                     : box->caretMaxOffset();
       }
       break;
     }
 
     p = PositionTemplate<Strategy>::editingPositionOf(lineLayoutItem.node(),
                                                       offset);
 
     if ((isVisuallyEquivalentCandidate(p) &&
          mostForwardCaretPosition(p) != downstreamStart) ||
         p.atStartOfTree() || p.atEndOfTree())
       return p;
 
     DCHECK_NE(p, deepPosition);
   }
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> leftPositionOfAlgorithm(
     const VisiblePositionTemplate<Strategy>& visiblePosition) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   const PositionTemplate<Strategy> pos =
       leftVisuallyDistinctCandidate(visiblePosition);
   // TODO(yosin) Why can't we move left from the last position in a tree?
   if (pos.atStartOfTree() || pos.atEndOfTree())
     return VisiblePositionTemplate<Strategy>();
 
   const VisiblePositionTemplate<Strategy> left = createVisiblePosition(pos);
   DCHECK_NE(left.deepEquivalent(), visiblePosition.deepEquivalent());
 
-  return directionOfEnclosingBlock(left.deepEquivalent()) == TextDirection::Ltr
+  return directionOfEnclosingBlock(left.deepEquivalent()) == TextDirection::kLtr
              ? honorEditingBoundaryAtOrBefore(left,
                                               visiblePosition.deepEquivalent())
              : honorEditingBoundaryAtOrAfter(left,
                                              visiblePosition.deepEquivalent());
 }
 
 VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition) {
   return leftPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
@@ skipping 16 matching lines @@
       mostForwardCaretPosition(p);
   TextDirection primaryDirection = primaryDirectionOf(*p.anchorNode());
   const TextAffinity affinity = visiblePosition.affinity();
 
   while (true) {
     InlineBoxPosition boxPosition =
         computeInlineBoxPosition(p, affinity, primaryDirection);
     InlineBox* box = boxPosition.inlineBox;
     int offset = boxPosition.offsetInBox;
     if (!box)
-      return primaryDirection == TextDirection::Ltr
+      return primaryDirection == TextDirection::kLtr
                  ? nextVisuallyDistinctCandidate(deepPosition)
                  : previousVisuallyDistinctCandidate(deepPosition);
 
     LayoutObject* layoutObject =
         LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
 
     while (true) {
       if ((layoutObject->isAtomicInlineLevel() || layoutObject->isBR()) &&
           offset == box->caretLeftmostOffset())
         return box->isLeftToRightDirection()
                    ? nextVisuallyDistinctCandidate(deepPosition)
                    : previousVisuallyDistinctCandidate(deepPosition);
 
       if (!layoutObject->node()) {
         box = box->nextLeafChild();
         if (!box)
-          return primaryDirection == TextDirection::Ltr
+          return primaryDirection == TextDirection::kLtr
                      ? nextVisuallyDistinctCandidate(deepPosition)
                      : previousVisuallyDistinctCandidate(deepPosition);
         layoutObject =
             LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
         offset = box->caretLeftmostOffset();
         continue;
       }
 
       offset = box->isLeftToRightDirection()
                    ? nextGraphemeBoundaryOf(layoutObject->node(), offset)
                    : previousGraphemeBoundaryOf(layoutObject->node(), offset);
 
       int caretMinOffset = box->caretMinOffset();
       int caretMaxOffset = box->caretMaxOffset();
 
       if (offset > caretMinOffset && offset < caretMaxOffset)
         break;
 
       if (box->isLeftToRightDirection() ? offset > caretMaxOffset
                                         : offset < caretMinOffset) {
         // Overshot to the right.
         InlineBox* nextBox = box->nextLeafChildIgnoringLineBreak();
         if (!nextBox) {
           PositionTemplate<Strategy> positionOnRight =
-              primaryDirection == TextDirection::Ltr
+              primaryDirection == TextDirection::kLtr
                   ? nextVisuallyDistinctCandidate(deepPosition)
                   : previousVisuallyDistinctCandidate(deepPosition);
           if (positionOnRight.isNull())
             return PositionTemplate<Strategy>();
 
           InlineBox* boxOnRight =
               computeInlineBoxPosition(positionOnRight, affinity,
                                        primaryDirection)
                   .inlineBox;
           if (boxOnRight && boxOnRight->root() == box->root())
@@ skipping 11 matching lines @@
       }
 
       DCHECK_EQ(offset, box->caretRightmostOffset());
 
       unsigned char level = box->bidiLevel();
       InlineBox* nextBox = box->nextLeafChild();
 
       if (box->direction() == primaryDirection) {
         if (!nextBox) {
           InlineBox* logicalEnd = 0;
-          if (primaryDirection == TextDirection::Ltr
+          if (primaryDirection == TextDirection::kLtr
                   ? box->root().getLogicalEndBoxWithNode(logicalEnd)
                   : box->root().getLogicalStartBoxWithNode(logicalEnd)) {
             box = logicalEnd;
             layoutObject =
                 LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
-            offset = primaryDirection == TextDirection::Ltr
+            offset = primaryDirection == TextDirection::kLtr
                          ? box->caretMaxOffset()
                          : box->caretMinOffset();
           }
           break;
         }
 
         if (nextBox->bidiLevel() >= level)
           break;
 
         level = nextBox->bidiLevel();
@@ skipping 50 matching lines @@
             if (nextBox->bidiLevel() < level)
               break;
             box = nextBox;
           }
           if (box->bidiLevel() == level)
             break;
           level = box->bidiLevel();
         }
         layoutObject =
             LineLayoutAPIShim::layoutObjectFrom(box->getLineLayoutItem());
-        offset = primaryDirection == TextDirection::Ltr ? box->caretMaxOffset()
-                                                        : box->caretMinOffset();
+        offset = primaryDirection == TextDirection::kLtr
+                     ? box->caretMaxOffset()
+                     : box->caretMinOffset();
       }
       break;
     }
 
     p = PositionTemplate<Strategy>::editingPositionOf(layoutObject->node(),
                                                       offset);
 
     if ((isVisuallyEquivalentCandidate(p) &&
          mostForwardCaretPosition(p) != downstreamStart) ||
         p.atStartOfTree() || p.atEndOfTree())
       return p;
 
     DCHECK_NE(p, deepPosition);
   }
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> rightPositionOfAlgorithm(
     const VisiblePositionTemplate<Strategy>& visiblePosition) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   const PositionTemplate<Strategy> pos =
       rightVisuallyDistinctCandidate(visiblePosition);
   // FIXME: Why can't we move left from the last position in a tree?
   if (pos.atStartOfTree() || pos.atEndOfTree())
     return VisiblePositionTemplate<Strategy>();
 
   const VisiblePositionTemplate<Strategy> right = createVisiblePosition(pos);
   DCHECK_NE(right.deepEquivalent(), visiblePosition.deepEquivalent());
 
-  return directionOfEnclosingBlock(right.deepEquivalent()) == TextDirection::Ltr
+  return directionOfEnclosingBlock(right.deepEquivalent()) ==
+                 TextDirection::kLtr
              ? honorEditingBoundaryAtOrAfter(right,
                                              visiblePosition.deepEquivalent())
              : honorEditingBoundaryAtOrBefore(right,
                                               visiblePosition.deepEquivalent());
 }
 
 VisiblePosition rightPositionOf(const VisiblePosition& visiblePosition) {
   return rightPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
@@ skipping 108 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink