Reflow comments in core/dom/.

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Gunnstein Lye (gunnstein@netcom.no)
  * (C) 2000 Frederik Holljen (frederik.holljen@hig.no)
  * (C) 2001 Peter Kelly (pmk@post.com)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc. All
+ * rights reserved.
  * Copyright (C) 2011 Motorola Mobility. 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 51 matching lines @@
 inline Range::Range(Document& ownerDocument,
                     Node* startContainer,
                     int startOffset,
                     Node* endContainer,
                     int endOffset)
     : m_ownerDocument(&ownerDocument),
       m_start(m_ownerDocument),
       m_end(m_ownerDocument) {
   m_ownerDocument->attachRange(this);
 
-  // Simply setting the containers and offsets directly would not do any of the checking
-  // that setStart and setEnd do, so we call those functions.
+  // Simply setting the containers and offsets directly would not do any of the
+  // checking that setStart and setEnd do, so we call those functions.
   setStart(startContainer, startOffset);
   setEnd(endContainer, endOffset);
 }
 
 Range* Range::create(Document& ownerDocument,
                      Node* startContainer,
                      int startOffset,
                      Node* endContainer,
                      int endOffset) {
   return new Range(ownerDocument, startContainer, startOffset, endContainer,
@@ skipping 72 matching lines @@
     startRootContainer = startRootContainer->parentNode();
 
   return startRootContainer != endRootContainer ||
          (Range::compareBoundaryPoints(start, end, ASSERT_NO_EXCEPTION) > 0);
 }
 
 void Range::setStart(Node* refNode,
                      int offset,
                      ExceptionState& exceptionState) {
   if (!refNode) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   bool didMoveDocument = false;
   if (refNode->document() != m_ownerDocument) {
     setDocument(refNode->document());
     didMoveDocument = true;
   }
 
   Node* childNode = checkNodeWOffset(refNode, offset, exceptionState);
   if (exceptionState.hadException())
     return;
 
   m_start.set(refNode, offset, childNode);
 
   if (didMoveDocument || checkForDifferentRootContainer(m_start, m_end))
     collapse(true);
 }
 
 void Range::setEnd(Node* refNode, int offset, ExceptionState& exceptionState) {
   if (!refNode) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   bool didMoveDocument = false;
   if (refNode->document() != m_ownerDocument) {
     setDocument(refNode->document());
     didMoveDocument = true;
   }
 
@@ skipping 22 matching lines @@
 void Range::collapse(bool toStart) {
   if (toStart)
     m_end = m_start;
   else
     m_start = m_end;
 }
 
 bool Range::isNodeFullyContained(Node& node) const {
   ContainerNode* parentNode = node.parentNode();
   int nodeIndex = node.nodeIndex();
-  return isPointInRange(
-             parentNode, nodeIndex,
-             IGNORE_EXCEPTION)  // starts in the middle of this range, or on the boundary points.
-         &&
-         isPointInRange(
-             parentNode, nodeIndex + 1,
-             IGNORE_EXCEPTION);  // ends in the middle of this range, or on the boundary points.
+  return isPointInRange(parentNode, nodeIndex,
+                        IGNORE_EXCEPTION)  // starts in the middle of this
+                                           // range, or on the boundary points.
+         && isPointInRange(parentNode, nodeIndex + 1,
+                           IGNORE_EXCEPTION);  // ends in the middle of this
+                                               // range, or on the boundary
+                                               // points.
 }
 
 bool Range::isPointInRange(Node* refNode,
                            int offset,
                            ExceptionState& exceptionState) const {
   if (!refNode) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return false;
   }
 
   if (!refNode->inActiveDocument() || refNode->document() != m_ownerDocument) {
     return false;
   }
 
   checkNodeWOffset(refNode, offset, exceptionState);
   if (exceptionState.hadException())
     return false;
 
   return compareBoundaryPoints(refNode, offset, m_start.container(),
                                m_start.offset(), exceptionState) >= 0 &&
          !exceptionState.hadException() &&
          compareBoundaryPoints(refNode, offset, m_end.container(),
                                m_end.offset(), exceptionState) <= 0 &&
          !exceptionState.hadException();
 }
 
 short Range::comparePoint(Node* refNode,
                           int offset,
                           ExceptionState& exceptionState) const {
   // http://developer.mozilla.org/en/docs/DOM:range.comparePoint
   // This method returns -1, 0 or 1 depending on if the point described by the
-  // refNode node and an offset within the node is before, same as, or after the range respectively.
+  // refNode node and an offset within the node is before, same as, or after the
+  // range respectively.
 
   if (!refNode->inActiveDocument()) {
     exceptionState.throwDOMException(
         WrongDocumentError, "The node provided is not in an active document.");
     return 0;
   }
 
   if (refNode->document() != m_ownerDocument) {
     exceptionState.throwDOMException(
         WrongDocumentError,
@@ skipping 109 matching lines @@
   {
     EventQueueScope eventQueueScope;
     processContents(DELETE_CONTENTS, exceptionState);
   }
 }
 
 static bool nodeValidForIntersects(Node* refNode,
                                    Document* expectedDocument,
                                    ExceptionState& exceptionState) {
   if (!refNode) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return false;
   }
 
   if (!refNode->inActiveDocument() || refNode->document() != expectedDocument) {
     // Firefox doesn't throw an exception for these cases; it returns false.
     return false;
   }
 
   return true;
@@ skipping 122 matching lines @@
   Node* commonRoot = commonAncestorContainer();
   DCHECK(commonRoot);
 
   if (m_start.container() == m_end.container()) {
     processContentsBetweenOffsets(action, fragment, m_start.container(),
                                   m_start.offset(), m_end.offset(),
                                   exceptionState);
     return fragment;
   }
 
-  // Since mutation observers can modify the range during the process, the boundary points need to be saved.
+  // Since mutation observers can modify the range during the process, the
+  // boundary points need to be saved.
   RangeBoundaryPoint originalStart(m_start);
   RangeBoundaryPoint originalEnd(m_end);
 
-  // what is the highest node that partially selects the start / end of the range?
+  // what is the highest node that partially selects the start / end of the
+  // range?
   Node* partialStart =
       highestAncestorUnderCommonRoot(originalStart.container(), commonRoot);
   Node* partialEnd =
       highestAncestorUnderCommonRoot(originalEnd.container(), commonRoot);
 
   // Start and end containers are different.
   // There are three possibilities here:
   // 1. Start container == commonRoot (End container must be a descendant)
   // 2. End container == commonRoot (Start container must be a descendant)
   // 3. Neither is commonRoot, they are both descendants
   //
   // In case 3, we grab everything after the start (up until a direct child
   // of commonRoot) into leftContents, and everything before the end (up until
   // a direct child of commonRoot) into rightContents. Then we process all
   // commonRoot children between leftContents and rightContents
   //
   // In case 1 or 2, we skip either processing of leftContents or rightContents,
   // in which case the last lot of nodes either goes from the first or last
   // child of commonRoot.
   //
   // These are deleted, cloned, or extracted (i.e. both) depending on action.
 
   // Note that we are verifying that our common root hierarchy is still intact
-  // after any DOM mutation event, at various stages below. See webkit bug 60350.
+  // after any DOM mutation event, at various stages below. See webkit bug
+  // 60350.
 
   Node* leftContents = nullptr;
   if (originalStart.container() != commonRoot &&
       commonRoot->contains(originalStart.container())) {
     leftContents = processContentsBetweenOffsets(
         action, nullptr, originalStart.container(), originalStart.offset(),
         originalStart.container()->lengthOfContents(), exceptionState);
     leftContents = processAncestorsAndTheirSiblings(
         action, originalStart.container(), ProcessContentsForward, leftContents,
         commonRoot, exceptionState);
@@ skipping 13 matching lines @@
   // delete all children of commonRoot between the start and end container
   Node* processStart = childOfCommonRootBeforeOffset(
       originalStart.container(), originalStart.offset(), commonRoot);
   if (processStart &&
       originalStart.container() !=
           commonRoot)  // processStart contains nodes before m_start.
     processStart = processStart->nextSibling();
   Node* processEnd = childOfCommonRootBeforeOffset(
       originalEnd.container(), originalEnd.offset(), commonRoot);
 
-  // Collapse the range, making sure that the result is not within a node that was partially selected.
+  // Collapse the range, making sure that the result is not within a node that
+  // was partially selected.
   if (action == EXTRACT_CONTENTS || action == DELETE_CONTENTS) {
     if (partialStart && commonRoot->contains(partialStart)) {
       // FIXME: We should not continue if we have an earlier error.
       exceptionState.clearException();
       setStart(partialStart->parentNode(), partialStart->nodeIndex() + 1,
                exceptionState);
     } else if (partialEnd && commonRoot->contains(partialEnd)) {
       // FIXME: We should not continue if we have an earlier error.
       exceptionState.clearException();
       setStart(partialEnd->parentNode(), partialEnd->nodeIndex(),
@@ skipping 38 matching lines @@
 
 Node* Range::processContentsBetweenOffsets(ActionType action,
                                            DocumentFragment* fragment,
                                            Node* container,
                                            unsigned startOffset,
                                            unsigned endOffset,
                                            ExceptionState& exceptionState) {
   DCHECK(container);
   DCHECK_LE(startOffset, endOffset);
 
-  // This switch statement must be consistent with that of Node::lengthOfContents.
+  // This switch statement must be consistent with that of
+  // Node::lengthOfContents.
   Node* result = nullptr;
   switch (container->getNodeType()) {
     case Node::kTextNode:
     case Node::kCdataSectionNode:
     case Node::kCommentNode:
     case Node::kProcessingInstructionNode:
       endOffset = std::min(endOffset, toCharacterData(container)->length());
       if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
         CharacterData* c =
             static_cast<CharacterData*>(container->cloneNode(true));
@@ skipping 72 matching lines @@
     if (runner == commonRoot)
       break;
     ancestors.append(runner);
   }
 
   Node* firstChildInAncestorToProcess = direction == ProcessContentsForward
                                             ? container->nextSibling()
                                             : container->previousSibling();
   for (const auto& ancestor : ancestors) {
     if (action == EXTRACT_CONTENTS || action == CLONE_CONTENTS) {
-      if (Node* clonedAncestor = ancestor->cloneNode(
-              false)) {  // Might have been removed already during mutation event.
+      // Might have been removed already during mutation event.
+      if (Node* clonedAncestor = ancestor->cloneNode(false)) {
         clonedAncestor->appendChild(clonedContainer, exceptionState);
         clonedContainer = clonedAncestor;
       }
     }
 
     // Copy siblings of an ancestor of start/end containers
     // FIXME: This assertion may fail if DOM is modified during mutation event
     // FIXME: Share code with Range::processNodes
     DCHECK(!firstChildInAncestorToProcess ||
            firstChildInAncestorToProcess->parentNode() == ancestor);
 
     NodeVector nodes;
     for (Node* child = firstChildInAncestorToProcess; child;
          child = (direction == ProcessContentsForward)
                      ? child->nextSibling()
                      : child->previousSibling())
       nodes.append(child);
 
     for (const auto& node : nodes) {
       Node* child = node.get();
       switch (action) {
         case DELETE_CONTENTS:
-          // Prior call of ancestor->removeChild() may cause a tree change due to DOMSubtreeModified event.
-          // Therefore, we need to make sure |ancestor| is still |child|'s parent.
+          // Prior call of ancestor->removeChild() may cause a tree change due
+          // to DOMSubtreeModified event.  Therefore, we need to make sure
+          // |ancestor| is still |child|'s parent.
           if (ancestor == child->parentNode())
             ancestor->removeChild(child, exceptionState);
           break;
         case EXTRACT_CONTENTS:  // will remove child from ancestor
           if (direction == ProcessContentsForward)
             clonedContainer->appendChild(child, exceptionState);
           else
             clonedContainer->insertBefore(child, clonedContainer->firstChild(),
                                           exceptionState);
           break;
@@ skipping 23 matching lines @@
 
   return processContents(EXTRACT_CONTENTS, exceptionState);
 }
 
 DocumentFragment* Range::cloneContents(ExceptionState& exceptionState) {
   return processContents(CLONE_CONTENTS, exceptionState);
 }
 
 void Range::insertNode(Node* newNode, ExceptionState& exceptionState) {
   if (!newNode) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
-  // HierarchyRequestError: Raised if the container of the start of the Range is of a type that
-  // does not allow children of the type of newNode or if newNode is an ancestor of the container.
+  // HierarchyRequestError: Raised if the container of the start of the Range is
+  // of a type that does not allow children of the type of newNode or if newNode
+  // is an ancestor of the container.
 
-  // an extra one here - if a text node is going to split, it must have a parent to insert into
+  // an extra one here - if a text node is going to split, it must have a parent
+  // to insert into
   bool startIsText = m_start.container()->isTextNode();
   if (startIsText && !m_start.container()->parentNode()) {
     exceptionState.throwDOMException(HierarchyRequestError,
                                      "This operation would split a text node, "
                                      "but there's no parent into which to "
                                      "insert.");
     return;
   }
 
-  // In the case where the container is a text node, we check against the container's parent, because
-  // text nodes get split up upon insertion.
+  // In the case where the container is a text node, we check against the
+  // container's parent, because text nodes get split up upon insertion.
   Node* checkAgainst;
   if (startIsText)
     checkAgainst = m_start.container()->parentNode();
   else
     checkAgainst = m_start.container();
 
   Node::NodeType newNodeType = newNode->getNodeType();
   int numNewChildren;
   if (newNodeType == Node::kDocumentFragmentNode && !newNode->isShadowRoot()) {
     // check each child node, not the DocumentFragment itself
@@ skipping 23 matching lines @@
   for (Node& node : NodeTraversal::inclusiveAncestorsOf(*m_start.container())) {
     if (node == newNode) {
       exceptionState.throwDOMException(HierarchyRequestError,
                                        "The node to be inserted contains the "
                                        "insertion point; it may not be "
                                        "inserted into itself.");
       return;
     }
   }
 
-  // InvalidNodeTypeError: Raised if newNode is an Attr, Entity, Notation, ShadowRoot or Document node.
+  // InvalidNodeTypeError: Raised if newNode is an Attr, Entity, Notation,
+  // ShadowRoot or Document node.
   switch (newNodeType) {
     case Node::kAttributeNode:
     case Node::kDocumentNode:
       exceptionState.throwDOMException(
           InvalidNodeTypeError, "The node to be inserted is a '" +
                                     newNode->nodeName() +
                                     "' node, which may not be inserted here.");
       return;
     default:
       if (newNode->isShadowRoot()) {
@@ skipping 32 matching lines @@
             "but there's no parent into which to continue.");
         return;
       }
       m_end.setToBeforeChild(*newText);
     }
   } else {
     Node* lastChild = (newNodeType == Node::kDocumentFragmentNode)
                           ? toDocumentFragment(newNode)->lastChild()
                           : newNode;
     if (lastChild && lastChild == m_start.childBefore()) {
-      // The insertion will do nothing, but we need to extend the range to include
-      // the inserted nodes.
+      // The insertion will do nothing, but we need to extend the range to
+      // include the inserted nodes.
       Node* firstChild = (newNodeType == Node::kDocumentFragmentNode)
                              ? toDocumentFragment(newNode)->firstChild()
                              : newNode;
       DCHECK(firstChild);
       m_start.setToBeforeChild(*firstChild);
       return;
     }
 
     container = m_start.container();
     container->insertBefore(
         newNode, NodeTraversal::childAt(*container, m_start.offset()),
         exceptionState);
     if (exceptionState.hadException())
       return;
 
-    // Note that m_start.offset() may have changed as a result of container->insertBefore,
-    // when the node we are inserting comes before the range in the same container.
+    // Note that m_start.offset() may have changed as a result of
+    // container->insertBefore, when the node we are inserting comes before the
+    // range in the same container.
     if (collapsed && numNewChildren)
       m_end.set(m_start.container(), m_start.offset() + numNewChildren,
                 lastChild);
   }
 }
 
 String Range::toString() const {
   StringBuilder builder;
 
   Node* pastLast = pastLastNode();
   for (Node* n = firstNode(); n != pastLast; n = NodeTraversal::next(*n)) {
     Node::NodeType type = n->getNodeType();
     if (type == Node::kTextNode || type == Node::kCdataSectionNode) {
       String data = toCharacterData(n)->data();
       int length = data.length();
       int start = (n == m_start.container())
                       ? std::min(std::max(0, m_start.offset()), length)
                       : 0;
       int end = (n == m_end.container())
                     ? std::min(std::max(start, m_end.offset()), length)
                     : length;
       builder.append(data, start, end - start);
     }
   }
 
   return builder.toString();
 }
 
 String Range::text() const {
-  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  see http://crbug.com/590369 for more details.
   ownerDocument().updateStyleAndLayoutIgnorePendingStylesheets();
 
   return plainText(EphemeralRange(this),
                    TextIteratorEmitsObjectReplacementCharacter);
 }
 
 DocumentFragment* Range::createContextualFragment(
     const String& markup,
     ExceptionState& exceptionState) {
-  // Algorithm: http://domparsing.spec.whatwg.org/#extensions-to-the-range-interface
+  // Algorithm:
+  // http://domparsing.spec.whatwg.org/#extensions-to-the-range-interface
 
   Node* node = m_start.container();
 
   // Step 1.
   Element* element;
   if (!m_start.offset() &&
       (node->isDocumentNode() || node->isDocumentFragment()))
     element = nullptr;
   else if (node->isElementNode())
     element = toElement(node);
   else
     element = node->parentElement();
 
   // Step 2.
   if (!element || isHTMLHtmlElement(element)) {
     Document& document = node->document();
 
     if (document.isSVGDocument()) {
       element = document.documentElement();
       if (!element)
         element = SVGSVGElement::create(document);
     } else {
-      // Optimization over spec: try to reuse the existing <body> element, if it is available.
+      // Optimization over spec: try to reuse the existing <body> element, if it
+      // is available.
       element = document.body();
       if (!element)
         element = HTMLBodyElement::create(document);
     }
   }
 
   // Steps 3, 4, 5.
   return blink::createContextualFragment(
       markup, element, AllowScriptingContentAndDoNotMarkAlreadyStarted,
       exceptionState);
@@ skipping 45 matching lines @@
             "There is no child at offset " + String::number(offset) + ".");
       return childBefore;
     }
   }
   ASSERT_NOT_REACHED();
   return nullptr;
 }
 
 void Range::checkNodeBA(Node* n, ExceptionState& exceptionState) const {
   if (!n) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   // InvalidNodeTypeError: Raised if the root container of refNode is not an
-  // Attr, Document, DocumentFragment or ShadowRoot node, or part of a SVG shadow DOM tree,
-  // or if refNode is a Document, DocumentFragment, ShadowRoot, Attr, Entity, or Notation node.
+  // Attr, Document, DocumentFragment or ShadowRoot node, or part of a SVG
+  // shadow DOM tree, or if refNode is a Document, DocumentFragment, ShadowRoot,
+  // Attr, Entity, or Notation node.
 
   if (!n->parentNode()) {
     exceptionState.throwDOMException(InvalidNodeTypeError,
                                      "the given Node has no parent.");
     return;
   }
 
   switch (n->getNodeType()) {
     case Node::kAttributeNode:
     case Node::kDocumentFragmentNode:
@@ skipping 57 matching lines @@
 void Range::setEndAfter(Node* refNode, ExceptionState& exceptionState) {
   checkNodeBA(refNode, exceptionState);
   if (exceptionState.hadException())
     return;
 
   setEnd(refNode->parentNode(), refNode->nodeIndex() + 1, exceptionState);
 }
 
 void Range::selectNode(Node* refNode, ExceptionState& exceptionState) {
   if (!refNode) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   if (!refNode->parentNode()) {
     exceptionState.throwDOMException(InvalidNodeTypeError,
                                      "the given Node has no parent.");
     return;
   }
 
@@ skipping 16 matching lines @@
 
   if (m_ownerDocument != refNode->document())
     setDocument(refNode->document());
 
   setStartBefore(refNode);
   setEndAfter(refNode);
 }
 
 void Range::selectNodeContents(Node* refNode, ExceptionState& exceptionState) {
   if (!refNode) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
-  // InvalidNodeTypeError: Raised if refNode or an ancestor of refNode is an Entity, Notation
+  // InvalidNodeTypeError: Raised if refNode or an ancestor of refNode is an
+  // Entity, Notation
   // or DocumentType node.
   for (Node* n = refNode; n; n = n->parentNode()) {
     switch (n->getNodeType()) {
       case Node::kAttributeNode:
       case Node::kCdataSectionNode:
       case Node::kCommentNode:
       case Node::kDocumentFragmentNode:
       case Node::kDocumentNode:
       case Node::kElementNode:
       case Node::kProcessingInstructionNode:
@@ skipping 39 matching lines @@
   startBoundaryPoint.setToStartOfNode(*refNode);
   start = startBoundaryPoint.toPosition();
   RangeBoundaryPoint endBoundaryPoint(refNode);
   endBoundaryPoint.setToEndOfNode(*refNode);
   end = endBoundaryPoint.toPosition();
   return true;
 }
 
 void Range::surroundContents(Node* newParent, ExceptionState& exceptionState) {
   if (!newParent) {
-    // FIXME: Generated bindings code never calls with null, and neither should other callers!
+    // FIXME: Generated bindings code never calls with null, and neither should
+    // other callers!
     exceptionState.throwTypeError("The node provided is null.");
     return;
   }
 
   // InvalidStateError: Raised if the Range partially selects a non-Text node.
   Node* startNonTextContainer = m_start.container();
   if (startNonTextContainer->getNodeType() == Node::kTextNode)
     startNonTextContainer = startNonTextContainer->parentNode();
   Node* endNonTextContainer = m_end.container();
   if (endNonTextContainer->getNodeType() == Node::kTextNode)
     endNonTextContainer = endNonTextContainer->parentNode();
   if (startNonTextContainer != endNonTextContainer) {
     exceptionState.throwDOMException(
         InvalidStateError, "The Range has partially selected a non-Text node.");
     return;
   }
 
-  // InvalidNodeTypeError: Raised if node is an Attr, Entity, DocumentType, Notation,
+  // InvalidNodeTypeError: Raised if node is an Attr, Entity, DocumentType,
+  // Notation,
   // Document, or DocumentFragment node.
   switch (newParent->getNodeType()) {
     case Node::kAttributeNode:
     case Node::kDocumentFragmentNode:
     case Node::kDocumentNode:
     case Node::kDocumentTypeNode:
       exceptionState.throwDOMException(
           InvalidNodeTypeError,
           "The node provided is of type '" + newParent->nodeName() + "'.");
       return;
     case Node::kCdataSectionNode:
     case Node::kCommentNode:
     case Node::kElementNode:
     case Node::kProcessingInstructionNode:
     case Node::kTextNode:
       break;
   }
 
-  // Raise a HierarchyRequestError if m_start.container() doesn't accept children like newParent.
+  // Raise a HierarchyRequestError if m_start.container() doesn't accept
+  // children like newParent.
   Node* parentOfNewParent = m_start.container();
 
-  // If m_start.container() is a character data node, it will be split and it will be its parent that will
-  // need to accept newParent (or in the case of a comment, it logically "would" be inserted into the parent,
-  // although this will fail below for another reason).
+  // If m_start.container() is a character data node, it will be split and it
+  // will be its parent that will need to accept newParent (or in the case of a
+  // comment, it logically "would" be inserted into the parent, although this
+  // will fail below for another reason).
   if (parentOfNewParent->isCharacterDataNode())
     parentOfNewParent = parentOfNewParent->parentNode();
 
   if (!parentOfNewParent) {
     exceptionState.throwDOMException(HierarchyRequestError,
                                      "The container node is a detached "
                                      "character data node; no parent node is "
                                      "available for insertion.");
     return;
   }
 
   if (!parentOfNewParent->childTypeAllowed(newParent->getNodeType())) {
     exceptionState.throwDOMException(HierarchyRequestError,
                                      "The node provided is of type '" +
                                          newParent->nodeName() +
                                          "', which may not be inserted here.");
     return;
   }
 
   if (newParent->isShadowIncludingInclusiveAncestorOf(m_start.container())) {
     exceptionState.throwDOMException(HierarchyRequestError,
                                      "The node provided contains the insertion "
                                      "point; it may not be inserted into "
                                      "itself.");
     return;
   }
 
-  // FIXME: Do we need a check if the node would end up with a child node of a type not
-  // allowed by the type of node?
+  // FIXME: Do we need a check if the node would end up with a child node of a
+  // type not allowed by the type of node?
 
   while (Node* n = newParent->firstChild()) {
     toContainerNode(newParent)->removeChild(n, exceptionState);
     if (exceptionState.hadException())
       return;
   }
   DocumentFragment* fragment = extractContents(exceptionState);
   if (exceptionState.hadException())
     return;
   insertNode(newParent, exceptionState);
@@ skipping 377 matching lines @@
                      .data()
               << "start offset: " << range->startOffset()
               << ", end offset: " << range->endOffset();
   } else {
     LOG(INFO) << "Cannot show tree if range is null, or if boundary points are "
                  "invalid.";
   }
 }
 
 #endif