Reflow comments in core/dom/.

third_party/WebKit/Source/core/dom/Text.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
- * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. 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
  * Library General Public License for more details.
@@ skipping 169 matching lines @@
     result.append(toText(n)->data());
   }
   DCHECK_EQ(result.length(), resultLength);
 
   return result.toString();
 }
 
 Text* Text::replaceWholeText(const String& newText) {
   // Remove all adjacent text nodes, and replace the contents of this one.
 
-  // Protect startText and endText against mutation event handlers removing the last ref
+  // Protect startText and endText against mutation event handlers removing the
+  // last ref
   Text* startText = const_cast<Text*>(earliestLogicallyAdjacentTextNode(this));
   Text* endText = const_cast<Text*>(latestLogicallyAdjacentTextNode(this));
 
-  ContainerNode* parent =
-      parentNode();  // Protect against mutation handlers moving this node during traversal
+  ContainerNode* parent = parentNode();  // Protect against mutation handlers
+                                         // moving this node during traversal
   for (Node* n = startText;
        n && n != this && n->isTextNode() && n->parentNode() == parent;) {
     Node* nodeToRemove = n;
     n = nodeToRemove->nextSibling();
     parent->removeChild(nodeToRemove, IGNORE_EXCEPTION);
   }
 
   if (this != endText) {
     Node* onePastEndText = endText->nextSibling();
     for (Node* n = nextSibling(); n && n != onePastEndText && n->isTextNode() &&
@@ skipping 62 matching lines @@
     return false;
 
   // pre-wrap in SVG never makes layoutObject.
   if (style.whiteSpace() == PRE_WRAP && parent.isSVG())
     return false;
 
   // pre/pre-wrap/pre-line always make layoutObjects.
   if (style.preserveNewline())
     return true;
 
-  // childNeedsDistributionRecalc() here is rare, only happens JS calling surroundContents() etc. from DOMNodeInsertedIntoDocument etc.
+  // childNeedsDistributionRecalc() here is rare, only happens JS calling
+  // surroundContents() etc. from DOMNodeInsertedIntoDocument etc.
   if (document().childNeedsDistributionRecalc())
     return true;
 
   const LayoutObject* prev =
       LayoutTreeBuilderTraversal::previousSiblingLayoutObject(*this);
   if (prev && prev->isBR())  // <span><br/> <br/></span>
     return false;
 
   if (parent.isLayoutInline()) {
     // <span><div/> <div/></span>
     if (prev && !prev->isInline() && !prev->isOutOfFlowPositioned())
       return false;
   } else {
     if (parent.isLayoutBlock() && !parent.childrenInline() &&
         (!prev || !prev->isInline()))
       return false;
 
-    // Avoiding creation of a layoutObject for the text node is a non-essential memory optimization.
-    // So to avoid blowing up on very wide DOMs, we limit the number of siblings to visit.
+    // Avoiding creation of a layoutObject for the text node is a non-essential
+    // memory optimization.  So to avoid blowing up on very wide DOMs, we limit
+    // the number of siblings to visit.
     unsigned maxSiblingsToVisit = 50;
 
     LayoutObject* first = parent.slowFirstChild();
     while (first && first->isFloatingOrOutOfFlowPositioned() &&
            maxSiblingsToVisit--)
       first = first->nextSibling();
     if (!first || first == layoutObject() ||
         LayoutTreeBuilderTraversal::nextSiblingLayoutObject(*this) == first) {
-      // If we're adding children to this flow our previous siblings are not in the layout tree yet so we
-      // cannot know if we will be the first child in the line and collapse away. We have to assume we need a layout object.
+      // If we're adding children to this flow our previous siblings are not in
+      // the layout tree yet so we cannot know if we will be the first child in
+      // the line and collapse away. We have to assume we need a layout object.
       Node* firstChildNode =
           parent.node() ? LayoutTreeBuilderTraversal::firstChild(*parent.node())
                         : nullptr;
       if (first && first == layoutObject() && firstChildNode &&
           !firstChildNode->layoutObject())
         return true;
 
       // Whitespace at the start of a block just goes away.  Don't even
       // make a layout object for this text.
       return !firstChildNode;
@@ skipping 38 matching lines @@
     if (LayoutObject* parentLayoutObject = layoutParent->layoutObject()) {
       if (textLayoutObjectIsNeeded(*parentLayoutObject->style(),
                                    *parentLayoutObject))
         layoutObjectIsNeeded = true;
     }
   }
 
   if (layoutObjectIsNeeded == !!layoutObject())
     return;
 
-  // The following is almost the same as Node::reattachLayoutTree() except that we create a layoutObject only if needed.
-  // Not calling reattachLayoutTree() to avoid repeated calls to Text::textLayoutObjectIsNeeded().
+  // The following is almost the same as Node::reattachLayoutTree() except that
+  // we create a layoutObject only if needed.  Not calling reattachLayoutTree()
+  // to avoid repeated calls to Text::textLayoutObjectIsNeeded().
   AttachContext reattachContext(context);
   reattachContext.performingReattach = true;
 
   if (getStyleChangeType() < NeedsReattachStyleChange)
     detachLayoutTree(reattachContext);
   if (layoutObjectIsNeeded)
     LayoutTreeBuilderForText(*this, layoutParent->layoutObject())
         .createLayoutObject();
   CharacterData::attachLayoutTree(reattachContext);
 }
 
 void Text::recalcTextStyle(StyleRecalcChange change, Text* nextTextSibling) {
   if (LayoutTextItem layoutItem = LayoutTextItem(this->layoutObject())) {
     if (change != NoChange || needsStyleRecalc())
       layoutItem.setStyle(document().ensureStyleResolver().styleForText(this));
     if (needsStyleRecalc())
       layoutItem.setText(dataImpl());
     clearNeedsStyleRecalc();
   } else if (needsStyleRecalc() || needsWhitespaceLayoutObject()) {
     reattachLayoutTree();
     if (this->layoutObject())
       reattachWhitespaceSiblingsIfNeeded(nextTextSibling);
   }
 }
 
-// If a whitespace node had no layoutObject and goes through a recalcStyle it may
-// need to create one if the parent style now has white-space: pre.
+// If a whitespace node had no layoutObject and goes through a recalcStyle it
+// may need to create one if the parent style now has white-space: pre.
 bool Text::needsWhitespaceLayoutObject() {
   DCHECK(!layoutObject());
   if (const ComputedStyle* style = parentComputedStyle())
     return style->preserveNewline();
   return false;
 }
 
 // Passing both |textNode| and its layout object because repeated calls to
 // |Node::layoutObject()| are discouraged.
 static bool shouldUpdateLayoutByReattaching(const Text& textNode,
@@ skipping 27 matching lines @@
 
 Text* Text::cloneWithData(const String& data) {
   return create(document(), data);
 }
 
 DEFINE_TRACE(Text) {
   CharacterData::trace(visitor);
 }
 
 }  // namespace blink