Rename ComposedTree to FlatTree

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

 /*
  * Copyright (C) 2004, 2005, 2006, 2007 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 149 matching lines @@
     // Should never reach this point.
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 int comparePositionsInDOMTree(Node* containerA, int offsetA, Node* containerB, int offsetB, bool* disconnected)
 {
     return comparePositions<NodeTraversal>(containerA, offsetA, containerB, offsetB, disconnected);
 }
 
-int comparePositionsInComposedTree(Node* containerA, int offsetA, Node* containerB, int offsetB, bool* disconnected)
+int comparePositionsInFlatTree(Node* containerA, int offsetA, Node* containerB, int offsetB, bool* disconnected)
 {
-    return comparePositions<ComposedTreeTraversal>(containerA, offsetA, containerB, offsetB, disconnected);
+    return comparePositions<FlatTreeTraversal>(containerA, offsetA, containerB, offsetB, disconnected);
 }
 
 // Compare two positions, taking into account the possibility that one or both
 // could be inside a shadow tree. Only works for non-null values.
 int comparePositions(const Position& a, const Position& b)
 {
     ASSERT(a.isNotNull());
     ASSERT(b.isNotNull());
     const TreeScope* commonScope = Position::commonAncestorTreeScope(a, b);
 
@@ skipping 50 matching lines @@
         if (node->hasEditableStyle(editableType))
             highestRoot = node;
         if (isHTMLBodyElement(*node))
             break;
         node = node->parentNode();
     }
 
     return highestRoot;
 }
 
-ContainerNode* highestEditableRoot(const PositionInComposedTree& position, EditableType editableType)
+ContainerNode* highestEditableRoot(const PositionInFlatTree& position, EditableType editableType)
 {
     return highestEditableRoot(toPositionInDOMTree(position), editableType);
 }
 
 bool isEditablePosition(const Position& p, EditableType editableType, EUpdateStyle updateStyle)
 {
     Node* node = p.parentAnchoredEquivalent().anchorNode();
     if (!node)
         return false;
     if (updateStyle == UpdateStyle)
         node->document().updateLayoutIgnorePendingStylesheets();
     else
         ASSERT(updateStyle == DoNotUpdateStyle);
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
 
     if (node->isDocumentNode())
         return false;
     return node->hasEditableStyle(editableType);
 }
 
-bool isEditablePosition(const PositionInComposedTree& p, EditableType editableType, EUpdateStyle updateStyle)
+bool isEditablePosition(const PositionInFlatTree& p, EditableType editableType, EUpdateStyle updateStyle)
 {
     return isEditablePosition(toPositionInDOMTree(p), editableType, updateStyle);
 }
 
 bool isAtUnsplittableElement(const Position& pos)
 {
     Node* node = pos.anchorNode();
     return (node == rootEditableElementOf(pos) || node == enclosingNodeOfType(pos, &isTableCell));
 }
 
@@ skipping 15 matching lines @@
     Node* node = p.computeContainerNode();
     if (!node)
         return 0;
 
     if (isDisplayInsideTable(node))
         node = node->parentNode();
 
     return node->rootEditableElement(editableType);
 }
 
-Element* rootEditableElementOf(const PositionInComposedTree& p, EditableType editableType)
+Element* rootEditableElementOf(const PositionInFlatTree& p, EditableType editableType)
 {
     return rootEditableElementOf(toPositionInDOMTree(p), editableType);
 }
 
 // TODO(yosin) This does not handle [table, 0] correctly.
 Element* rootEditableElementOf(const VisiblePosition& visiblePosition)
 {
     Node* anchorNode = visiblePosition.deepEquivalent().anchorNode();
     return anchorNode ? anchorNode->rootEditableElement() : nullptr;
 }
@@ skipping 28 matching lines @@
     }
 
     return PositionTemplate<Strategy>();
 }
 
 Position nextCandidate(const Position& position)
 {
     return nextCandidateAlgorithm<EditingStrategy>(position);
 }
 
-PositionInComposedTree nextCandidate(const PositionInComposedTree& position)
+PositionInFlatTree nextCandidate(const PositionInFlatTree& position)
 {
-    return nextCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
+    return nextCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 // |nextVisuallyDistinctCandidate| is similar to |nextCandidate| except
 // for returning position which |downstream()| not equal to initial position's
 // |downstream()|.
 template <typename Strategy>
 static PositionTemplate<Strategy> nextVisuallyDistinctCandidateAlgorithm(const PositionTemplate<Strategy>& position)
 {
     TRACE_EVENT0("input", "EditingUtility::nextVisuallyDistinctCandidateAlgorithm");
     if (position.isNull())
@@ skipping 12 matching lines @@
     }
 
     return PositionTemplate<Strategy>();
 }
 
 Position nextVisuallyDistinctCandidate(const Position& position)
 {
     return nextVisuallyDistinctCandidateAlgorithm<EditingStrategy>(position);
 }
 
-PositionInComposedTree nextVisuallyDistinctCandidate(const PositionInComposedTree& position)
+PositionInFlatTree nextVisuallyDistinctCandidate(const PositionInFlatTree& position)
 {
-    return nextVisuallyDistinctCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
+    return nextVisuallyDistinctCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> previousCandidateAlgorithm(const PositionTemplate<Strategy>& position)
 {
     TRACE_EVENT0("input", "EditingUtility::previousCandidateAlgorithm");
     PositionIteratorAlgorithm<Strategy> p(position);
 
     p.decrement();
     while (!p.atStart()) {
         PositionTemplate<Strategy> candidate = p.computePosition();
         if (isVisuallyEquivalentCandidate(candidate))
             return candidate;
 
         p.decrement();
     }
 
     return PositionTemplate<Strategy>();
 }
 
 Position previousCandidate(const Position& position)
 {
     return previousCandidateAlgorithm<EditingStrategy>(position);
 }
 
-PositionInComposedTree previousCandidate(const PositionInComposedTree& position)
+PositionInFlatTree previousCandidate(const PositionInFlatTree& position)
 {
-    return previousCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
+    return previousCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 // |previousVisuallyDistinctCandidate| is similar to |previousCandidate| except
 // for returning position which |downstream()| not equal to initial position's
 // |downstream()|.
 template <typename Strategy>
 PositionTemplate<Strategy> previousVisuallyDistinctCandidateAlgorithm(const PositionTemplate<Strategy>& position)
 {
     TRACE_EVENT0("input", "EditingUtility::previousVisuallyDistinctCandidateAlgorithm");
     if (position.isNull())
@@ skipping 12 matching lines @@
     }
 
     return PositionTemplate<Strategy>();
 }
 
 Position previousVisuallyDistinctCandidate(const Position& position)
 {
     return previousVisuallyDistinctCandidateAlgorithm<EditingStrategy>(position);
 }
 
-PositionInComposedTree previousVisuallyDistinctCandidate(const PositionInComposedTree& position)
+PositionInFlatTree previousVisuallyDistinctCandidate(const PositionInFlatTree& position)
 {
-    return previousVisuallyDistinctCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
+    return previousVisuallyDistinctCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 VisiblePosition firstEditableVisiblePositionAfterPositionInRoot(const Position& position, ContainerNode& highestRoot)
 {
     return createVisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
 }
 
-VisiblePositionInComposedTree firstEditableVisiblePositionAfterPositionInRoot(const PositionInComposedTree& position, ContainerNode& highestRoot)
+VisiblePositionInFlatTree firstEditableVisiblePositionAfterPositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
     return createVisiblePosition(firstEditablePositionAfterPositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> firstEditablePositionAfterPositionInRootAlgorithm(const PositionTemplate<Strategy>& position, Node& highestRoot)
 {
     // position falls before highestRoot.
     if (position.compareTo(PositionTemplate<Strategy>::firstPositionInNode(&highestRoot)) == -1 && highestRoot.hasEditableStyle())
         return PositionTemplate<Strategy>::firstPositionInNode(&highestRoot);
@@ skipping 15 matching lines @@
         return PositionTemplate<Strategy>();
 
     return editablePosition;
 }
 
 Position firstEditablePositionAfterPositionInRoot(const Position& position, Node& highestRoot)
 {
     return firstEditablePositionAfterPositionInRootAlgorithm<EditingStrategy>(position, highestRoot);
 }
 
-PositionInComposedTree firstEditablePositionAfterPositionInRoot(const PositionInComposedTree& position, Node& highestRoot)
+PositionInFlatTree firstEditablePositionAfterPositionInRoot(const PositionInFlatTree& position, Node& highestRoot)
 {
-    return firstEditablePositionAfterPositionInRootAlgorithm<EditingInComposedTreeStrategy>(position, highestRoot);
+    return firstEditablePositionAfterPositionInRootAlgorithm<EditingInFlatTreeStrategy>(position, highestRoot);
 }
 
 VisiblePosition lastEditableVisiblePositionBeforePositionInRoot(const Position& position, ContainerNode& highestRoot)
 {
     return createVisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
-VisiblePositionInComposedTree lastEditableVisiblePositionBeforePositionInRoot(const PositionInComposedTree& position, ContainerNode& highestRoot)
+VisiblePositionInFlatTree lastEditableVisiblePositionBeforePositionInRoot(const PositionInFlatTree& position, ContainerNode& highestRoot)
 {
     return createVisiblePosition(lastEditablePositionBeforePositionInRoot(position, highestRoot));
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> lastEditablePositionBeforePositionInRootAlgorithm(const PositionTemplate<Strategy>& position, Node& highestRoot)
 {
     // When position falls after highestRoot, the result is easy to compute.
     if (position.compareTo(PositionTemplate<Strategy>::lastPositionInNode(&highestRoot)) == 1)
         return PositionTemplate<Strategy>::lastPositionInNode(&highestRoot);
@@ skipping 14 matching lines @@
     if (editablePosition.anchorNode() && editablePosition.anchorNode() != &highestRoot && !editablePosition.anchorNode()->isDescendantOf(&highestRoot))
         return PositionTemplate<Strategy>();
     return editablePosition;
 }
 
 Position lastEditablePositionBeforePositionInRoot(const Position& position, Node& highestRoot)
 {
     return lastEditablePositionBeforePositionInRootAlgorithm<EditingStrategy>(position, highestRoot);
 }
 
-PositionInComposedTree lastEditablePositionBeforePositionInRoot(const PositionInComposedTree& position, Node& highestRoot)
+PositionInFlatTree lastEditablePositionBeforePositionInRoot(const PositionInFlatTree& position, Node& highestRoot)
 {
-    return lastEditablePositionBeforePositionInRootAlgorithm<EditingInComposedTreeStrategy>(position, highestRoot);
+    return lastEditablePositionBeforePositionInRootAlgorithm<EditingInFlatTreeStrategy>(position, highestRoot);
 }
 
 int uncheckedPreviousOffset(const Node* n, int current)
 {
     return n->layoutObject() ? n->layoutObject()->previousOffset(current) : current - 1;
 }
 
 static int uncheckedPreviousOffsetForBackwardDeletion(const Node* n, int current)
 {
     return n->layoutObject() ? n->layoutObject()->previousOffsetForBackwardDeletion(current) : current - 1;
@@ skipping 43 matching lines @@
         return PositionTemplate<Strategy>(parent, node->nodeIndex());
     }
     return position;
 }
 
 Position previousPositionOf(const Position& position, PositionMoveType moveType)
 {
     return previousPositionOfAlgorithm<EditingStrategy>(position, moveType);
 }
 
-PositionInComposedTree previousPositionOf(const PositionInComposedTree& position, PositionMoveType moveType)
+PositionInFlatTree previousPositionOf(const PositionInFlatTree& position, PositionMoveType moveType)
 {
-    return previousPositionOfAlgorithm<EditingInComposedTreeStrategy>(position, moveType);
+    return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(position, moveType);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> nextPositionOfAlgorithm(const PositionTemplate<Strategy>& position, PositionMoveType moveType)
 {
     ASSERT(moveType != PositionMoveType::BackwardDeletion);
 
     Node* node = position.anchorNode();
     if (!node)
         return position;
@@ skipping 18 matching lines @@
     if (ContainerNode* parent = Strategy::parent(*node))
         return PositionTemplate<Strategy>::editingPositionOf(parent, Strategy::index(*node) + 1);
     return position;
 }
 
 Position nextPositionOf(const Position& position, PositionMoveType moveType)
 {
     return nextPositionOfAlgorithm<EditingStrategy>(position, moveType);
 }
 
-PositionInComposedTree nextPositionOf(const PositionInComposedTree& position, PositionMoveType moveType)
+PositionInFlatTree nextPositionOf(const PositionInFlatTree& position, PositionMoveType moveType)
 {
-    return nextPositionOfAlgorithm<EditingInComposedTreeStrategy>(position, moveType);
+    return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(position, moveType);
 }
 
 bool isEnclosingBlock(const Node* node)
 {
     return node && node->layoutObject() && !node->layoutObject()->isInline() && !node->layoutObject()->isRubyText();
 }
 
 bool isInline(const Node* node)
 {
     return node && node->layoutObject() && node->layoutObject()->isInline();
@@ skipping 15 matching lines @@
 {
     Node* enclosingNode = enclosingNodeOfType(position, isEnclosingBlock, rule);
     return enclosingNode && enclosingNode->isElementNode() ? toElement(enclosingNode) : nullptr;
 }
 
 Element* enclosingBlock(const Position& position, EditingBoundaryCrossingRule rule)
 {
     return enclosingBlockAlgorithm<EditingStrategy>(position, rule);
 }
 
-Element* enclosingBlock(const PositionInComposedTree& position, EditingBoundaryCrossingRule rule)
+Element* enclosingBlock(const PositionInFlatTree& position, EditingBoundaryCrossingRule rule)
 {
-    return enclosingBlockAlgorithm<EditingInComposedTreeStrategy>(position, rule);
+    return enclosingBlockAlgorithm<EditingInFlatTreeStrategy>(position, rule);
 }
 
 Element* enclosingBlockFlowElement(Node& node)
 {
     if (isBlockFlowElement(node))
         return &toElement(node);
 
     for (Node* n = node.parentNode(); n; n = n->parentNode()) {
         if (isBlockFlowElement(*n) || isHTMLBodyElement(*n))
             return toElement(n);
@@ skipping 20 matching lines @@
         return LTR;
     LayoutObject* layoutObject = enclosingBlockElement->layoutObject();
     return layoutObject ? layoutObject->style()->direction() : LTR;
 }
 
 TextDirection directionOfEnclosingBlock(const Position& position)
 {
     return directionOfEnclosingBlockAlgorithm<EditingStrategy>(position);
 }
 
-TextDirection directionOfEnclosingBlock(const PositionInComposedTree& position)
+TextDirection directionOfEnclosingBlock(const PositionInFlatTree& position)
 {
-    return directionOfEnclosingBlockAlgorithm<EditingInComposedTreeStrategy>(position);
+    return directionOfEnclosingBlockAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 TextDirection primaryDirectionOf(const Node& node)
 {
     TextDirection primaryDirection = LTR;
     for (const LayoutObject* r = node.layoutObject(); r; r = r->parent()) {
         if (r->isLayoutBlockFlow()) {
             primaryDirection = r->style()->direction();
             break;
         }
@@ skipping 134 matching lines @@
         return toElement(upstream.anchorNode());
 
     return nullptr;
 }
 
 Element* isFirstPositionAfterTable(const VisiblePosition& visiblePosition)
 {
     return isFirstPositionAfterTableAlgorithm<EditingStrategy>(visiblePosition);
 }
 
-Element* isFirstPositionAfterTable(const VisiblePositionInComposedTree& visiblePosition)
+Element* isFirstPositionAfterTable(const VisiblePositionInFlatTree& visiblePosition)
 {
-    return isFirstPositionAfterTableAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+    return isFirstPositionAfterTableAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 Element* isLastPositionBeforeTable(const VisiblePosition& visiblePosition)
 {
     Position downstream(mostForwardCaretPosition(visiblePosition.deepEquivalent()));
     if (isDisplayInsideTable(downstream.anchorNode()) && downstream.atFirstEditingPositionForNode())
         return toElement(downstream.anchorNode());
 
     return 0;
 }
@@ skipping 124 matching lines @@
     }
 
     return nullptr;
 }
 
 Node* enclosingNodeOfType(const Position& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
 {
     return enclosingNodeOfTypeAlgorithm<EditingStrategy>(p, nodeIsOfType, rule);
 }
 
-Node* enclosingNodeOfType(const PositionInComposedTree& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
+Node* enclosingNodeOfType(const PositionInFlatTree& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule)
 {
-    return enclosingNodeOfTypeAlgorithm<EditingInComposedTreeStrategy>(p, nodeIsOfType, rule);
+    return enclosingNodeOfTypeAlgorithm<EditingInFlatTreeStrategy>(p, nodeIsOfType, rule);
 }
 
 Node* highestEnclosingNodeOfType(const Position& p, bool (*nodeIsOfType)(const Node*), EditingBoundaryCrossingRule rule, Node* stayWithin)
 {
     Node* highest = nullptr;
     ContainerNode* root = rule == CannotCrossEditingBoundary ? highestEditableRoot(p) : nullptr;
     for (Node* n = p.computeContainerNode(); n && n != stayWithin; n = n->parentNode()) {
         if (root && !n->hasEditableStyle())
             continue;
         if (nodeIsOfType(n))
@@ skipping 485 matching lines @@
     if (normalizedStart.compareTo(normalizedEnd) > 0)
         return EphemeralRangeTemplate<Strategy>(normalizedEnd, normalizedStart);
     return EphemeralRangeTemplate<Strategy>(normalizedStart, normalizedEnd);
 }
 
 EphemeralRange normalizeRange(const EphemeralRange& range)
 {
     return normalizeRangeAlgorithm<EditingStrategy>(range);
 }
 
-EphemeralRangeInComposedTree normalizeRange(const EphemeralRangeInComposedTree& range)
+EphemeralRangeInFlatTree normalizeRange(const EphemeralRangeInFlatTree& range)
 {
-    return normalizeRangeAlgorithm<EditingInComposedTreeStrategy>(range);
+    return normalizeRangeAlgorithm<EditingInFlatTreeStrategy>(range);
 }
 
 VisiblePosition visiblePositionForIndex(int index, ContainerNode* scope)
 {
     if (!scope)
         return VisiblePosition();
     EphemeralRange range = PlainTextRange(index).createRangeForSelection(*scope);
     // Check for an invalid index. Certain editing operations invalidate indices
     // because of problems with
     // TextIteratorEmitsCharactersBetweenAllVisiblePositions.
@@ skipping 93 matching lines @@
     // instead of possibly at the end of the last node before the selection
     return mostForwardCaretPosition(visiblePosition.deepEquivalent());
 }
 
 bool isTextSecurityNode(const Node* node)
 {
     return node && node->layoutObject() && node->layoutObject()->style()->textSecurity() != TSNONE;
 }
 
 } // namespace blink