Rename ComposedTree to FlatTree

third_party/WebKit/Source/core/dom/LayoutTreeBuilderTraversal.cpp

 /*
  * Copyright (C) 2012 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Neither the name of Google Inc. nor the names of its
@@ skipping 10 matching lines @@
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/dom/LayoutTreeBuilderTraversal.h"
 
 #include "core/HTMLNames.h"
 #include "core/dom/PseudoElement.h"
-#include "core/dom/shadow/ComposedTreeTraversal.h"
+#include "core/dom/shadow/FlatTreeTraversal.h"
 #include "core/layout/LayoutObject.h"
 
 namespace blink {
 
 namespace LayoutTreeBuilderTraversal {
 
 static bool isLayoutObjectReparented(const LayoutObject* layoutObject)
 {
     if (!layoutObject->node()->isElementNode())
         return false;
     if (toElement(layoutObject->node())->isInTopLayer())
         return true;
     return false;
 }
 
 void ParentDetails::didTraverseInsertionPoint(const InsertionPoint* insertionPoint)
 {
     if (!m_insertionPoint) {
         m_insertionPoint = insertionPoint;
     }
 }
 
 ContainerNode* parent(const Node& node, ParentDetails* details)
 {
     // TODO(hayato): Uncomment this once we can be sure LayoutTreeBuilderTraversal::parent() is used only for a node in a document.
     // ASSERT(node.inDocument());
-    return ComposedTreeTraversal::parent(node, details);
+    return FlatTreeTraversal::parent(node, details);
 }
 
 Node* nextSibling(const Node& node)
 {
     if (node.isBeforePseudoElement()) {
-        if (Node* next = ComposedTreeTraversal::firstChild(*ComposedTreeTraversal::parent(node)))
+        if (Node* next = FlatTreeTraversal::firstChild(*FlatTreeTraversal::parent(node)))
             return next;
     } else {
-        if (Node* next = ComposedTreeTraversal::nextSibling(node))
+        if (Node* next = FlatTreeTraversal::nextSibling(node))
             return next;
         if (node.isAfterPseudoElement())
             return 0;
     }
 
-    Node* parent = ComposedTreeTraversal::parent(node);
+    Node* parent = FlatTreeTraversal::parent(node);
     if (parent && parent->isElementNode())
         return toElement(parent)->pseudoElement(AFTER);
 
     return 0;
 }
 
 Node* previousSibling(const Node& node)
 {
     if (node.isAfterPseudoElement()) {
-        if (Node* previous = ComposedTreeTraversal::lastChild(*ComposedTreeTraversal::parent(node)))
+        if (Node* previous = FlatTreeTraversal::lastChild(*FlatTreeTraversal::parent(node)))
             return previous;
     } else {
-        if (Node* previous = ComposedTreeTraversal::previousSibling(node))
+        if (Node* previous = FlatTreeTraversal::previousSibling(node))
             return previous;
         if (node.isBeforePseudoElement())
             return 0;
     }
 
-    Node* parent = ComposedTreeTraversal::parent(node);
+    Node* parent = FlatTreeTraversal::parent(node);
     if (parent && parent->isElementNode())
         return toElement(parent)->pseudoElement(BEFORE);
 
     return 0;
 }
 
 static Node* lastChild(const Node& node)
 {
-    return ComposedTreeTraversal::lastChild(node);
+    return FlatTreeTraversal::lastChild(node);
 }
 
 static Node* pseudoAwarePreviousSibling(const Node& node)
 {
     Node* previousNode = previousSibling(node);
     Node* parentNode = parent(node);
 
     if (parentNode && parentNode->isElementNode() && !previousNode) {
         if (node.isAfterPseudoElement()) {
             if (Node* child = lastChild(*parentNode))
@@ skipping 30 matching lines @@
     if (Node* previousNode = pseudoAwarePreviousSibling(node)) {
         while (Node* previousLastChild = pseudoAwareLastChild(*previousNode))
             previousNode = previousLastChild;
         return previousNode;
     }
     return parent(node);
 }
 
 Node* firstChild(const Node& node)
 {
-    return ComposedTreeTraversal::firstChild(node);
+    return FlatTreeTraversal::firstChild(node);
 }
 
 static Node* pseudoAwareNextSibling(const Node& node)
 {
     Node* parentNode = parent(node);
     Node* nextNode = nextSibling(node);
 
     if (parentNode && parentNode->isElementNode() && !nextNode) {
         if (node.isBeforePseudoElement()) {
             if (Node* child = firstChild(*parentNode))
@@ skipping 80 matching lines @@
     for (size_t i = position + 1; i < topLayerElements.size(); ++i) {
         if (LayoutObject* layoutObject = topLayerElements[i]->layoutObject())
             return layoutObject;
     }
     return 0;
 }
 
 } // namespace LayoutTreeBuilderTraversal
 
 } // namespace blink