Fix style erros in XPath-related files.

Source/core/xml/XPathNodeSet.cpp

 /*
  * Copyright (C) 2007 Alexey Proskuryakov <ap@webkit.org>
  *
  * 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
@@ skipping 16 matching lines @@
 #include "core/xml/XPathNodeSet.h"
 
 #include "core/dom/Attr.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/dom/NodeTraversal.h"
 
 namespace WebCore {
 namespace XPath {
 
-// When a node set is large, sorting it by traversing the whole document is better (we can
-// assume that we aren't dealing with documents that we cannot even traverse in reasonable time).
+// When a node set is large, sorting it by traversing the whole document is
+// better (we can assume that we aren't dealing with documents that we cannot
+// even traverse in reasonable time).
 const unsigned traversalSortCutoff = 10000;
 
 typedef WillBeHeapVector<RawPtrWillBeMember<Node> > NodeSetVector;
 
 PassOwnPtrWillBeRawPtr<NodeSet> NodeSet::create(const NodeSet& other)
 {
     OwnPtrWillBeRawPtr<NodeSet> nodeSet = NodeSet::create();
     nodeSet->m_isSorted = other.m_isSorted;
     nodeSet->m_subtreesAreDisjoint = other.m_subtreesAreDisjoint;
     nodeSet->m_nodes.appendVector(other.m_nodes);
     return nodeSet.release();
 }
 
 static inline Node* parentWithDepth(unsigned depth, const NodeSetVector& parents)
 {
     ASSERT(parents.size() >= depth + 1);
     return parents[parents.size() - 1 - depth];
 }
 
 static void sortBlock(unsigned from, unsigned to, WillBeHeapVector<NodeSetVector>& parentMatrix, bool mayContainAttributeNodes)
 {
-    ASSERT(from + 1 < to); // Should not call this function with less that two nodes to sort.
+    // Should not call this function with less that two nodes to sort.
+    ASSERT(from + 1 < to);
     unsigned minDepth = UINT_MAX;
     for (unsigned i = from; i < to; ++i) {
         unsigned depth = parentMatrix[i].size() - 1;
         if (minDepth > depth)
             minDepth = depth;
     }
 
     // Find the common ancestor.
     unsigned commonAncestorDepth = minDepth;
     Node* commonAncestor;
     while (true) {
         commonAncestor = parentWithDepth(commonAncestorDepth, parentMatrix[from]);
         if (commonAncestorDepth == 0)
             break;
 
         bool allEqual = true;
         for (unsigned i = from + 1; i < to; ++i) {
             if (commonAncestor != parentWithDepth(commonAncestorDepth, parentMatrix[i])) {
                 allEqual = false;
                 break;
             }
         }
         if (allEqual)
             break;
 
         --commonAncestorDepth;
     }
 
     if (commonAncestorDepth == minDepth) {
-        // One of the nodes is the common ancestor => it is the first in document order.
-        // Find it and move it to the beginning.
-        for (unsigned i = from; i < to; ++i)
+        // One of the nodes is the common ancestor => it is the first in
+        // document order. Find it and move it to the beginning.
+        for (unsigned i = from; i < to; ++i) {
             if (commonAncestor == parentMatrix[i][0]) {
                 parentMatrix[i].swap(parentMatrix[from]);
                 if (from + 2 < to)
                     sortBlock(from + 1, to, parentMatrix, mayContainAttributeNodes);
                 return;
             }
+        }
     }
 
     if (mayContainAttributeNodes && commonAncestor->isElementNode()) {
-        // The attribute nodes and namespace nodes of an element occur before the children of the element.
-        // The namespace nodes are defined to occur before the attribute nodes.
-        // The relative order of namespace nodes is implementation-dependent.
-        // The relative order of attribute nodes is implementation-dependent.
+        // The attribute nodes and namespace nodes of an element occur before
+        // the children of the element. The namespace nodes are defined to occur
+        // before the attribute nodes. The relative order of namespace nodes is
+        // implementation-dependent. The relative order of attribute nodes is
+        // implementation-dependent.
         unsigned sortedEnd = from;
         // FIXME: namespace nodes are not implemented.
         for (unsigned i = sortedEnd; i < to; ++i) {
             Node* n = parentMatrix[i][0];
             if (n->isAttributeNode() && toAttr(n)->ownerElement() == commonAncestor)
                 parentMatrix[i].swap(parentMatrix[sortedEnd++]);
         }
         if (sortedEnd != from) {
             if (to - sortedEnd > 1)
                 sortBlock(sortedEnd, to, parentMatrix, mayContainAttributeNodes);
             return;
         }
     }
 
-    // Children nodes of the common ancestor induce a subdivision of our node-set.
-    // Sort it according to this subdivision, and recursively sort each group.
+    // Children nodes of the common ancestor induce a subdivision of our
+    // node-set. Sort it according to this subdivision, and recursively sort
+    // each group.
     WillBeHeapHashSet<RawPtrWillBeMember<Node> > parentNodes;
     for (unsigned i = from; i < to; ++i)
         parentNodes.add(parentWithDepth(commonAncestorDepth + 1, parentMatrix[i]));
 
     unsigned previousGroupEnd = from;
     unsigned groupEnd = from;
     for (Node* n = commonAncestor->firstChild(); n; n = n->nextSibling()) {
-        // If parentNodes contains the node, perform a linear search to move its children in the node-set to the beginning.
+        // If parentNodes contains the node, perform a linear search to move its
+        // children in the node-set to the beginning.
         if (parentNodes.contains(n)) {
-            for (unsigned i = groupEnd; i < to; ++i)
+            for (unsigned i = groupEnd; i < to; ++i) {
                 if (parentWithDepth(commonAncestorDepth + 1, parentMatrix[i]) == n)
                     parentMatrix[i].swap(parentMatrix[groupEnd++]);
+            }
 
             if (groupEnd - previousGroupEnd > 1)
                 sortBlock(previousGroupEnd, groupEnd, parentMatrix, mayContainAttributeNodes);
 
             ASSERT(previousGroupEnd != groupEnd);
             previousGroupEnd = groupEnd;
 #ifndef NDEBUG
             parentNodes.remove(n);
 #endif
         }
@@ skipping 28 matching lines @@
         if (n->isAttributeNode()) {
             n = toAttr(n)->ownerElement();
             parentsVector.append(n);
             containsAttributeNodes = true;
         }
         while ((n = n->parentNode()))
             parentsVector.append(n);
     }
     sortBlock(0, nodeCount, parentMatrix, containsAttributeNodes);
 
-    // It is not possible to just assign the result to m_nodes, because some nodes may get dereferenced and destroyed.
+    // It is not possible to just assign the result to m_nodes, because some
+    // nodes may get dereferenced and destroyed.
     WillBeHeapVector<RefPtrWillBeMember<Node> > sortedNodes;
     sortedNodes.reserveInitialCapacity(nodeCount);
     for (unsigned i = 0; i < nodeCount; ++i)
         sortedNodes.append(parentMatrix[i][0]);
 
     const_cast<WillBeHeapVector<RefPtrWillBeMember<Node> >&>(m_nodes).swap(sortedNodes);
 }
 
 static Node* findRootNode(Node* node)
 {
     if (node->isAttributeNode())
         node = toAttr(node)->ownerElement();
-    if (node->inDocument())
+    if (node->inDocument()) {
         node = &node->document();
-    else {
+    } else {
         while (Node* parent = node->parentNode())
             node = parent;
     }
     return node;
 }
 
 void NodeSet::traversalSort() const
 {
     WillBeHeapHashSet<RawPtrWillBeMember<Node> > nodes;
     bool containsAttributeNodes = false;
@@ skipping 46 matching lines @@
         ++from;
         --to;
     }
 }
 
 Node* NodeSet::firstNode() const
 {
     if (isEmpty())
         return 0;
 
-    sort(); // FIXME: fully sorting the node-set just to find its first node is wasteful.
+    // FIXME: fully sorting the node-set just to find its first node is
+    // wasteful.
+    sort();
     return m_nodes.at(0).get();
 }
 
 Node* NodeSet::anyNode() const
 {
     if (isEmpty())
         return 0;
 
     return m_nodes.at(0).get();
 }
 
 }
 }