Introduce ComposedTreeTraversal::previousPostOrder()

Source/core/dom/shadow/ComposedTreeTraversal.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 173 matching lines @@
     return false;
 }
 
 Node* ComposedTreeTraversal::previousSkippingChildren(const Node& node)
 {
     if (Node* previousSibling = traversePreviousSibling(node))
         return previousSibling;
     return traversePreviousAncestorSibling(node);
 }
 
+static Node* previousAncestorSiblingPostOrder(const Node& current, const Node* stayWithin)
+{
+    ASSERT(!ComposedTreeTraversal::previousSibling(current));
+    for (Node* parent = ComposedTreeTraversal::parent(current); parent; parent = ComposedTreeTraversal::parent(*parent)) {
+        if (parent == stayWithin)
+            return nullptr;
+        if (Node* previousSibling = ComposedTreeTraversal::previousSibling(*parent))
+            return previousSibling;
+    }
+    return nullptr;
+}
+
+// TODO(yosin) We should consider introducing template class to share code
+// between DOM tree traversal and composed tree tarversal.
+Node* ComposedTreeTraversal::previousPostOrder(const Node& current, const Node* stayWithin)
+{
+    assertPrecondition(current);
+    if (stayWithin)
+        assertPrecondition(*stayWithin);
+    if (Node* lastChild = traverseLastChild(current)) {
+        assertPostcondition(lastChild);
+        return lastChild;
+    }
+    if (current == stayWithin)
+        return nullptr;
+    if (Node* previousSibling = traversePreviousSibling(current)) {
+        assertPostcondition(previousSibling);
+        return previousSibling;
+    }
+    return previousAncestorSiblingPostOrder(current, stayWithin);
+}
+
 bool ComposedTreeTraversal::isDescendantOf(const Node& node, const Node& other)
 {
     assertPrecondition(node);
     assertPrecondition(other);
     if (!hasChildren(other) || node.inDocument() != other.inDocument())
         return false;
     for (const ContainerNode* n = traverseParent(node); n; n = traverseParent(*n)) {
         if (n == other)
             return true;
     }
@@ skipping 64 matching lines @@
 Node& ComposedTreeTraversal::lastWithinOrSelf(const Node& node)
 {
     assertPrecondition(node);
     Node* lastDescendant = lastWithin(node);
     Node& result = lastDescendant ? *lastDescendant : const_cast<Node&>(node);
     assertPostcondition(&result);
     return result;
 }
 
 } // namespace