wtf reformat test

third_party/WebKit/Source/wtf/TreeNode.h

Index: third_party/WebKit/Source/wtf/TreeNode.h
diff --git a/third_party/WebKit/Source/wtf/TreeNode.h b/third_party/WebKit/Source/wtf/TreeNode.h
index 561eca53af27b1b98bc34ea62dea715d41bc2a91..b6ad2320dfcfcd15e2dd6cbab93abdd3e2a0025b 100644
--- a/third_party/WebKit/Source/wtf/TreeNode.h
+++ b/third_party/WebKit/Source/wtf/TreeNode.h
@@ -48,155 +48,155 @@ namespace WTF {
 // As it is used in HTMLImport it is safe since they all die together.
 template <class T>
 class TreeNode {
-public:
-    typedef T NodeType;
-
-    TreeNode()
-        : m_next(0)
-        , m_previous(0)
-        , m_parent(0)
-        , m_firstChild(0)
-        , m_lastChild(0)
-    {
+ public:
+  typedef T NodeType;
+
+  TreeNode()
+      : m_next(0),
+        m_previous(0),
+        m_parent(0),
+        m_firstChild(0),
+        m_lastChild(0) {}
+
+  NodeType* next() const { return m_next; }
+  NodeType* previous() const { return m_previous; }
+  NodeType* parent() const { return m_parent; }
+  NodeType* firstChild() const { return m_firstChild; }
+  NodeType* lastChild() const { return m_lastChild; }
+  NodeType* here() const {
+    return static_cast<NodeType*>(const_cast<TreeNode*>(this));
+  }
+
+  bool orphan() const {
+    return !m_parent && !m_next && !m_previous && !m_firstChild && !m_lastChild;
+  }
+  bool hasChildren() const { return m_firstChild; }
+
+  void insertBefore(NodeType* newChild, NodeType* refChild) {
+    ASSERT(!newChild->parent());
+    ASSERT(!newChild->next());
+    ASSERT(!newChild->previous());
+
+    ASSERT(!refChild || this == refChild->parent());
+
+    if (!refChild) {
+      appendChild(newChild);
+      return;
     }
 
-    NodeType* next() const { return m_next; }
-    NodeType* previous() const { return m_previous; }
-    NodeType* parent() const { return m_parent; }
-    NodeType* firstChild() const { return m_firstChild; }
-    NodeType* lastChild() const { return m_lastChild; }
-    NodeType* here() const { return static_cast<NodeType*>(const_cast<TreeNode*>(this)); }
-
-    bool orphan() const { return !m_parent && !m_next && !m_previous && !m_firstChild && !m_lastChild; }
-    bool hasChildren() const { return m_firstChild; }
-
-    void insertBefore(NodeType* newChild, NodeType* refChild)
-    {
-        ASSERT(!newChild->parent());
-        ASSERT(!newChild->next());
-        ASSERT(!newChild->previous());
-
-        ASSERT(!refChild || this == refChild->parent());
-
-        if (!refChild) {
-            appendChild(newChild);
-            return;
-        }
-
-        NodeType* newPrevious = refChild->previous();
-        newChild->m_parent = here();
-        newChild->m_next = refChild;
-        newChild->m_previous = newPrevious;
-        refChild->m_previous = newChild;
-        if (newPrevious)
-            newPrevious->m_next = newChild;
-        else
-            m_firstChild = newChild;
+    NodeType* newPrevious = refChild->previous();
+    newChild->m_parent = here();
+    newChild->m_next = refChild;
+    newChild->m_previous = newPrevious;
+    refChild->m_previous = newChild;
+    if (newPrevious)
+      newPrevious->m_next = newChild;
+    else
+      m_firstChild = newChild;
+  }
+
+  void appendChild(NodeType* child) {
+    ASSERT(!child->parent());
+    ASSERT(!child->next());
+    ASSERT(!child->previous());
+
+    child->m_parent = here();
+
+    if (!m_lastChild) {
+      ASSERT(!m_firstChild);
+      m_lastChild = m_firstChild = child;
+      return;
     }
 
-    void appendChild(NodeType* child)
-    {
-        ASSERT(!child->parent());
-        ASSERT(!child->next());
-        ASSERT(!child->previous());
+    ASSERT(!m_lastChild->m_next);
+    NodeType* oldLast = m_lastChild;
+    m_lastChild = child;
 
-        child->m_parent = here();
+    child->m_previous = oldLast;
+    oldLast->m_next = child;
+  }
 
-        if (!m_lastChild) {
-            ASSERT(!m_firstChild);
-            m_lastChild = m_firstChild = child;
-            return;
-        }
+  NodeType* removeChild(NodeType* child) {
+    ASSERT(child->parent() == this);
 
-        ASSERT(!m_lastChild->m_next);
-        NodeType* oldLast = m_lastChild;
-        m_lastChild = child;
+    if (m_firstChild == child)
+      m_firstChild = child->next();
+    if (m_lastChild == child)
+      m_lastChild = child->previous();
 
-        child->m_previous = oldLast;
-        oldLast->m_next = child;
-    }
-
-    NodeType* removeChild(NodeType* child)
-    {
-        ASSERT(child->parent() == this);
-
-        if (m_firstChild == child)
-            m_firstChild = child->next();
-        if (m_lastChild == child)
-            m_lastChild = child->previous();
+    NodeType* oldNext = child->next();
+    NodeType* oldPrevious = child->previous();
+    child->m_parent = child->m_next = child->m_previous = 0;
 
-        NodeType* oldNext = child->next();
-        NodeType* oldPrevious = child->previous();
-        child->m_parent = child->m_next = child->m_previous = 0;
+    if (oldNext)
+      oldNext->m_previous = oldPrevious;
+    if (oldPrevious)
+      oldPrevious->m_next = oldNext;
 
-        if (oldNext)
-            oldNext->m_previous = oldPrevious;
-        if (oldPrevious)
-            oldPrevious->m_next = oldNext;
-
-        return child;
-    }
+    return child;
+  }
 
-    void takeChildrenFrom(NodeType* oldParent)
-    {
-        ASSERT(oldParent != this);
-        while (oldParent->hasChildren()) {
-            NodeType* child = oldParent->firstChild();
-            oldParent->removeChild(child);
-            this->appendChild(child);
-        }
+  void takeChildrenFrom(NodeType* oldParent) {
+    ASSERT(oldParent != this);
+    while (oldParent->hasChildren()) {
+      NodeType* child = oldParent->firstChild();
+      oldParent->removeChild(child);
+      this->appendChild(child);
     }
-
-private:
-    NodeType* m_next;
-    NodeType* m_previous;
-    NodeType* m_parent;
-    NodeType* m_firstChild;
-    NodeType* m_lastChild;
+  }
+
+ private:
+  NodeType* m_next;
+  NodeType* m_previous;
+  NodeType* m_parent;
+  NodeType* m_firstChild;
+  NodeType* m_lastChild;
 };
 
-template<class T>
-inline typename TreeNode<T>::NodeType* traverseNext(const TreeNode<T>* current, const TreeNode<T>* stayWithin = 0)
-{
-    if (typename TreeNode<T>::NodeType* next = current->firstChild())
-        return next;
-    if (current == stayWithin)
-        return 0;
-    if (typename TreeNode<T>::NodeType* next = current->next())
-        return next;
-    for (typename TreeNode<T>::NodeType* parent = current->parent(); parent; parent = parent->parent()) {
-        if (parent == stayWithin)
-            return 0;
-        if (typename TreeNode<T>::NodeType* next = parent->next())
-            return next;
-    }
-
+template <class T>
+inline typename TreeNode<T>::NodeType* traverseNext(
+    const TreeNode<T>* current,
+    const TreeNode<T>* stayWithin = 0) {
+  if (typename TreeNode<T>::NodeType* next = current->firstChild())
+    return next;
+  if (current == stayWithin)
     return 0;
+  if (typename TreeNode<T>::NodeType* next = current->next())
+    return next;
+  for (typename TreeNode<T>::NodeType* parent = current->parent(); parent;
+       parent = parent->parent()) {
+    if (parent == stayWithin)
+      return 0;
+    if (typename TreeNode<T>::NodeType* next = parent->next())
+      return next;
+  }
+
+  return 0;
 }
 
-template<class T>
-inline typename TreeNode<T>::NodeType* traverseFirstPostOrder(const TreeNode<T>* current)
-{
-    typename TreeNode<T>::NodeType* first = current->here();
-    while (first->firstChild())
-        first = first->firstChild();
-    return first;
+template <class T>
+inline typename TreeNode<T>::NodeType* traverseFirstPostOrder(
+    const TreeNode<T>* current) {
+  typename TreeNode<T>::NodeType* first = current->here();
+  while (first->firstChild())
+    first = first->firstChild();
+  return first;
 }
 
-template<class T>
-inline typename TreeNode<T>::NodeType* traverseNextPostOrder(const TreeNode<T>* current, const TreeNode<T>* stayWithin = 0)
-{
-    if (current == stayWithin)
-        return 0;
-
-    typename TreeNode<T>::NodeType* next = current->next();
-    if (!next)
-        return current->parent();
-    while (next->firstChild())
-        next = next->firstChild();
-    return next;
-}
+template <class T>
+inline typename TreeNode<T>::NodeType* traverseNextPostOrder(
+    const TreeNode<T>* current,
+    const TreeNode<T>* stayWithin = 0) {
+  if (current == stayWithin)
+    return 0;
 
+  typename TreeNode<T>::NodeType* next = current->next();
+  if (!next)
+    return current->parent();
+  while (next->firstChild())
+    next = next->firstChild();
+  return next;
+}
 }
 
 using WTF::TreeNode;