Make core/editing/ files to match Blink coding style

Source/core/editing/DeleteSelectionCommand.cpp

 /*
  * Copyright (C) 2005 Apple Computer, 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 40 matching lines @@
 {
     ASSERT(isTableCell(cell));
     return VisiblePosition(firstPositionInNode(cell)).deepEquivalent() == VisiblePosition(lastPositionInNode(cell)).deepEquivalent();
 }
 
 static bool isTableRowEmpty(Node* row)
 {
     if (!isHTMLTableRowElement(row))
         return false;
 
-    for (Node* child = row->firstChild(); child; child = child->nextSibling())
+    for (Node* child = row->firstChild(); child; child = child->nextSibling()) {
         if (isTableCell(child) && !isTableCellEmpty(child))
             return false;
-
+    }
     return true;
 }
 
 DeleteSelectionCommand::DeleteSelectionCommand(Document& document, bool smartDelete, bool mergeBlocksAfterDelete, bool expandForSpecialElements, bool sanitizeMarkup)
     : CompositeEditCommand(document)
     , m_hasSelectionToDelete(false)
     , m_smartDelete(smartDelete)
     , m_mergeBlocksAfterDelete(mergeBlocksAfterDelete)
     , m_needPlaceholder(false)
     , m_expandForSpecialElements(expandForSpecialElements)
@@ skipping 58 matching lines @@
             break;
 
         // If we're going to expand to include the startSpecialContainer, it must be fully selected.
         if (startSpecialContainer && !endSpecialContainer && comparePositions(positionInParentAfterNode(*startSpecialContainer), end) > -1)
             break;
 
         // If we're going to expand to include the endSpecialContainer, it must be fully selected.
         if (endSpecialContainer && !startSpecialContainer && comparePositions(start, positionInParentBeforeNode(*endSpecialContainer)) > -1)
             break;
 
-        if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer))
+        if (startSpecialContainer && startSpecialContainer->isDescendantOf(endSpecialContainer)) {
             // Don't adjust the end yet, it is the end of a special element that contains the start
             // special element (which may or may not be fully selected).
             start = s;
-        else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer))
+        } else if (endSpecialContainer && endSpecialContainer->isDescendantOf(startSpecialContainer)) {
             // Don't adjust the start yet, it is the start of a special element that contains the end
             // special element (which may or may not be fully selected).
             end = e;
-        else {
+        } else {
             start = s;
             end = e;
         }
     }
 }
 
 void DeleteSelectionCommand::setStartingSelectionOnSmartDelete(const Position& start, const Position& end)
 {
     bool isBaseFirst = startingSelection().isBaseFirst();
     VisiblePosition newBase(isBaseFirst ? start : end);
@@ skipping 39 matching lines @@
     else
         m_endingPosition = m_downstreamStart;
 
     // We don't want to merge into a block if it will mean changing the quote level of content after deleting
     // selections that contain a whole number paragraphs plus a line break, since it is unclear to most users
     // that such a selection actually ends at the start of the next paragraph. This matches TextEdit behavior
     // for indented paragraphs.
     // Only apply this rule if the endingSelection is a range selection.  If it is a caret, then other operations have created
     // the selection we're deleting (like the process of creating a selection to delete during a backspace), and the user isn't in the situation described above.
     if (numEnclosingMailBlockquotes(start) != numEnclosingMailBlockquotes(end)
-            && isStartOfParagraph(visibleEnd) && isStartOfParagraph(VisiblePosition(start))
-            && endingSelection().isRange()) {
+        && isStartOfParagraph(visibleEnd) && isStartOfParagraph(VisiblePosition(start))
+        && endingSelection().isRange()) {
         m_mergeBlocksAfterDelete = false;
         m_pruneStartBlockIfNecessary = true;
     }
 
     // Handle leading and trailing whitespace, as well as smart delete adjustments to the selection
     m_leadingWhitespace = leadingWhitespacePosition(m_upstreamStart, m_selectionToDelete.affinity());
     m_trailingWhitespace = trailingWhitespacePosition(m_downstreamEnd, VP_DEFAULT_AFFINITY);
 
     if (m_smartDelete) {
 
@@ skipping 261 matching lines @@
                 deleteTextFromNode(text, startOffset, m_downstreamEnd.computeOffsetInContainerNode() - startOffset);
             } else {
                 removeChildrenInRange(startNode, startOffset, m_downstreamEnd.computeEditingOffset());
                 m_endingPosition = m_upstreamStart;
             }
         }
 
         // The selection to delete is all in one node.
         if (!startNode->layoutObject() || (!startOffset && m_downstreamEnd.atLastEditingPositionForNode()))
             removeNode(startNode);
-    }
-    else {
+    } else {
         bool startNodeWasDescendantOfEndNode = m_upstreamStart.anchorNode()->isDescendantOf(m_downstreamEnd.anchorNode());
         // The selection to delete spans more than one node.
         RefPtrWillBeRawPtr<Node> node(startNode);
 
         if (startOffset > 0) {
             if (startNode->isTextNode()) {
                 // in a text node that needs to be trimmed
                 Text* text = toText(node);
                 deleteTextFromNode(text, startOffset, text->length() - startOffset);
                 node = NodeTraversal::next(*node);
@@ skipping 91 matching lines @@
             m_needPlaceholder = false;
         }
         return;
     }
 
     // It shouldn't have been asked to both try and merge content into the start block and prune it.
     ASSERT(!m_pruneStartBlockIfNecessary);
 
     // FIXME: Deletion should adjust selection endpoints as it removes nodes so that we never get into this state (4099839).
     if (!m_downstreamEnd.inDocument() || !m_upstreamStart.inDocument())
-         return;
+        return;
 
     // FIXME: The deletion algorithm shouldn't let this happen.
     if (comparePositions(m_upstreamStart, m_downstreamEnd) > 0)
         return;
 
     // There's nothing to merge.
     if (m_upstreamStart == m_downstreamEnd)
         return;
 
     VisiblePosition startOfParagraphToMove(m_downstreamEnd);
@@ skipping 59 matching lines @@
     // The endingPosition was likely clobbered by the move, so recompute it (moveParagraph selects the moved paragraph).
     m_endingPosition = endingSelection().start();
 }
 
 void DeleteSelectionCommand::removePreviouslySelectedEmptyTableRows()
 {
     if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) {
         Node* row = m_endTableRow->previousSibling();
         while (row && row != m_startTableRow) {
             RefPtrWillBeRawPtr<Node> previousRow = row->previousSibling();
-            if (isTableRowEmpty(row))
-                // Use a raw removeNode, instead of DeleteSelectionCommand's, because
-                // that won't remove rows, it only empties them in preparation for this function.
+            if (isTableRowEmpty(row)) {
+                // Use a raw removeNode, instead of DeleteSelectionCommand's,
+                // because that won't remove rows, it only empties them in
+                // preparation for this function.
                 CompositeEditCommand::removeNode(row);
+            }
             row = previousRow.get();
         }
     }
 
     // Remove empty rows after the start row.
     if (m_startTableRow && m_startTableRow->inDocument() && m_startTableRow != m_endTableRow) {
         Node* row = m_startTableRow->nextSibling();
         while (row && row != m_endTableRow) {
             RefPtrWillBeRawPtr<Node> nextRow = row->nextSibling();
             if (isTableRowEmpty(row))
                 CompositeEditCommand::removeNode(row);
             row = nextRow.get();
         }
     }
 
-    if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow)
+    if (m_endTableRow && m_endTableRow->inDocument() && m_endTableRow != m_startTableRow) {
         if (isTableRowEmpty(m_endTableRow.get())) {
-            // Don't remove m_endTableRow if it's where we're putting the ending selection.
+            // Don't remove m_endTableRow if it's where we're putting the ending
+            // selection.
             if (!m_endingPosition.anchorNode()->isDescendantOf(m_endTableRow.get())) {
-                // FIXME: We probably shouldn't remove m_endTableRow unless it's fully selected, even if it is empty.
-                // We'll need to start adjusting the selection endpoints during deletion to know whether or not m_endTableRow
-                // was fully selected here.
+                // FIXME: We probably shouldn't remove m_endTableRow unless it's
+                // fully selected, even if it is empty. We'll need to start
+                // adjusting the selection endpoints during deletion to know
+                // whether or not m_endTableRow was fully selected here.
                 CompositeEditCommand::removeNode(m_endTableRow.get());
             }
         }
+    }
 }
 
 void DeleteSelectionCommand::calculateTypingStyleAfterDelete()
 {
     // Clearing any previously set typing style and doing an early return.
     if (!m_typingStyle) {
         document().frame()->selection().clearTypingStyle();
         return;
     }
 
@@ skipping 36 matching lines @@
     Node* node = m_endingPosition.computeContainerNode();
     Element* rootElement = node->rootEditableElement();
 
     while (node != rootElement) {
         if (isRemovableBlock(node)) {
             if (node == m_endingPosition.anchorNode())
                 updatePositionForNodeRemovalPreservingChildren(m_endingPosition, *node);
 
             CompositeEditCommand::removeNodePreservingChildren(node);
             node = m_endingPosition.anchorNode();
-        } else
+        } else {
             node = node->parentNode();
+        }
     }
 }
 
 void DeleteSelectionCommand::doApply()
 {
     // If selection has not been set to a custom selection when the command was created,
     // use the current ending selection.
     if (!m_hasSelectionToDelete)
         m_selectionToDelete = endingSelection();
 
     if (!m_selectionToDelete.isNonOrphanedRange() || !m_selectionToDelete.isContentEditable())
         return;
 
     // save this to later make the selection with
     EAffinity affinity = m_selectionToDelete.affinity();
 
     Position downstreamEnd = m_selectionToDelete.end().downstream();
     bool rootWillStayOpenWithoutPlaceholder = downstreamEnd.computeContainerNode() == downstreamEnd.computeContainerNode()->rootEditableElement()
         || (downstreamEnd.computeContainerNode()->isTextNode() && downstreamEnd.computeContainerNode()->parentNode() == downstreamEnd.computeContainerNode()->rootEditableElement());
     bool lineBreakAtEndOfSelectionToDelete = lineBreakExistsAtVisiblePosition(m_selectionToDelete.visibleEnd());
     m_needPlaceholder = !rootWillStayOpenWithoutPlaceholder
         && isStartOfParagraph(m_selectionToDelete.visibleStart(), CanCrossEditingBoundary)
         && isEndOfParagraph(m_selectionToDelete.visibleEnd(), CanCrossEditingBoundary)
         && !lineBreakAtEndOfSelectionToDelete;
     if (m_needPlaceholder) {
-        // Don't need a placeholder when deleting a selection that starts just before a table
-        // and ends inside it (we do need placeholders to hold open empty cells, but that's
-        // handled elsewhere).
-        if (Element* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart()))
+        // Don't need a placeholder when deleting a selection that starts just
+        // before a table and ends inside it (we do need placeholders to hold
+        // open empty cells, but that's handled elsewhere).
+        if (Element* table = isLastPositionBeforeTable(m_selectionToDelete.visibleStart())) {
             if (m_selectionToDelete.end().anchorNode()->isDescendantOf(table))
                 m_needPlaceholder = false;
+        }
     }
 
 
     // set up our state
     initializePositionData();
 
     bool lineBreakBeforeStart = lineBreakExistsAtVisiblePosition(VisiblePosition(m_upstreamStart).previous());
 
     // Delete any text that may hinder our ability to fixup whitespace after the delete
     deleteInsignificantTextDownstream(m_trailingWhitespace);
@@ skipping 76 matching lines @@
     visitor->trace(m_deleteIntoBlockquoteStyle);
     visitor->trace(m_startRoot);
     visitor->trace(m_endRoot);
     visitor->trace(m_startTableRow);
     visitor->trace(m_endTableRow);
     visitor->trace(m_temporaryPlaceholder);
     CompositeEditCommand::trace(visitor);
 }
 
 } // namespace blink