Rename ComposedTree to FlatTree

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 144 matching lines @@
         return prev;
 
     return next;
 }
 
 Position canonicalPositionOf(const Position& position)
 {
     return canonicalPosition(position);
 }
 
-PositionInComposedTree canonicalPositionOf(const PositionInComposedTree& position)
+PositionInFlatTree canonicalPositionOf(const PositionInFlatTree& position)
 {
     return canonicalPosition(position);
 }
 
 template <typename Strategy>
 static PositionWithAffinityTemplate<Strategy> honorEditingBoundaryAtOrBefore(const PositionWithAffinityTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
     if (pos.isNull())
         return pos;
 
@@ skipping 691 matching lines @@
             return c;
     }
     return previousBoundary(p, startWordBoundary);
 }
 
 VisiblePosition startOfWord(const VisiblePosition& c, EWordSide side)
 {
     return startOfWordAlgorithm<EditingStrategy>(c, side);
 }
 
-VisiblePositionInComposedTree startOfWord(const VisiblePositionInComposedTree& c, EWordSide side)
+VisiblePositionInFlatTree startOfWord(const VisiblePositionInFlatTree& c, EWordSide side)
 {
-    return startOfWordAlgorithm<EditingInComposedTreeStrategy>(c, side);
+    return startOfWordAlgorithm<EditingInFlatTreeStrategy>(c, side);
 }
 
 static unsigned endWordBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     ASSERT(offset <= length);
     if (mayHaveMoreContext && endOfFirstWordBoundaryContext(characters + offset, length - offset) == static_cast<int>(length - offset)) {
         needMoreContext = true;
         return length;
     }
     needMoreContext = false;
@@ skipping 16 matching lines @@
     }
 
     return nextBoundary(p, endWordBoundary);
 }
 
 VisiblePosition endOfWord(const VisiblePosition& c, EWordSide side)
 {
     return endOfWordAlgorithm<EditingStrategy>(c, side);
 }
 
-VisiblePositionInComposedTree endOfWord(const VisiblePositionInComposedTree& c, EWordSide side)
+VisiblePositionInFlatTree endOfWord(const VisiblePositionInFlatTree& c, EWordSide side)
 {
-    return endOfWordAlgorithm<EditingInComposedTreeStrategy>(c, side);
+    return endOfWordAlgorithm<EditingInFlatTreeStrategy>(c, side);
 }
 
 static unsigned previousWordPositionBoundary(const UChar* characters, unsigned length, unsigned offset, BoundarySearchContextAvailability mayHaveMoreContext, bool& needMoreContext)
 {
     if (mayHaveMoreContext && !startOfLastWordBoundaryContext(characters, offset)) {
         needMoreContext = true;
         return 0;
     }
     needMoreContext = false;
     return findNextWordFromIndex(characters, length, offset, false);
@@ skipping 73 matching lines @@
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     PositionWithAffinityTemplate<Strategy> visPos = startPositionForLine(c, UseInlineBoxOrdering);
     return honorEditingBoundaryAtOrBefore(visPos, c.position());
 }
 
 static PositionWithAffinity startOfLine(const PositionWithAffinity& currentPosition)
 {
     return startOfLineAlgorithm<EditingStrategy>(currentPosition);
 }
 
-static PositionInComposedTreeWithAffinity startOfLine(const PositionInComposedTreeWithAffinity& currentPosition)
+static PositionInFlatTreeWithAffinity startOfLine(const PositionInFlatTreeWithAffinity& currentPosition)
 {
-    return startOfLineAlgorithm<EditingInComposedTreeStrategy>(currentPosition);
+    return startOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition);
 }
 
 // FIXME: Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition startOfLine(const VisiblePosition& currentPosition)
 {
     return createVisiblePosition(startOfLine(currentPosition.toPositionWithAffinity()));
 }
 
-VisiblePositionInComposedTree startOfLine(const VisiblePositionInComposedTree& currentPosition)
+VisiblePositionInFlatTree startOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
     return createVisiblePosition(startOfLine(currentPosition.toPositionWithAffinity()));
 }
 
 template <typename Strategy>
 static PositionWithAffinityTemplate<Strategy> logicalStartOfLineAlgorithm(const PositionWithAffinityTemplate<Strategy>& c)
 {
     // TODO: this is the current behavior that might need to be fixed.
     // Please refer to https://bugs.webkit.org/show_bug.cgi?id=49107 for detail.
     PositionWithAffinityTemplate<Strategy> visPos = startPositionForLine(c, UseLogicalOrdering);
 
     if (ContainerNode* editableRoot = highestEditableRoot(c.position())) {
         if (!editableRoot->contains(visPos.position().computeContainerNode()))
             return PositionWithAffinityTemplate<Strategy>(PositionTemplate<Strategy>::firstPositionInNode(editableRoot));
     }
 
     return honorEditingBoundaryAtOrBefore(visPos, c.position());
 }
 
 VisiblePosition logicalStartOfLine(const VisiblePosition& currentPosition)
 {
     return createVisiblePosition(logicalStartOfLineAlgorithm<EditingStrategy>(currentPosition.toPositionWithAffinity()));
 }
 
-VisiblePositionInComposedTree logicalStartOfLine(const VisiblePositionInComposedTree& currentPosition)
+VisiblePositionInFlatTree logicalStartOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
-    return createVisiblePosition(logicalStartOfLineAlgorithm<EditingInComposedTreeStrategy>(currentPosition.toPositionWithAffinity()));
+    return createVisiblePosition(logicalStartOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition.toPositionWithAffinity()));
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endPositionForLine(const VisiblePositionTemplate<Strategy>& c, LineEndpointComputationMode mode)
 {
     if (c.isNull())
         return VisiblePositionTemplate<Strategy>();
 
     RootInlineBox* rootBox = RenderedPosition(c).rootBox();
     if (!rootBox) {
@@ skipping 69 matching lines @@
 
     return honorEditingBoundaryAtOrAfter(visPos, currentPosition.deepEquivalent());
 }
 
 // TODO(yosin) Rename this function to reflect the fact it ignores bidi levels.
 VisiblePosition endOfLine(const VisiblePosition& currentPosition)
 {
     return endOfLineAlgorithm<EditingStrategy>(currentPosition);
 }
 
-VisiblePositionInComposedTree endOfLine(const VisiblePositionInComposedTree& currentPosition)
+VisiblePositionInFlatTree endOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
-    return endOfLineAlgorithm<EditingInComposedTreeStrategy>(currentPosition);
+    return endOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition);
 }
 
 template <typename Strategy>
 static bool inSameLogicalLine(const VisiblePositionTemplate<Strategy>& a, const VisiblePositionTemplate<Strategy>& b)
 {
     return a.isNotNull() && logicalStartOfLine(a).deepEquivalent() == logicalStartOfLine(b).deepEquivalent();
 }
 
 template <typename Strategy>
 VisiblePositionTemplate<Strategy> logicalEndOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& currentPosition)
@@ skipping 19 matching lines @@
     }
 
     return honorEditingBoundaryAtOrAfter(visPos, currentPosition.deepEquivalent());
 }
 
 VisiblePosition logicalEndOfLine(const VisiblePosition& currentPosition)
 {
     return logicalEndOfLineAlgorithm<EditingStrategy>(currentPosition);
 }
 
-VisiblePositionInComposedTree logicalEndOfLine(const VisiblePositionInComposedTree& currentPosition)
+VisiblePositionInFlatTree logicalEndOfLine(const VisiblePositionInFlatTree& currentPosition)
 {
-    return logicalEndOfLineAlgorithm<EditingInComposedTreeStrategy>(currentPosition);
+    return logicalEndOfLineAlgorithm<EditingInFlatTreeStrategy>(currentPosition);
 }
 
 template <typename Strategy>
 bool inSameLineAlgorithm(const PositionWithAffinityTemplate<Strategy>& position1, const PositionWithAffinityTemplate<Strategy>& position2)
 {
     if (position1.isNull() || position2.isNull())
         return false;
     PositionWithAffinityTemplate<Strategy> startOfLine1 = startOfLine(position1);
     PositionWithAffinityTemplate<Strategy> startOfLine2 = startOfLine(position2);
     if (startOfLine1 == startOfLine2)
         return true;
     PositionTemplate<Strategy> canonicalized1 = canonicalPositionOf(startOfLine1.position());
     if (canonicalized1 == startOfLine2.position())
         return true;
     return canonicalized1 == canonicalPositionOf(startOfLine2.position());
 }
 
 bool inSameLine(const PositionWithAffinity& a, const PositionWithAffinity& b)
 {
     return inSameLineAlgorithm<EditingStrategy>(a, b);
 }
 
-bool inSameLine(const PositionInComposedTreeWithAffinity& position1, const PositionInComposedTreeWithAffinity& position2)
+bool inSameLine(const PositionInFlatTreeWithAffinity& position1, const PositionInFlatTreeWithAffinity& position2)
 {
-    return inSameLineAlgorithm<EditingInComposedTreeStrategy>(position1, position2);
+    return inSameLineAlgorithm<EditingInFlatTreeStrategy>(position1, position2);
 }
 
 bool inSameLine(const VisiblePosition& position1, const VisiblePosition& position2)
 {
     return inSameLine(position1.toPositionWithAffinity(), position2.toPositionWithAffinity());
 }
 
-bool inSameLine(const VisiblePositionInComposedTree& position1, const VisiblePositionInComposedTree& position2)
+bool inSameLine(const VisiblePositionInFlatTree& position1, const VisiblePositionInFlatTree& position2)
 {
     return inSameLine(position1.toPositionWithAffinity(), position2.toPositionWithAffinity());
 }
 
 template <typename Strategy>
 bool isStartOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& p)
 {
     return p.isNotNull() && p.deepEquivalent() == startOfLine(p).deepEquivalent();
 }
 
 bool isStartOfLine(const VisiblePosition& p)
 {
     return isStartOfLineAlgorithm<EditingStrategy>(p);
 }
 
-bool isStartOfLine(const VisiblePositionInComposedTree& p)
+bool isStartOfLine(const VisiblePositionInFlatTree& p)
 {
-    return isStartOfLineAlgorithm<EditingInComposedTreeStrategy>(p);
+    return isStartOfLineAlgorithm<EditingInFlatTreeStrategy>(p);
 }
 
 template <typename Strategy>
 bool isEndOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& p)
 {
     return p.isNotNull() && p.deepEquivalent() == endOfLine(p).deepEquivalent();
 }
 
 bool isEndOfLine(const VisiblePosition& p)
 {
     return isEndOfLineAlgorithm<EditingStrategy>(p);
 }
 
-bool isEndOfLine(const VisiblePositionInComposedTree& p)
+bool isEndOfLine(const VisiblePositionInFlatTree& p)
 {
-    return isEndOfLineAlgorithm<EditingInComposedTreeStrategy>(p);
+    return isEndOfLineAlgorithm<EditingInFlatTreeStrategy>(p);
 }
 
 template <typename Strategy>
 static bool isLogicalEndOfLineAlgorithm(const VisiblePositionTemplate<Strategy>& p)
 {
     return p.isNotNull() && p.deepEquivalent() == logicalEndOfLine(p).deepEquivalent();
 }
 
 bool isLogicalEndOfLine(const VisiblePosition& p)
 {
     return isLogicalEndOfLineAlgorithm<EditingStrategy>(p);
 }
 
-bool isLogicalEndOfLine(const VisiblePositionInComposedTree& p)
+bool isLogicalEndOfLine(const VisiblePositionInFlatTree& p)
 {
-    return isLogicalEndOfLineAlgorithm<EditingInComposedTreeStrategy>(p);
+    return isLogicalEndOfLineAlgorithm<EditingInFlatTreeStrategy>(p);
 }
 
 static inline LayoutPoint absoluteLineDirectionPointToLocalPointInBlock(RootInlineBox* root, LayoutUnit lineDirectionPoint)
 {
     ASSERT(root);
     LayoutBlockFlow& containingBlock = root->block();
     FloatPoint absoluteBlockPoint = containingBlock.localToAbsolute(FloatPoint());
     if (containingBlock.hasOverflowClip())
         absoluteBlockPoint -= FloatSize(containingBlock.scrolledContentOffset());
 
@@ skipping 125 matching lines @@
 static VisiblePositionTemplate<Strategy> startOfSentenceAlgorithm(const VisiblePositionTemplate<Strategy>& c)
 {
     return previousBoundary(c, startSentenceBoundary);
 }
 
 VisiblePosition startOfSentence(const VisiblePosition& c)
 {
     return startOfSentenceAlgorithm<EditingStrategy>(c);
 }
 
-VisiblePositionInComposedTree startOfSentence(const VisiblePositionInComposedTree& c)
+VisiblePositionInFlatTree startOfSentence(const VisiblePositionInFlatTree& c)
 {
-    return startOfSentenceAlgorithm<EditingInComposedTreeStrategy>(c);
+    return startOfSentenceAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 static unsigned endSentenceBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     return iterator->next();
 }
 
 // TODO(yosin) This includes the space after the punctuation that marks the end
 // of the sentence.
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfSentenceAlgorithm(const VisiblePositionTemplate<Strategy>& c)
 {
     return nextBoundary(c, endSentenceBoundary);
 }
 
 VisiblePosition endOfSentence(const VisiblePosition& c)
 {
     return endOfSentenceAlgorithm<EditingStrategy>(c);
 }
 
-VisiblePositionInComposedTree endOfSentence(const VisiblePositionInComposedTree& c)
+VisiblePositionInFlatTree endOfSentence(const VisiblePositionInFlatTree& c)
 {
-    return endOfSentenceAlgorithm<EditingInComposedTreeStrategy>(c);
+    return endOfSentenceAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 static unsigned previousSentencePositionBoundary(const UChar* characters, unsigned length, unsigned, BoundarySearchContextAvailability, bool&)
 {
     // FIXME: This is identical to startSentenceBoundary. I'm pretty sure that's not right.
     TextBreakIterator* iterator = sentenceBreakIterator(characters, length);
     // FIXME: The following function can return -1; we don't handle that.
     return iterator->preceding(length);
 }
 
@@ skipping 91 matching lines @@
         return createVisiblePosition(PositionTemplate<Strategy>(node, offset));
 
     return createVisiblePosition(PositionTemplate<Strategy>(node, type));
 }
 
 VisiblePosition startOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return startOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
 }
 
-VisiblePositionInComposedTree startOfParagraph(const VisiblePositionInComposedTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+VisiblePositionInFlatTree startOfParagraph(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    return startOfParagraphAlgorithm<EditingInComposedTreeStrategy>(c, boundaryCrossingRule);
+    return startOfParagraphAlgorithm<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     if (c.isNull())
         return VisiblePositionTemplate<Strategy>();
 
     const PositionTemplate<Strategy> p = c.deepEquivalent();
     Node* startNode = p.anchorNode();
@@ skipping 64 matching lines @@
         return createVisiblePosition(PositionTemplate<Strategy>(node, offset));
 
     return createVisiblePosition(PositionTemplate<Strategy>(node, type));
 }
 
 VisiblePosition endOfParagraph(const VisiblePosition& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return endOfParagraphAlgorithm<EditingStrategy>(c, boundaryCrossingRule);
 }
 
-VisiblePositionInComposedTree endOfParagraph(const VisiblePositionInComposedTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
+VisiblePositionInFlatTree endOfParagraph(const VisiblePositionInFlatTree& c, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    return endOfParagraphAlgorithm<EditingInComposedTreeStrategy>(c, boundaryCrossingRule);
+    return endOfParagraphAlgorithm<EditingInFlatTreeStrategy>(c, boundaryCrossingRule);
 }
 
 // FIXME: isStartOfParagraph(startOfNextParagraph(pos)) is not always true
 VisiblePosition startOfNextParagraph(const VisiblePosition& visiblePosition)
 {
     VisiblePosition paragraphEnd(endOfParagraph(visiblePosition, CanSkipOverEditingBoundary));
     VisiblePosition afterParagraphEnd(nextPositionOf(paragraphEnd, CannotCrossEditingBoundary));
     // The position after the last position in the last cell of a table
     // is not the start of the next paragraph.
     if (isFirstPositionAfterTable(afterParagraphEnd))
@@ skipping 10 matching lines @@
 static bool isStartOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return pos.isNotNull() && pos.deepEquivalent() == startOfParagraph(pos, boundaryCrossingRule).deepEquivalent();
 }
 
 bool isStartOfParagraph(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return isStartOfParagraphAlgorithm<EditingStrategy>(pos, boundaryCrossingRule);
 }
 
-bool isStartOfParagraph(const VisiblePositionInComposedTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+bool isStartOfParagraph(const VisiblePositionInFlatTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    return isStartOfParagraphAlgorithm<EditingInComposedTreeStrategy>(pos, boundaryCrossingRule);
+    return isStartOfParagraphAlgorithm<EditingInFlatTreeStrategy>(pos, boundaryCrossingRule);
 }
 
 template <typename Strategy>
 static bool isEndOfParagraphAlgorithm(const VisiblePositionTemplate<Strategy>& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return pos.isNotNull() && pos.deepEquivalent() == endOfParagraph(pos, boundaryCrossingRule).deepEquivalent();
 }
 
 bool isEndOfParagraph(const VisiblePosition& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
     return isEndOfParagraphAlgorithm<EditingStrategy>(pos, boundaryCrossingRule);
 }
 
-bool isEndOfParagraph(const VisiblePositionInComposedTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
+bool isEndOfParagraph(const VisiblePositionInFlatTree& pos, EditingBoundaryCrossingRule boundaryCrossingRule)
 {
-    return isEndOfParagraphAlgorithm<EditingInComposedTreeStrategy>(pos, boundaryCrossingRule);
+    return isEndOfParagraphAlgorithm<EditingInFlatTreeStrategy>(pos, boundaryCrossingRule);
 }
 
 VisiblePosition previousParagraphPosition(const VisiblePosition& p, LayoutUnit x)
 {
     VisiblePosition pos = p;
     do {
         VisiblePosition n = previousLinePosition(pos, x);
         if (n.isNull() || n.deepEquivalent() == pos.deepEquivalent())
             break;
         pos = n;
@@ skipping 54 matching lines @@
         return VisiblePositionTemplate<Strategy>();
 
     return createVisiblePosition(PositionTemplate<Strategy>::firstPositionInNode(node->document().documentElement()));
 }
 
 VisiblePosition startOfDocument(const VisiblePosition& c)
 {
     return startOfDocumentAlgorithm<EditingStrategy>(c);
 }
 
-VisiblePositionInComposedTree startOfDocument(const VisiblePositionInComposedTree& c)
+VisiblePositionInFlatTree startOfDocument(const VisiblePositionInFlatTree& c)
 {
-    return startOfDocumentAlgorithm<EditingInComposedTreeStrategy>(c);
+    return startOfDocumentAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> endOfDocumentAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     Node* node = visiblePosition.deepEquivalent().anchorNode();
     if (!node || !node->document().documentElement())
         return VisiblePositionTemplate<Strategy>();
 
     Element* doc = node->document().documentElement();
     return createVisiblePosition(PositionTemplate<Strategy>::lastPositionInNode(doc));
 }
 
 VisiblePosition endOfDocument(const VisiblePosition& c)
 {
     return endOfDocumentAlgorithm<EditingStrategy>(c);
 }
 
-VisiblePositionInComposedTree endOfDocument(const VisiblePositionInComposedTree& c)
+VisiblePositionInFlatTree endOfDocument(const VisiblePositionInFlatTree& c)
 {
-    return endOfDocumentAlgorithm<EditingInComposedTreeStrategy>(c);
+    return endOfDocumentAlgorithm<EditingInFlatTreeStrategy>(c);
 }
 
 bool isStartOfDocument(const VisiblePosition& p)
 {
     return p.isNotNull() && previousPositionOf(p, CanCrossEditingBoundary).isNull();
 }
 
 bool isEndOfDocument(const VisiblePosition& p)
 {
     return p.isNotNull() && nextPositionOf(p, CanCrossEditingBoundary).isNull();
@@ skipping 19 matching lines @@
     return createVisiblePosition(lastPositionInNode(highestRoot));
 }
 
 bool isEndOfEditableOrNonEditableContent(const VisiblePosition& position)
 {
     return position.isNotNull() && nextPositionOf(position).isNull();
 }
 
 // TODO(yosin) We should rename |isEndOfEditableOrNonEditableContent()| what
 // this function does, e.g. |isLastVisiblePositionOrEndOfInnerEditor()|.
-bool isEndOfEditableOrNonEditableContent(const VisiblePositionInComposedTree& position)
+bool isEndOfEditableOrNonEditableContent(const VisiblePositionInFlatTree& position)
 {
     if (position.isNull())
         return false;
-    const VisiblePositionInComposedTree nextPosition = nextPositionOf(position);
+    const VisiblePositionInFlatTree nextPosition = nextPositionOf(position);
     if (nextPosition.isNull())
         return true;
     // In DOM version, following condition, the last position of inner editor
     // of INPUT/TEXTAREA element, by |nextPosition().isNull()|, because of
     // an inner editor is an only leaf node.
     if (!nextPosition.deepEquivalent().isAfterAnchor())
         return false;
     return isHTMLTextFormControlElement(nextPosition.deepEquivalent().anchorNode());
 }
 
@@ skipping 236 matching lines @@
 static InlineBoxPosition computeInlineBoxPositionTemplate(const PositionTemplate<Strategy>& position, TextAffinity affinity)
 {
     return computeInlineBoxPositionTemplate<Strategy>(position, affinity, primaryDirectionOf(*position.anchorNode()));
 }
 
 InlineBoxPosition computeInlineBoxPosition(const Position& position, TextAffinity affinity)
 {
     return computeInlineBoxPositionTemplate<EditingStrategy>(position, affinity);
 }
 
-InlineBoxPosition computeInlineBoxPosition(const PositionInComposedTree& position, TextAffinity affinity)
+InlineBoxPosition computeInlineBoxPosition(const PositionInFlatTree& position, TextAffinity affinity)
 {
-    return computeInlineBoxPositionTemplate<EditingInComposedTreeStrategy>(position, affinity);
+    return computeInlineBoxPositionTemplate<EditingInFlatTreeStrategy>(position, affinity);
 }
 
 InlineBoxPosition computeInlineBoxPosition(const VisiblePosition& position)
 {
     return computeInlineBoxPosition(position.deepEquivalent(), position.affinity());
 }
 
-InlineBoxPosition computeInlineBoxPosition(const VisiblePositionInComposedTree& position)
+InlineBoxPosition computeInlineBoxPosition(const VisiblePositionInFlatTree& position)
 {
     return computeInlineBoxPosition(position.deepEquivalent(), position.affinity());
 }
 
 InlineBoxPosition computeInlineBoxPosition(const Position& position, TextAffinity affinity, TextDirection primaryDirection)
 {
     return computeInlineBoxPositionTemplate<EditingStrategy>(position, affinity, primaryDirection);
 }
 
-InlineBoxPosition computeInlineBoxPosition(const PositionInComposedTree& position, TextAffinity affinity, TextDirection primaryDirection)
+InlineBoxPosition computeInlineBoxPosition(const PositionInFlatTree& position, TextAffinity affinity, TextDirection primaryDirection)
 {
-    return computeInlineBoxPositionTemplate<EditingInComposedTreeStrategy>(position, affinity, primaryDirection);
+    return computeInlineBoxPositionTemplate<EditingInFlatTreeStrategy>(position, affinity, primaryDirection);
 }
 
 template <typename Strategy>
 LayoutRect localCaretRectOfPositionTemplate(const PositionWithAffinityTemplate<Strategy>& position, LayoutObject*& layoutObject)
 {
     if (position.position().isNull()) {
         layoutObject = nullptr;
         return LayoutRect();
     }
     Node* node = position.position().anchorNode();
 
     layoutObject = node->layoutObject();
     if (!layoutObject)
         return LayoutRect();
 
     InlineBoxPosition boxPosition = computeInlineBoxPosition(position.position(), position.affinity());
 
     if (boxPosition.inlineBox)
         layoutObject = LineLayoutAPIShim::layoutObjectFrom(boxPosition.inlineBox->lineLayoutItem());
 
     return layoutObject->localCaretRect(boxPosition.inlineBox, boxPosition.offsetInBox);
 }
 
 LayoutRect localCaretRectOfPosition(const PositionWithAffinity& position, LayoutObject*& layoutObject)
 {
     return localCaretRectOfPositionTemplate<EditingStrategy>(position, layoutObject);
 }
 
-LayoutRect localCaretRectOfPosition(const PositionInComposedTreeWithAffinity& position, LayoutObject*& layoutObject)
+LayoutRect localCaretRectOfPosition(const PositionInFlatTreeWithAffinity& position, LayoutObject*& layoutObject)
 {
-    return localCaretRectOfPositionTemplate<EditingInComposedTreeStrategy>(position, layoutObject);
+    return localCaretRectOfPositionTemplate<EditingInFlatTreeStrategy>(position, layoutObject);
 }
 
 static int boundingBoxLogicalHeight(LayoutObject *o, const IntRect &rect)
 {
     return o->style()->isHorizontalWritingMode() ? rect.height() : rect.width();
 }
 
 bool hasRenderedNonAnonymousDescendantsWithHeight(LayoutObject* layoutObject)
 {
     LayoutObject* stop = layoutObject->nextInPreOrderAfterChildren();
@@ skipping 428 matching lines @@
         }
     }
     return lastVisible.deprecatedComputePosition();
 }
 
 Position mostBackwardCaretPosition(const Position& position, EditingBoundaryCrossingRule rule)
 {
     return mostBackwardCaretPosition<EditingStrategy>(position, rule);
 }
 
-PositionInComposedTree mostBackwardCaretPosition(const PositionInComposedTree& position, EditingBoundaryCrossingRule rule)
+PositionInFlatTree mostBackwardCaretPosition(const PositionInFlatTree& position, EditingBoundaryCrossingRule rule)
 {
-    return mostBackwardCaretPosition<EditingInComposedTreeStrategy>(position, rule);
+    return mostBackwardCaretPosition<EditingInFlatTreeStrategy>(position, rule);
 }
 
 template <typename Strategy>
 PositionTemplate<Strategy> mostForwardCaretPosition(const PositionTemplate<Strategy>& position, EditingBoundaryCrossingRule rule)
 {
     TRACE_EVENT0("input", "VisibleUnits::mostForwardCaretPosition");
 
     Node* startNode = position.anchorNode();
     if (!startNode)
         return PositionTemplate<Strategy>();
@@ skipping 109 matching lines @@
     }
 
     return lastVisible.deprecatedComputePosition();
 }
 
 Position mostForwardCaretPosition(const Position& position, EditingBoundaryCrossingRule rule)
 {
     return mostForwardCaretPosition<EditingStrategy>(position, rule);
 }
 
-PositionInComposedTree mostForwardCaretPosition(const PositionInComposedTree& position, EditingBoundaryCrossingRule rule)
+PositionInFlatTree mostForwardCaretPosition(const PositionInFlatTree& position, EditingBoundaryCrossingRule rule)
 {
-    return mostForwardCaretPosition<EditingInComposedTreeStrategy>(position, rule);
+    return mostForwardCaretPosition<EditingInFlatTreeStrategy>(position, rule);
 }
 
 // Returns true if the visually equivalent positions around have different
 // editability. A position is considered at editing boundary if one of the
 // following is true:
 // 1. It is the first position in the node and the next visually equivalent
 //    position is non editable.
 // 2. It is the last position in the node and the previous visually equivalent
 //    position is non editable.
 // 3. It is an editable position and both the next and previous visually
@@ skipping 75 matching lines @@
     }
 
     return false;
 }
 
 bool isVisuallyEquivalentCandidate(const Position& position)
 {
     return isVisuallyEquivalentCandidateAlgorithm<EditingStrategy>(position);
 }
 
-bool isVisuallyEquivalentCandidate(const PositionInComposedTree& position)
+bool isVisuallyEquivalentCandidate(const PositionInFlatTree& position)
 {
-    return isVisuallyEquivalentCandidateAlgorithm<EditingInComposedTreeStrategy>(position);
+    return isVisuallyEquivalentCandidateAlgorithm<EditingInFlatTreeStrategy>(position);
 }
 
 template <typename Strategy>
 static IntRect absoluteCaretBoundsOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     LayoutObject* layoutObject;
     LayoutRect localRect = localCaretRectOfPosition(visiblePosition.toPositionWithAffinity(), layoutObject);
     if (localRect.isEmpty() || !layoutObject)
         return IntRect();
 
     return layoutObject->localToAbsoluteQuad(FloatRect(localRect)).enclosingBoundingBox();
 }
 
 IntRect absoluteCaretBoundsOf(const VisiblePosition& visiblePosition)
 {
     return absoluteCaretBoundsOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
-IntRect absoluteCaretBoundsOf(const VisiblePositionInComposedTree& visiblePosition)
+IntRect absoluteCaretBoundsOf(const VisiblePositionInFlatTree& visiblePosition)
 {
-    return absoluteCaretBoundsOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+    return absoluteCaretBoundsOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> skipToEndOfEditingBoundary(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
@@ skipping 32 matching lines @@
         return 0;
 
     return textNode->data().characterStartingAt(offset);
 }
 
 UChar32 characterAfter(const VisiblePosition& visiblePosition)
 {
     return characterAfterAlgorithm<EditingStrategy>(visiblePosition);
 }
 
-UChar32 characterAfter(const VisiblePositionInComposedTree& visiblePosition)
+UChar32 characterAfter(const VisiblePositionInFlatTree& visiblePosition)
 {
-    return characterAfterAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+    return characterAfterAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static UChar32 characterBeforeAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     return characterAfter(previousPositionOf(visiblePosition));
 }
 
 UChar32 characterBefore(const VisiblePosition& visiblePosition)
 {
     return characterBeforeAlgorithm<EditingStrategy>(visiblePosition);
 }
 
-UChar32 characterBefore(const VisiblePositionInComposedTree& visiblePosition)
+UChar32 characterBefore(const VisiblePositionInFlatTree& visiblePosition)
 {
-    return characterBeforeAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+    return characterBeforeAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static PositionTemplate<Strategy> leftVisuallyDistinctCandidate(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     const PositionTemplate<Strategy> deepPosition = visiblePosition.deepEquivalent();
     PositionTemplate<Strategy> p = deepPosition;
 
     if (p.isNull())
         return PositionTemplate<Strategy>();
@@ skipping 153 matching lines @@
     ASSERT(left.deepEquivalent() != visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(left.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrBefore(left, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrAfter(left, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition leftPositionOf(const VisiblePosition& visiblePosition)
 {
     return leftPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
-VisiblePositionInComposedTree leftPositionOf(const VisiblePositionInComposedTree& visiblePosition)
+VisiblePositionInFlatTree leftPositionOf(const VisiblePositionInFlatTree& visiblePosition)
 {
-    return leftPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+    return leftPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static PositionTemplate<Strategy> rightVisuallyDistinctCandidate(const VisiblePositionTemplate<Strategy>& visiblePosition)
 {
     const PositionTemplate<Strategy> deepPosition = visiblePosition.deepEquivalent();
     PositionTemplate<Strategy> p = deepPosition;
     if (p.isNull())
         return PositionTemplate<Strategy>();
 
@@ skipping 155 matching lines @@
     ASSERT(right.deepEquivalent() != visiblePosition.deepEquivalent());
 
     return directionOfEnclosingBlock(right.deepEquivalent()) == LTR ? honorEditingBoundaryAtOrAfter(right, visiblePosition.deepEquivalent()) : honorEditingBoundaryAtOrBefore(right, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition rightPositionOf(const VisiblePosition& visiblePosition)
 {
     return rightPositionOfAlgorithm<EditingStrategy>(visiblePosition);
 }
 
-VisiblePositionInComposedTree rightPositionOf(const VisiblePositionInComposedTree& visiblePosition)
+VisiblePositionInFlatTree rightPositionOf(const VisiblePositionInFlatTree& visiblePosition)
 {
-    return rightPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition);
+    return rightPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> nextPositionOfAlgorithm(const VisiblePositionTemplate<Strategy>& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     const VisiblePositionTemplate<Strategy> next = createVisiblePosition(nextVisuallyDistinctCandidate(visiblePosition.deepEquivalent()), visiblePosition.affinity());
 
     switch (rule) {
     case CanCrossEditingBoundary:
         return next;
     case CannotCrossEditingBoundary:
         return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
     case CanSkipOverEditingBoundary:
         return skipToEndOfEditingBoundary(next, visiblePosition.deepEquivalent());
     }
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrAfter(next, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition nextPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return nextPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
-VisiblePositionInComposedTree nextPositionOf(const VisiblePositionInComposedTree& visiblePosition, EditingBoundaryCrossingRule rule)
+VisiblePositionInFlatTree nextPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    return nextPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition, rule);
+    return nextPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 template <typename Strategy>
 static VisiblePositionTemplate<Strategy> skipToStartOfEditingBoundary(const VisiblePositionTemplate<Strategy>& pos, const PositionTemplate<Strategy>& anchor)
 {
     if (pos.isNull())
         return pos;
 
     ContainerNode* highestRoot = highestEditableRoot(anchor);
     ContainerNode* highestRootOfPos = highestEditableRoot(pos.deepEquivalent());
@@ skipping 40 matching lines @@
 
     ASSERT_NOT_REACHED();
     return honorEditingBoundaryAtOrBefore(prev, visiblePosition.deepEquivalent());
 }
 
 VisiblePosition previousPositionOf(const VisiblePosition& visiblePosition, EditingBoundaryCrossingRule rule)
 {
     return previousPositionOfAlgorithm<EditingStrategy>(visiblePosition, rule);
 }
 
-VisiblePositionInComposedTree previousPositionOf(const VisiblePositionInComposedTree& visiblePosition, EditingBoundaryCrossingRule rule)
+VisiblePositionInFlatTree previousPositionOf(const VisiblePositionInFlatTree& visiblePosition, EditingBoundaryCrossingRule rule)
 {
-    return previousPositionOfAlgorithm<EditingInComposedTreeStrategy>(visiblePosition, rule);
+    return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(visiblePosition, rule);
 }
 
 } // namespace blink