Reflow comments in //third_party/WebKit/Source/core/editing/commands

third_party/WebKit/Source/core/editing/commands/InsertTextCommand.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 59 matching lines @@
     return Position::firstPositionInNode(textNode);
   }
 
   return pos;
 }
 
 void InsertTextCommand::setEndingSelectionWithoutValidation(
     const Position& startPosition,
     const Position& endPosition) {
   // We could have inserted a part of composed character sequence,
-  // so we are basically treating ending selection as a range to avoid validation.
-  // <http://bugs.webkit.org/show_bug.cgi?id=15781>
+  // so we are basically treating ending selection as a range to avoid
+  // validation. <http://bugs.webkit.org/show_bug.cgi?id=15781>
   VisibleSelection forcedEndingSelection;
   forcedEndingSelection.setWithoutValidation(startPosition, endPosition);
   forcedEndingSelection.setIsDirectional(endingSelection().isDirectional());
   setEndingSelection(forcedEndingSelection);
 }
 
-// This avoids the expense of a full fledged delete operation, and avoids a layout that typically results
-// from text removal.
+// This avoids the expense of a full fledged delete operation, and avoids a
+// layout that typically results from text removal.
 bool InsertTextCommand::performTrivialReplace(const String& text,
                                               bool selectInsertedText) {
   if (!endingSelection().isRange())
     return false;
 
   if (text.contains('\t') || text.contains(' ') || text.contains('\n'))
     return false;
 
   Position start = endingSelection().start();
   Position endPosition = replaceSelectedTextInNode(text);
@@ skipping 46 matching lines @@
   // Delete the current selection.
   // FIXME: This delete operation blows away the typing style.
   if (endingSelection().isRange()) {
     if (performTrivialReplace(m_text, m_selectInsertedText))
       return;
     bool endOfSelectionWasAtStartOfBlock =
         isStartOfBlock(endingSelection().visibleEndDeprecated());
     deleteSelection(editingState, false, true, false, false);
     if (editingState->isAborted())
       return;
-    // deleteSelection eventually makes a new endingSelection out of a Position. If that Position doesn't have
-    // a layoutObject (e.g. it is on a <frameset> in the DOM), the VisibleSelection cannot be canonicalized to
-    // anything other than NoSelection. The rest of this function requires a real endingSelection, so bail out.
+    // deleteSelection eventually makes a new endingSelection out of a Position.
+    // If that Position doesn't have a layoutObject (e.g. it is on a <frameset>
+    // in the DOM), the VisibleSelection cannot be canonicalized to anything
+    // other than NoSelection. The rest of this function requires a real
+    // endingSelection, so bail out.
     if (endingSelection().isNone())
       return;
     if (endOfSelectionWasAtStartOfBlock) {
       if (EditingStyle* typingStyle =
               document().frame()->selection().typingStyle())
         typingStyle->removeBlockProperties();
     }
   } else if (document().frame()->editor().isOverwriteModeEnabled()) {
     if (performOverwrite(m_text, m_selectInsertedText))
       return;
   }
 
   Position startPosition(endingSelection().start());
 
   Position placeholder;
-  // We want to remove preserved newlines and brs that will collapse (and thus become unnecessary) when content
-  // is inserted just before them.
-  // FIXME: We shouldn't really have to do this, but removing placeholders is a workaround for 9661.
-  // If the caret is just before a placeholder, downstream will normalize the caret to it.
+  // We want to remove preserved newlines and brs that will collapse (and thus
+  // become unnecessary) when content is inserted just before them.
+  // FIXME: We shouldn't really have to do this, but removing placeholders is a
+  // workaround for 9661.
+  // If the caret is just before a placeholder, downstream will normalize the
+  // caret to it.
   Position downstream(mostForwardCaretPosition(startPosition));
   if (lineBreakExistsAtPosition(downstream)) {
     // FIXME: This doesn't handle placeholders at the end of anonymous blocks.
     VisiblePosition caret = createVisiblePositionDeprecated(startPosition);
     if (isEndOfBlock(caret) && isStartOfParagraphDeprecated(caret))
       placeholder = downstream;
-    // Don't remove the placeholder yet, otherwise the block we're inserting into would collapse before
-    // we get a chance to insert into it.  We check for a placeholder now, though, because doing so requires
-    // the creation of a VisiblePosition, and if we did that post-insertion it would force a layout.
+    // Don't remove the placeholder yet, otherwise the block we're inserting
+    // into would collapse before we get a chance to insert into it.  We check
+    // for a placeholder now, though, because doing so requires the creation of
+    // a VisiblePosition, and if we did that post-insertion it would force a
+    // layout.
   }
 
   // Insert the character at the leftmost candidate.
   startPosition = mostBackwardCaretPosition(startPosition);
 
-  // It is possible for the node that contains startPosition to contain only unrendered whitespace,
-  // and so deleteInsignificantText could remove it.  Save the position before the node in case that happens.
+  // It is possible for the node that contains startPosition to contain only
+  // unrendered whitespace, and so deleteInsignificantText could remove it.
+  // Save the position before the node in case that happens.
   DCHECK(startPosition.computeContainerNode()) << startPosition;
   Position positionBeforeStartNode(
       Position::inParentBeforeNode(*startPosition.computeContainerNode()));
   deleteInsignificantText(startPosition,
                           mostForwardCaretPosition(startPosition));
   if (!startPosition.isConnected())
     startPosition = positionBeforeStartNode;
   if (!isVisuallyEquivalentCandidate(startPosition))
     startPosition = mostForwardCaretPosition(startPosition);
 
@@ skipping 22 matching lines @@
     DCHECK(startPosition.computeContainerNode()->isTextNode()) << startPosition;
     if (placeholder.isNotNull())
       removePlaceholderAt(placeholder);
     Text* textNode = toText(startPosition.computeContainerNode());
     const unsigned offset = startPosition.offsetInContainerNode();
 
     insertTextIntoNode(textNode, offset, m_text);
     endPosition = Position(textNode, offset + m_text.length());
 
     if (m_rebalanceType == RebalanceLeadingAndTrailingWhitespaces) {
-      // The insertion may require adjusting adjacent whitespace, if it is present.
+      // The insertion may require adjusting adjacent whitespace, if it is
+      // present.
       rebalanceWhitespaceAt(endPosition);
-      // Rebalancing on both sides isn't necessary if we've inserted only spaces.
+      // Rebalancing on both sides isn't necessary if we've inserted only
+      // spaces.
       if (!shouldRebalanceLeadingWhitespaceFor(m_text))
         rebalanceWhitespaceAt(startPosition);
     } else {
       DCHECK_EQ(m_rebalanceType, RebalanceAllWhitespaces);
       if (canRebalance(startPosition) && canRebalance(endPosition))
         rebalanceWhitespaceOnTextSubstring(
             textNode, startPosition.offsetInContainerNode(),
             endPosition.offsetInContainerNode());
     }
   }
@@ skipping 55 matching lines @@
     }
   }
   if (editingState->isAborted())
     return Position();
 
   // return the position following the new tab
   return Position::lastPositionInNode(spanElement);
 }
 
 }  // namespace blink