Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/ElementTraversal.h

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All rights reserved.
- * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013
+ * Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved.
+ * (http://www.torchmobile.com/)
  * Copyright (C) 2014 Samsung Electronics. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
@@ skipping 146 matching lines @@
 
   // Pre-order traversal including the pseudo-elements.
   static ElementType* previousIncludingPseudo(const Node&,
                                               const Node* stayWithin = 0);
   static ElementType* nextIncludingPseudo(const Node&,
                                           const Node* stayWithin = 0);
   static ElementType* nextIncludingPseudoSkippingChildren(
       const Node&,
       const Node* stayWithin = 0);
 
-  // Utility function to traverse only the element and pseudo-element siblings of a node.
+  // Utility function to traverse only the element and pseudo-element siblings
+  // of a node.
   static ElementType* pseudoAwarePreviousSibling(const Node&);
 
   // Previous / Next sibling.
   static ElementType* previousSibling(const Node&);
   template <class MatchFunc>
   static ElementType* previousSibling(const Node&, MatchFunc);
   static ElementType* nextSibling(const Node&);
   template <class MatchFunc>
   static ElementType* nextSibling(const Node&, MatchFunc);
 
@@ skipping 55 matching lines @@
 Traversal<ElementType>::startsAt(const ElementType* start) {
   return TraversalRange<TraversalNextIterator<Traversal<ElementType>>>(start);
 };
 
 template <class ElementType>
 inline TraversalRange<TraversalNextIterator<Traversal<ElementType>>>
 Traversal<ElementType>::startsAfter(const Node& start) {
   return startsAt(Traversal<ElementType>::next(start));
 };
 
-// Specialized for pure Element to exploit the fact that Elements parent is always either another Element or the root.
+// Specialized for pure Element to exploit the fact that Elements parent is
+// always either another Element or the root.
 template <>
 template <class NodeType>
 inline Element* Traversal<Element>::firstWithinTemplate(NodeType& current) {
   return firstChildTemplate(current);
 }
 
 template <>
 template <class NodeType>
 inline Element* Traversal<Element>::nextTemplate(NodeType& current) {
   Node* node = NodeTraversal::next(current);
@@ skipping 275 matching lines @@
                                                         MatchFunc isMatch) {
   ElementType* element = Traversal<ElementType>::nextSibling(current);
   while (element && !isMatch(*element))
     element = Traversal<ElementType>::nextSibling(*element);
   return element;
 }
 
 }  // namespace blink
 
 #endif