Changed ComputedStyle's EVisibility to be an enum class and fixed naming

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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 1493 matching lines @@
             if (!prevousNodeIterator || !prevousNodeIterator->isDescendantOf(highestRoot))
                 break;
         }
 
         const LayoutItem layoutItem = LayoutItem(prevousNodeIterator->layoutObject());
         if (layoutItem.isNull()) {
             prevousNodeIterator = Strategy::previousPostOrder(*prevousNodeIterator, startBlock);
             continue;
         }
         const ComputedStyle& style = layoutItem.styleRef();
-        if (style.visibility() != VISIBLE) {
+        if (style.visibility() != EVisibility::Visible) {
             prevousNodeIterator = Strategy::previousPostOrder(*prevousNodeIterator, startBlock);
             continue;
         }
 
         if (layoutItem.isBR() || isEnclosingBlock(prevousNodeIterator))
             break;
 
         if (layoutItem.isText() && toLayoutText(prevousNodeIterator->layoutObject())->resolvedTextLength()) {
             SECURITY_DCHECK(prevousNodeIterator->isTextNode());
             if (style.preserveNewline()) {
@@ skipping 70 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() != VISIBLE) {
+        if (style.visibility() != EVisibility::Visible) {
             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() && toLayoutText(layoutObject)->resolvedTextLength()) {
             SECURITY_DCHECK(nextNodeItreator->isTextNode());
@@ skipping 774 matching lines @@
             lastNode = currentNode;
         }
 
         // If we've moved to a position that is visually distinct, return the last 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() != VISIBLE)
+        if (!layoutObject || layoutObject->style()->visibility() != EVisibility::Visible)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer<Strategy>(currentPos))
             lastVisible = currentPos;
@@ skipping 27 matching lines @@
             DCHECK_GE(currentPos.offsetInLeafNode(), static_cast<int>(textStartOffset));
             const unsigned textOffset = currentPos.offsetInLeafNode() - textStartOffset;
             InlineTextBox* lastTextBox = textLayoutObject->lastTextBox();
             for (InlineTextBox* box = textLayoutObject->firstTextBox(); box; box = box->nextTextBox()) {
                 if (textOffset == box->start()) {
                     if (textLayoutObject->isTextFragment() && toLayoutTextFragment(layoutObject)->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() == VISIBLE)
+                        if (firstLetterLayoutObject && firstLetterLayoutObject->style()->visibility() == EVisibility::Visible)
                             return currentPos.computePosition();
                     }
                     continue;
                 }
                 if (textOffset <= box->start() + box->len()) {
                     if (textOffset > box->start())
                         return currentPos.computePosition();
                     continue;
                 }
 
@@ skipping 82 matching lines @@
         if (endsOfNodeAreVisuallyDistinctPositions(currentNode) && currentNode != boundary)
             return lastVisible.deprecatedComputePosition();
         // Do not move past a visually disinct position.
         // 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() != VISIBLE)
+        if (!layoutObject || layoutObject->style()->visibility() != EVisibility::Visible)
             continue;
 
         if (rule == CanCrossEditingBoundary && boundaryCrossed) {
             lastVisible = currentPos;
             break;
         }
 
         // track last visible streamer position
         if (isStreamer<Strategy>(currentPos))
             lastVisible = currentPos;
@@ skipping 97 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() != VISIBLE)
+    if (layoutObject->style()->visibility() != EVisibility::Visible)
         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 580 matching lines @@
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
 VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink