Make core/editing/ files to match Blink coding style

Source/core/editing/CompositeEditCommand.cpp

 /*
  * Copyright (C) 2005, 2006, 2007, 2008 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 302 matching lines @@
 }
 
 void CompositeEditCommand::insertNodeAfter(PassRefPtrWillBeRawPtr<Node> insertChild, PassRefPtrWillBeRawPtr<Node> refChild)
 {
     ASSERT(insertChild);
     ASSERT(refChild);
     ASSERT(!isHTMLBodyElement(*refChild));
     ContainerNode* parent = refChild->parentNode();
     ASSERT(parent);
     ASSERT(!parent->isShadowRoot());
-    if (parent->lastChild() == refChild)
+    if (parent->lastChild() == refChild) {
         appendNode(insertChild, parent);
-    else {
+    } else {
         ASSERT(refChild->nextSibling());
         insertNodeBefore(insertChild, refChild->nextSibling());
     }
 }
 
 void CompositeEditCommand::insertNodeAt(PassRefPtrWillBeRawPtr<Node> insertChild, const Position& editingPosition)
 {
     ASSERT(isEditablePosition(editingPosition, ContentIsEditable, DoNotUpdateStyle));
     // For editing positions like [table, 0], insert before the table,
     // likewise for replaced elements, brs, etc.
     Position p = editingPosition.parentAnchoredEquivalent();
     Node* refChild = p.anchorNode();
     int offset = p.offsetInContainerNode();
 
     if (canHaveChildrenForEditing(refChild)) {
         Node* child = refChild->firstChild();
         for (int i = 0; child && i < offset; i++)
             child = child->nextSibling();
         if (child)
             insertNodeBefore(insertChild, child);
         else
             appendNode(insertChild, toContainerNode(refChild));
-    } else if (caretMinOffset(refChild) >= offset)
+    } else if (caretMinOffset(refChild) >= offset) {
         insertNodeBefore(insertChild, refChild);
-    else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
+    } else if (refChild->isTextNode() && caretMaxOffset(refChild) > offset) {
         splitTextNode(toText(refChild), offset);
 
         // Mutation events (bug 22634) from the text node insertion may have removed the refChild
         if (!refChild->inDocument())
             return;
         insertNodeBefore(insertChild, refChild);
-    } else
+    } else {
         insertNodeAfter(insertChild, refChild);
+    }
 }
 
 void CompositeEditCommand::appendNode(PassRefPtrWillBeRawPtr<Node> node, PassRefPtrWillBeRawPtr<ContainerNode> parent)
 {
     // When cloneParagraphUnderNewElement() clones the fallback content
     // of an OBJECT element, the ASSERT below may fire since the return
     // value of canHaveChildrenForEditing is not reliable until the layout
     // object of the OBJECT is created. Hence we ignore this check for OBJECTs.
     ASSERT(canHaveChildrenForEditing(parent.get())
         || (parent->isElementNode() && toElement(parent.get())->tagQName() == objectTag));
@@ skipping 298 matching lines @@
 
     int length = downstream - upstream;
     if (!length)
         return;
 
     VisiblePosition visibleUpstreamPos(Position(textNode, upstream));
     VisiblePosition visibleDownstreamPos(Position(textNode, downstream));
 
     String string = text.substring(upstream, length);
     String rebalancedString = stringWithRebalancedWhitespace(string,
-    // FIXME: Because of the problem mentioned at the top of this function, we must also use nbsps at the start/end of the string because
-    // this function doesn't get all surrounding whitespace, just the whitespace in the current text node.
-                                                             isStartOfParagraph(visibleUpstreamPos) || upstream == 0,
-                                                             isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length());
+    // FIXME: Because of the problem mentioned at the top of this function, we
+    // must also use nbsps at the start/end of the string because this function
+    // doesn't get all surrounding whitespace, just the whitespace in the
+    // current text node.
+        isStartOfParagraph(visibleUpstreamPos) || upstream == 0,
+        isEndOfParagraph(visibleDownstreamPos) || (unsigned)downstream == text.length());
 
     if (string != rebalancedString)
         replaceTextInNodePreservingMarkers(textNode.release(), upstream, length, rebalancedString);
 }
 
 void CompositeEditCommand::prepareWhitespaceAtPositionForSplit(Position& position)
 {
     Node* node = position.anchorNode();
     if (!node || !node->isTextNode())
         return;
@@ skipping 71 matching lines @@
         return;
 
     unsigned removed = 0;
     InlineTextBox* prevBox = nullptr;
     String str;
 
     // This loop structure works to process all gaps preceding a box,
     // and also will look at the gap after the last box.
     while (prevBox || box) {
         unsigned gapStart = prevBox ? prevBox->start() + prevBox->len() : 0;
-        if (end < gapStart)
+        if (end < gapStart) {
             // No more chance for any intersections
             break;
+        }
 
         unsigned gapEnd = box ? box->start() : length;
         bool indicesIntersect = start <= gapEnd && end >= gapStart;
         int gapLen = gapEnd - gapStart;
         if (indicesIntersect && gapLen > 0) {
             gapStart = std::max(gapStart, start);
             if (str.isNull())
                 str = textNode->data().substring(start, end - start);
             // remove text in the gap
             str.remove(gapStart - start - removed, gapLen);
             removed += gapLen;
         }
 
         prevBox = box;
         if (box) {
             if (++sortedTextBoxesPosition < sortedTextBoxes.size())
                 box = sortedTextBoxes[sortedTextBoxesPosition];
             else
                 box = 0;
         }
     }
 
     if (!str.isNull()) {
         // Replace the text between start and end with our pruned version.
-        if (!str.isEmpty())
+        if (!str.isEmpty()) {
             replaceTextInNode(textNode, start, end - start, str);
-        else {
+        } else {
             // Assert that we are not going to delete all of the text in the node.
             // If we were, that should have been done above with the call to
             // removeNode and return.
             ASSERT(start > 0 || end - start < textNode->length());
             deleteTextFromNode(textNode, start, end - start);
         }
     }
 }
 
 void CompositeEditCommand::deleteInsignificantText(const Position& start, const Position& end)
@@ skipping 284 matching lines @@
             // div or an li), remove it during the move (the list removal code
             // expects this behavior).
         } else if (isBlock(node)) {
             // If caret position after deletion and destination position coincides,
             // node should not be removed.
             if (!rendersInDifferentPosition(position, destination.deepEquivalent())) {
                 prune(node, destinationNode);
                 return;
             }
             removeNodeAndPruneAncestors(node, destinationNode);
-        }
-        else if (lineBreakExistsAtPosition(position)) {
+        } else if (lineBreakExistsAtPosition(position)) {
             // There is a preserved '\n' at caretAfterDelete.
             // We can safely assume this is a text node.
             Text* textNode = toText(node);
             if (textNode->length() == 1)
                 removeNodeAndPruneAncestors(node, destinationNode);
             else
                 deleteTextFromNode(textNode, position.computeOffsetInContainerNode(), 1);
         }
     }
 }
@@ skipping 381 matching lines @@
 }
 
 DEFINE_TRACE(CompositeEditCommand)
 {
     visitor->trace(m_commands);
     visitor->trace(m_composition);
     EditCommand::trace(visitor);
 }
 
 } // namespace blink