Rename ComposedTree to FlatTree

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

 /*
  * Copyright (C) 2004, 2005, 2006, 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 265 matching lines @@
         return child;
     return Strategy::nextSkippingChildren(*m_anchorNode);
 }
 
 template <typename Strategy>
 Node* PositionTemplate<Strategy>::commonAncestorContainer(const PositionTemplate<Strategy>& other) const
 {
     return Strategy::commonAncestor(*computeContainerNode(), *other.computeContainerNode());
 }
 
-int comparePositions(const PositionInComposedTree& positionA, const PositionInComposedTree& positionB)
+int comparePositions(const PositionInFlatTree& positionA, const PositionInFlatTree& positionB)
 {
     ASSERT(positionA.isNotNull());
     ASSERT(positionB.isNotNull());
 
     positionA.anchorNode()->updateDistribution();
     Node* containerA = positionA.computeContainerNode();
     positionB.anchorNode()->updateDistribution();
     Node* containerB = positionB.computeContainerNode();
     int offsetA = positionA.computeOffsetInContainerNode();
     int offsetB = positionB.computeOffsetInContainerNode();
-    return comparePositionsInComposedTree(containerA, offsetA, containerB, offsetB);
+    return comparePositionsInFlatTree(containerA, offsetA, containerB, offsetB);
 }
 
 template <typename Strategy>
 int PositionTemplate<Strategy>::compareTo(const PositionTemplate<Strategy>& other) const
 {
     return comparePositions(*this, other);
 }
 
 template <typename Strategy>
 bool PositionTemplate<Strategy>::atFirstEditingPositionForNode() const
@@ skipping 68 matching lines @@
 
     const char* anchorType = anchorTypes[std::min(static_cast<size_t>(m_anchorType), WTF_ARRAY_LENGTH(anchorTypes) - 1)];
     if (m_anchorNode->isTextNode()) {
         fprintf(stderr, "Position [%s]: %s [%p] %s, (%s) at %d\n", msg, anchorNode()->nodeName().utf8().data(), anchorNode(), anchorType, m_anchorNode->nodeValue().utf8().data(), m_offset);
         return;
     }
 
     fprintf(stderr, "Position [%s]: %s [%p] %s at %d\n", msg, anchorNode()->nodeName().utf8().data(), anchorNode(), anchorType, m_offset);
 }
 
-PositionInComposedTree toPositionInComposedTree(const Position& pos)
+PositionInFlatTree toPositionInFlatTree(const Position& pos)
 {
     if (pos.isNull())
-        return PositionInComposedTree();
+        return PositionInFlatTree();
 
     if (pos.isOffsetInAnchor()) {
         Node* anchor = pos.anchorNode();
         if (anchor->offsetInCharacters())
-            return PositionInComposedTree(anchor, pos.computeOffsetInContainerNode());
+            return PositionInFlatTree(anchor, pos.computeOffsetInContainerNode());
         ASSERT(!anchor->isSlotOrActiveInsertionPoint());
         int offset = pos.computeOffsetInContainerNode();
         Node* child = NodeTraversal::childAt(*anchor, offset);
         if (!child) {
             if (anchor->isShadowRoot())
-                return PositionInComposedTree(anchor->shadowHost(), PositionAnchorType::AfterChildren);
-            return PositionInComposedTree(anchor, PositionAnchorType::AfterChildren);
+                return PositionInFlatTree(anchor->shadowHost(), PositionAnchorType::AfterChildren);
+            return PositionInFlatTree(anchor, PositionAnchorType::AfterChildren);
         }
         child->updateDistribution();
         if (child->isSlotOrActiveInsertionPoint()) {
             if (anchor->isShadowRoot())
-                return PositionInComposedTree(anchor->shadowHost(), offset);
-            return PositionInComposedTree(anchor, offset);
+                return PositionInFlatTree(anchor->shadowHost(), offset);
+            return PositionInFlatTree(anchor, offset);
         }
-        if (Node* parent = ComposedTreeTraversal::parent(*child))
-            return PositionInComposedTree(parent, ComposedTreeTraversal::index(*child));
-        // When |pos| isn't appeared in composed tree, we map |pos| to after
+        if (Node* parent = FlatTreeTraversal::parent(*child))
+            return PositionInFlatTree(parent, FlatTreeTraversal::index(*child));
+        // When |pos| isn't appeared in flat tree, we map |pos| to after
         // children of shadow host.
         // e.g. "foo",0 in <progress>foo</progress>
         if (anchor->isShadowRoot())
-            return PositionInComposedTree(anchor->shadowHost(), PositionAnchorType::AfterChildren);
-        return PositionInComposedTree(anchor, PositionAnchorType::AfterChildren);
+            return PositionInFlatTree(anchor->shadowHost(), PositionAnchorType::AfterChildren);
+        return PositionInFlatTree(anchor, PositionAnchorType::AfterChildren);
     }
 
-    return PositionInComposedTree(pos.anchorNode(), pos.anchorType());
+    return PositionInFlatTree(pos.anchorNode(), pos.anchorType());
 }
 
 Position toPositionInDOMTree(const Position& position)
 {
     return position;
 }
 
-Position toPositionInDOMTree(const PositionInComposedTree& position)
+Position toPositionInDOMTree(const PositionInFlatTree& position)
 {
     if (position.isNull())
         return Position();
 
     Node* anchorNode = position.anchorNode();
 
     switch (position.anchorType()) {
     case PositionAnchorType::AfterChildren:
         // FIXME: When anchorNode is <img>, assertion fails in the constructor.
         return Position(anchorNode, PositionAnchorType::AfterChildren);
     case PositionAnchorType::AfterAnchor:
         return positionAfterNode(anchorNode);
     case PositionAnchorType::BeforeChildren:
         return Position(anchorNode, PositionAnchorType::BeforeChildren);
     case PositionAnchorType::BeforeAnchor:
         return positionBeforeNode(anchorNode);
     case PositionAnchorType::OffsetInAnchor: {
         int offset = position.offsetInContainerNode();
         if (anchorNode->offsetInCharacters())
             return Position(anchorNode, offset);
-        Node* child = ComposedTreeTraversal::childAt(*anchorNode, offset);
+        Node* child = FlatTreeTraversal::childAt(*anchorNode, offset);
         if (child)
             return Position(child->parentNode(), child->nodeIndex());
         if (!position.offsetInContainerNode())
             return Position(anchorNode, PositionAnchorType::BeforeChildren);
 
         // |child| is null when the position is at the end of the children.
         // <div>foo|</div>
         return Position(anchorNode, PositionAnchorType::AfterChildren);
     }
     default:
@@ skipping 49 matching lines @@
 template <typename Strategy>
 void PositionTemplate<Strategy>::showTreeForThis() const
 {
     if (!anchorNode())
         return;
     anchorNode()->showTreeForThis();
     showAnchorTypeAndOffset();
 }
 
 template <typename Strategy>
-void PositionTemplate<Strategy>::showTreeForThisInComposedTree() const
+void PositionTemplate<Strategy>::showTreeForThisInFlatTree() const
 {
     if (!anchorNode())
         return;
-    anchorNode()->showTreeForThisInComposedTree();
+    anchorNode()->showTreeForThisInFlatTree();
     showAnchorTypeAndOffset();
 }
 
 #endif
 
 template class CORE_TEMPLATE_EXPORT PositionTemplate<EditingStrategy>;
-template class CORE_TEMPLATE_EXPORT PositionTemplate<EditingInComposedTreeStrategy>;
+template class CORE_TEMPLATE_EXPORT PositionTemplate<EditingInFlatTreeStrategy>;
 
 } // namespace blink
 
 #ifndef NDEBUG
 
 void showTree(const blink::Position& pos)
 {
     pos.showTreeForThis();
 }
 
 void showTree(const blink::Position* pos)
 {
     if (pos)
         pos->showTreeForThis();
     else
         fprintf(stderr, "Cannot showTree for (nil)\n");
 }
 
 #endif