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

third_party/WebKit/Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights
  * reserved.
  *
  * 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 347 matching lines @@
 }
 
 static Position nextRootInlineBoxCandidatePosition(
     Node* node,
     const VisiblePosition& visiblePosition,
     EditableType editableType) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   ContainerNode* highestRoot =
       highestEditableRoot(visiblePosition.deepEquivalent(), editableType);
   Node* nextNode = nextLeafWithSameEditability(node, editableType);
-  while (nextNode && (!nextNode->layoutObject() ||
-                      inSameLine(createVisiblePosition(
-                                     firstPositionInOrBeforeNode(nextNode)),
-                                 visiblePosition)))
+  while (
+      nextNode &&
+      (!nextNode->layoutObject() ||
+       inSameLine(createVisiblePosition(firstPositionInOrBeforeNode(nextNode)),
+                  visiblePosition)))
     nextNode = nextLeafWithSameEditability(nextNode, ContentIsEditable);
 
   while (nextNode && !nextNode->isShadowRoot()) {
     if (highestEditableRoot(firstPositionInOrBeforeNode(nextNode),
                             editableType) != highestRoot)
       break;
 
     Position pos;
     pos = Position::editingPositionOf(nextNode, caretMinOffset(nextNode));
 
@@ skipping 1954 matching lines @@
         if (equivalent == position ||
             downstreamIgnoringEditingBoundaries(equivalent) == position)
           return InlineBoxPosition(inlineBox, caretOffset);
       }
 
       return computeInlineBoxPosition(equivalent, TextAffinity::Upstream,
                                       primaryDirection);
     }
     if (layoutObject->isBox()) {
       inlineBox = toLayoutBox(layoutObject)->inlineBoxWrapper();
-      if (!inlineBox || (caretOffset > inlineBox->caretMinOffset() &&
-                         caretOffset < inlineBox->caretMaxOffset()))
+      if (!inlineBox ||
+          (caretOffset > inlineBox->caretMinOffset() &&
+           caretOffset < inlineBox->caretMaxOffset()))
         return InlineBoxPosition(inlineBox, caretOffset);
     }
   } else {
     LayoutText* textLayoutObject = toLayoutText(layoutObject);
 
     InlineTextBox* box;
     InlineTextBox* candidate = 0;
 
     for (box = textLayoutObject->firstTextBox(); box;
          box = box->nextTextBox()) {
@@ skipping 383 matching lines @@
     if (textOffset < static_cast<int>(box->start()) &&
         !textLayoutObject->containsReversedText()) {
       // The offset we're looking for is before this node
       // this means the offset must be in content that is
       // not laid out. Return false.
       return false;
     }
     if (box->containsCaretOffset(textOffset)) {
       // Return false for offsets inside composed characters.
       return textOffset == 0 ||
-             textOffset == nextGraphemeBoundaryOf(anchorNode,
-                                                  previousGraphemeBoundaryOf(
-                                                      anchorNode, textOffset));
+             textOffset ==
+                 nextGraphemeBoundaryOf(
+                     anchorNode,
+                     previousGraphemeBoundaryOf(anchorNode, textOffset));
     }
   }
 
   return false;
 }
 
 bool rendersInDifferentPosition(const Position& position1,
                                 const Position& position2) {
   if (position1.isNull() || position2.isNull())
     return false;
@@ skipping 1164 matching lines @@
 
 VisiblePositionInFlatTree previousPositionOf(
     const VisiblePositionInFlatTree& visiblePosition,
     EditingBoundaryCrossingRule rule) {
   DCHECK(visiblePosition.isValid()) << visiblePosition;
   return previousPositionOfAlgorithm<EditingInFlatTreeStrategy>(
       visiblePosition.deepEquivalent(), rule);
 }
 
 }  // namespace blink