DO NOT COMMIT: Results of running new (proposed) clang-format on Blink

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) 2011 Motorola Mobility. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 231 matching lines @@
   updateSelectionIfAddedToSelection();
 }
 
 bool Range::isNodeFullyContained(Node& node) const {
   ContainerNode* parentNode = node.parentNode();
   int nodeIndex = node.nodeIndex();
   return isPointInRange(
              parentNode, nodeIndex,
              IGNORE_EXCEPTION_FOR_TESTING)  // starts in the middle of this
                                             // range, or on the boundary points.
-         && isPointInRange(
-                parentNode, nodeIndex + 1,
-                IGNORE_EXCEPTION_FOR_TESTING);  // ends in the middle of this
-                                                // range, or on the boundary
-                                                // points.
+         &&
+         isPointInRange(
+             parentNode, nodeIndex + 1,
+             IGNORE_EXCEPTION_FOR_TESTING);  // ends in the middle of this
+                                             // range, or on the boundary
+                                             // points.
 }
 
 bool Range::hasSameRoot(const Node& node) const {
   if (node.document() != m_ownerDocument)
     return false;
   // commonAncestorContainer() is O(depth). We should avoid to call it in common
   // cases.
   if (node.isInTreeScope() && m_start.container()->isInTreeScope() &&
       &node.treeScope() == &m_start.container()->treeScope())
     return true;
@@ skipping 574 matching lines @@
             "The node to be inserted contains a '" + c->nodeName() +
                 "' node, which may not be inserted here.");
         return;
       }
       ++numNewChildren;
     }
   } else {
     numNewChildren = 1;
     if (!checkAgainst->childTypeAllowed(newNodeType)) {
       exceptionState.throwDOMException(
-          HierarchyRequestError, "The node to be inserted is a '" +
-                                     newNode->nodeName() +
-                                     "' node, which may not be inserted here.");
+          HierarchyRequestError,
+          "The node to be inserted is a '" + newNode->nodeName() +
+              "' node, which may not be inserted here.");
       return;
     }
   }
 
   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.
   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.");
+          InvalidNodeTypeError,
+          "The node to be inserted is a '" + newNode->nodeName() +
+              "' node, which may not be inserted here.");
       return;
     default:
       if (newNode->isShadowRoot()) {
         exceptionState.throwDOMException(InvalidNodeTypeError,
                                          "The node to be inserted is a shadow "
                                          "root, which may not be inserted "
                                          "here.");
         return;
       }
       break;
@@ skipping 775 matching lines @@
     if (node->isElementNode())
       nodeSet.insert(node);
   }
 
   for (Node* node = firstNode(); node != stopNode;
        node = NodeTraversal::next(*node)) {
     if (node->isElementNode()) {
       // Exclude start & end container unless the entire corresponding
       // node is included in the range.
       if (!nodeSet.contains(node->parentNode()) &&
-          (startContainer == endContainer || (!node->contains(startContainer) &&
-                                              !node->contains(endContainer)))) {
+          (startContainer == endContainer ||
+           (!node->contains(startContainer) &&
+            !node->contains(endContainer)))) {
         if (LayoutObject* layoutObject = toElement(node)->layoutObject()) {
           Vector<FloatQuad> elementQuads;
           layoutObject->absoluteQuads(elementQuads);
           m_ownerDocument->adjustFloatQuadsForScrollAndAbsoluteZoom(
               elementQuads, *layoutObject);
 
           quads.appendVector(elementQuads);
         }
       }
     } else if (node->isTextNode()) {
@@ skipping 76 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