Get rid of the overloads on templated traversal methods for clarity and safety

Source/wtf/TreeNode.h

 /*
  * Copyright (C) 2013 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.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 141 matching lines @@
     if (NodeType* nextSibling = current.nextSibling())
         return nextSibling;
     for (NodeType* parent = current.parent(); parent; parent = parent->parent()) {
         if (NodeType* nextSibling = parent->nextSibling())
             return nextSibling;
     }
 
     return 0;
 }
 
-template<class ContainerType>
-inline ContainerType* traverseNext(const ContainerType& current)
-{ return traverseNext<ContainerType, ContainerType>(current); }
-
 template<class NodeType, class ContainerType>
 inline NodeType* traverseNext(const ContainerType& current, const NodeType* stayWithin)
 {
     if (NodeType* firstChild = current.firstChild())
         return firstChild;
     if (&current == stayWithin)
         return 0;
     if (NodeType* nextSibling = current.nextSibling())
         return nextSibling;
     for (NodeType* parent = current.parent(); parent; parent = parent->parent()) {
         if (parent == stayWithin)
             return 0;
         if (NodeType* nextSibling = parent->nextSibling())
             return nextSibling;
     }
 
     return 0;
 }
 
-template<class ContainerType>
-inline ContainerType* traverseNext(const ContainerType& current, const ContainerType* stayWithin)
-{ return traverseNext<ContainerType, ContainerType>(current, stayWithin); }
-
 /* non-recursive post-order traversal */
 template<class NodeType, class ContainerType>
 inline NodeType* traverseFirstPostOrder(const ContainerType& current)
 {
     NodeType* first = current.here();
     while (first->firstChild())
         first = first->firstChild();
     return first;
 }
 
-template<class ContainerType>
-inline ContainerType* traverseFirstPostOrder(const ContainerType& current)
-{ return traverseFirstPostOrder<ContainerType, ContainerType>(current); }
-
 template<class NodeType, class ContainerType>
 inline NodeType* traverseNextPostOrder(const ContainerType& current)
 {
     NodeType* nextSibling = current.nextSibling();
     if (!nextSibling)
         return current.parent();
     while (nextSibling->firstChild())
         nextSibling = nextSibling->firstChild();
     return nextSibling;
 }
 
-template<class ContainerType>
-inline ContainerType* traverseNextPostOrder(const ContainerType& current)
-{ return traverseNextPostOrder<ContainerType, ContainerType>(current); }
-
 template<class NodeType, class ContainerType>
 inline NodeType* traverseNextPostOrder(const ContainerType& current, const NodeType* stayWithin)
 {
     if (&current == stayWithin)
         return 0;
 
     NodeType* nextSibling = current.nextSibling();
     if (!nextSibling)
         return current.parent();
     while (nextSibling->firstChild())
         nextSibling = nextSibling->firstChild();
     return nextSibling;
 }
 
-template<class ContainerType>
-inline ContainerType* traverseNextPostOrder(const ContainerType& current, const ContainerType* stayWithin)
-{ return traverseNextPostOrder<ContainerType, ContainerType>(current, stayWithin); }
-
 /* non-recursive traversal skipping children */
 template <class NodeType, class ContainerType>
 inline NodeType* traverseNextSkippingChildren(const ContainerType& current)
 {
     if (current.nextSibling())
         return current.nextSibling();
     for (NodeType* parent = current.parent(); parent; parent = parent->parent()) {
         if (NodeType* nextSibling = parent->nextSibling())
             return nextSibling;
     }
 
     return 0;
 }
 
-template <class ContainerType>
-inline ContainerType* traverseNextSkippingChildren(const ContainerType& current)
-{ return traverseNextSkippingChildren<ContainerType, ContainerType>(current); }
-
 template <class NodeType, class ContainerType>
 inline NodeType* traverseNextSkippingChildren(const ContainerType& current, const NodeType* stayWithin)
 {
     if (current == stayWithin)
         return 0;
     if (current.nextSibling())
         return current.nextSibling();
     for (NodeType* parent = current.parent(); parent; parent = parent->parent()) {
         if (parent == stayWithin)
             return 0;
         if (NodeType* nextSibling = parent->nextSibling())
             return nextSibling;
     }
 
     return 0;
 }
 
-template <class ContainerType>
-inline ContainerType* traverseNextSkippingChildren(const ContainerType& current, const ContainerType* stayWithin)
-{ return traverseNextSkippingChildren<ContainerType, ContainerType>(current, stayWithin); }
-
 } // namespace WTF
 
 using WTF::TreeNode;
 using WTF::traverseNext;
 using WTF::traverseFirstPostOrder;
 using WTF::traverseNextPostOrder;
 using WTF::traverseNextSkippingChildren;
 
 #endif // TreeNode_h