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

third_party/WebKit/Source/core/editing/spellcheck/SpellChecker.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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 190 matching lines @@
     element = textControl->innerEditorElement();
     if (!element)
       return;
     isTextField = isHTMLInputElement(*textControl) &&
                   toHTMLInputElement(*textControl).isTextField();
   }
 
   if (isTextField || !parent->isAlreadySpellChecked()) {
     if (EditingStrategy::editingIgnoresContent(element))
       return;
-    // We always recheck textfields because markers are removed from them on blur.
+    // We always recheck textfields because markers are removed from them on
+    // blur.
     VisibleSelection selection =
         VisibleSelection::selectionFromContentsOfNode(element);
     markMisspellingsAndBadGrammar(selection);
     if (!isTextField)
       parent->setAlreadySpellChecked(true);
   }
 }
 
 void SpellChecker::ignoreSpelling() {
   removeMarkers(frame().selection().selection(), DocumentMarker::Spelling);
 }
 
 void SpellChecker::advanceToNextMisspelling(bool startBeforeSelection) {
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       frame().document()->lifecycle());
 
-  // The basic approach is to search in two phases - from the selection end to the end of the doc, and
-  // then we wrap and search from the doc start to (approximately) where we started.
+  // The basic approach is to search in two phases - from the selection end to
+  // the end of the doc, and then we wrap and search from the doc start to
+  // (approximately) where we started.
 
-  // Start at the end of the selection, search to edge of document. Starting at the selection end makes
-  // repeated "check spelling" commands work.
+  // Start at the end of the selection, search to edge of document. Starting at
+  // the selection end makes repeated "check spelling" commands work.
   VisibleSelection selection(frame().selection().selection());
   Position spellingSearchStart, spellingSearchEnd;
   Range::selectNodeContents(frame().document(), spellingSearchStart,
                             spellingSearchEnd);
 
   bool startedWithSelection = false;
   if (selection.start().anchorNode()) {
     startedWithSelection = true;
     if (startBeforeSelection) {
       VisiblePosition start(selection.visibleStart());
       // We match AppKit's rule: Start 1 character before the selection.
       VisiblePosition oneBeforeStart = previousPositionOf(start);
       spellingSearchStart =
           (oneBeforeStart.isNotNull() ? oneBeforeStart : start)
               .toParentAnchoredPosition();
     } else {
       spellingSearchStart = selection.visibleEnd().toParentAnchoredPosition();
     }
   }
 
   Position position = spellingSearchStart;
   if (!isEditablePosition(position)) {
-    // This shouldn't happen in very often because the Spelling menu items aren't enabled unless the
-    // selection is editable.
-    // This can happen in Mail for a mix of non-editable and editable content (like Stationary),
-    // when spell checking the whole document before sending the message.
-    // In that case the document might not be editable, but there are editable pockets that need to be spell checked.
+    // This shouldn't happen in very often because the Spelling menu items
+    // aren't enabled unless the selection is editable.  This can happen in Mail
+    // for a mix of non-editable and editable content (like Stationary), when
+    // spell checking the whole document before sending the message.  In that
+    // case the document might not be editable, but there are editable pockets
+    // that need to be spell checked.
 
     if (!frame().document()->documentElement())
       return;
     position = firstEditableVisiblePositionAfterPositionInRoot(
                    position, *frame().document()->documentElement())
                    .deepEquivalent();
     if (position.isNull())
       return;
 
     spellingSearchStart = position.parentAnchoredEquivalent();
@@ skipping 17 matching lines @@
         rootEditableElementOf(oneBeforeStart) ==
             rootEditableElementOf(spellingSearchStart))
       spellingSearchStart =
           endOfWord(oneBeforeStart).toParentAnchoredPosition();
     // else we were already at the start of the editable node
   }
 
   if (spellingSearchStart == spellingSearchEnd)
     return;  // nothing to search in
 
-  // We go to the end of our first range instead of the start of it, just to be sure
-  // we don't get foiled by any word boundary problems at the start. It means we might
-  // do a tiny bit more searching.
+  // We go to the end of our first range instead of the start of it, just to be
+  // sure we don't get foiled by any word boundary problems at the start. It
+  // means we might do a tiny bit more searching.
   Node* searchEndNodeAfterWrap = spellingSearchEnd.computeContainerNode();
   int searchEndOffsetAfterWrap = spellingSearchEnd.offsetInContainerNode();
 
   std::pair<String, int> misspelledItem(String(), 0);
   String& misspelledWord = misspelledItem.first;
   int& misspellingOffset = misspelledItem.second;
   misspelledItem = findFirstMisspelling(spellingSearchStart, spellingSearchEnd);
 
-  // If we did not find a misspelled word, wrap and try again (but don't bother if we started at the beginning of the
-  // block rather than at a selection).
+  // If we did not find a misspelled word, wrap and try again (but don't bother
+  // if we started at the beginning of the block rather than at a selection).
   if (startedWithSelection && !misspelledWord) {
     spellingSearchStart = Position::editingPositionOf(topNode, 0);
     // going until the end of the very first chunk we tested is far enough
     spellingSearchEnd = Position::editingPositionOf(searchEndNodeAfterWrap,
                                                     searchEndOffsetAfterWrap);
     misspelledItem =
         findFirstMisspelling(spellingSearchStart, spellingSearchEnd);
   }
 
   if (!misspelledWord.isEmpty()) {
-    // We found a misspelling. Select the misspelling, update the spelling panel, and store
-    // a marker so we draw the red squiggle later.
+    // We found a misspelling. Select the misspelling, update the spelling
+    // panel, and store a marker so we draw the red squiggle later.
 
     const EphemeralRange misspellingRange = calculateCharacterSubrange(
         EphemeralRange(spellingSearchStart, spellingSearchEnd),
         misspellingOffset, misspelledWord.length());
     frame().selection().setSelection(createVisibleSelection(misspellingRange));
     frame().selection().revealSelection();
     spellCheckerClient().updateSpellingUIWithMisspelledWord(misspelledWord);
     frame().document()->markers().addMarker(misspellingRange.startPosition(),
                                             misspellingRange.endPosition(),
                                             DocumentMarker::Spelling);
@@ skipping 72 matching lines @@
   if (cmd.inputType() != InputEvent::InputType::InsertFromPaste)
     return;
 
   markMisspellingsAfterReplaceSelectionCommand(toReplaceSelectionCommand(cmd));
 }
 
 void SpellChecker::markMisspellingsAfterTypingCommand(
     const TypingCommand& cmd) {
   m_spellCheckRequester->cancelCheck();
 
-  // Take a look at the selection that results after typing and determine whether we need to spellcheck.
-  // Since the word containing the current selection is never marked, this does a check to
-  // see if typing made a new word that is not in the current selection. Basically, you
-  // get this by being at the end of a word and typing a space.
+  // Take a look at the selection that results after typing and determine
+  // whether we need to spellcheck.  Since the word containing the current
+  // selection is never marked, this does a check to see if typing made a new
+  // word that is not in the current selection.  Basically, you get this by
+  // being at the end of a word and typing a space.
   VisiblePosition start = createVisiblePosition(
       cmd.endingSelection().start(), cmd.endingSelection().affinity());
   VisiblePosition previous = previousPositionOf(start);
 
   VisiblePosition wordStartOfPrevious =
       startOfWord(previous, LeftWordIfOnBoundary);
 
   if (cmd.commandTypeOfOpenCommand() ==
       TypingCommand::InsertParagraphSeparator) {
     VisiblePosition nextWord = nextWordPosition(start);
@@ skipping 58 matching lines @@
   TextCheckingParagraph textToCheck(insertedRange, paragraphRange);
   chunkAndMarkAllMisspellingsAndBadGrammar(textToCheck);
 }
 
 void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(
     const TextCheckingParagraph& fullParagraphToCheck) {
   if (fullParagraphToCheck.isEmpty())
     return;
   const EphemeralRange& paragraphRange = fullParagraphToCheck.paragraphRange();
 
-  // Since the text may be quite big chunk it up and adjust to the sentence boundary.
+  // Since the text may be quite big chunk it up and adjust to the sentence
+  // boundary.
   const int kChunkSize = 16 * 1024;
 
   // Check the full paragraph instead if the paragraph is short, which saves
   // the cost on sentence boundary finding.
   if (fullParagraphToCheck.rangeLength() <= kChunkSize) {
     SpellCheckRequest* request =
         SpellCheckRequest::create(TextCheckingProcessBatch, paragraphRange, 0);
     if (request)
       m_spellCheckRequester->requestCheckingFor(request);
     return;
   }
 
   CharacterIterator checkRangeIterator(
       fullParagraphToCheck.checkingRange(),
       TextIteratorEmitsObjectReplacementCharacter);
   for (int requestNum = 0; !checkRangeIterator.atEnd(); requestNum++) {
     EphemeralRange chunkRange =
         checkRangeIterator.calculateCharacterSubrange(0, kChunkSize);
     EphemeralRange checkRange = requestNum
                                     ? expandEndToSentenceBoundary(chunkRange)
                                     : expandRangeToSentenceBoundary(chunkRange);
 
     SpellCheckRequest* request = SpellCheckRequest::create(
         TextCheckingProcessBatch, checkRange, requestNum);
     if (request)
       m_spellCheckRequester->requestCheckingFor(request);
 
     if (!checkRangeIterator.atEnd()) {
       checkRangeIterator.advance(1);
-      // The layout should be already update due to the initialization of checkRangeIterator,
-      // so comparePositions can be directly called.
+      // The layout should be already update due to the initialization of
+      // checkRangeIterator, so comparePositions can be directly called.
       if (comparePositions(chunkRange.endPosition(), checkRange.endPosition()) <
           0)
         checkRangeIterator.advance(TextIterator::rangeLength(
             chunkRange.endPosition(), checkRange.endPosition()));
     }
   }
 }
 
 void SpellChecker::markAndReplaceFor(
     SpellCheckRequest* request,
     const Vector<TextCheckingResult>& results) {
   TRACE_EVENT0("blink", "SpellChecker::markAndReplaceFor");
   DCHECK(request);
   if (!frame().selection().isAvailable()) {
     // "editing/spelling/spellcheck-async-remove-frame.html" reaches here.
     return;
   }
   if (!request->isValid())
     return;
   if (request->rootEditableElement()->document() !=
       frame().selection().document()) {
     // we ignore |request| made for another document.
     // "editing/spelling/spellcheck-sequencenum.html" and others reach here.
     return;
   }
 
-  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
-  // see http://crbug.com/590369 for more details.
+  // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
+  // needs to be audited.  See http://crbug.com/590369 for more details.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   TextCheckingParagraph paragraph(request->checkingRange(),
                                   request->checkingRange());
 
-  // Expand the range to encompass entire paragraphs, since text checking needs that much context.
+  // Expand the range to encompass entire paragraphs, since text checking needs
+  // that much context.
   int selectionOffset = 0;
   int ambiguousBoundaryOffset = -1;
   bool selectionChanged = false;
   bool restoreSelectionAfterChange = false;
   bool adjustSelectionForParagraphBoundaries = false;
 
   {
     DocumentLifecycle::DisallowTransitionScope disallowTransition(
         frame().document()->lifecycle());
 
@@ skipping 18 matching lines @@
       const TextCheckingResult* result = &results[i];
       int resultLocation = result->location + paragraph.checkingStart();
       int resultLength = result->length;
       bool resultEndsAtAmbiguousBoundary =
           ambiguousBoundaryOffset >= 0 &&
           resultLocation + resultLength == ambiguousBoundaryOffset;
 
       // Only mark misspelling if:
       // 1. Current text checking isn't done for autocorrection.
       // 2. Result falls within spellingRange.
-      // 3. The word in question doesn't end at an ambiguous boundary. For instance, we would not mark
-      //    "wouldn'" as misspelled right after apostrophe is typed.
+      // 3. The word in question doesn't end at an ambiguous boundary. For
+      //    instance, we would not mark "wouldn'" as misspelled right after
+      //    apostrophe is typed.
       if (result->decoration == TextDecorationTypeSpelling &&
           resultLocation >= paragraph.checkingStart() &&
           resultLocation + resultLength <= spellingRangeEndOffset &&
           !resultEndsAtAmbiguousBoundary) {
         DCHECK_GT(resultLength, 0);
         DCHECK_GE(resultLocation, 0);
         const EphemeralRange misspellingRange = calculateCharacterSubrange(
             paragraph.paragraphRange(), resultLocation, resultLength);
         frame().document()->markers().addMarker(
             misspellingRange.startPosition(), misspellingRange.endPosition(),
@@ skipping 40 matching lines @@
     if (restoreSelectionAfterChange && selectionOffset >= 0 &&
         selectionOffset <= extendedParagraph.rangeLength()) {
       EphemeralRange selectionRange =
           extendedParagraph.subrange(0, selectionOffset);
       frame().selection().moveTo(selectionRange.endPosition(),
                                  TextAffinity::Downstream);
       if (adjustSelectionForParagraphBoundaries)
         frame().selection().modify(FrameSelection::AlterationMove,
                                    DirectionForward, CharacterGranularity);
     } else {
-      // If this fails for any reason, the fallback is to go one position beyond the last replacement
+      // If this fails for any reason, the fallback is to go one position beyond
+      // the last replacement
       frame().selection().moveTo(frame().selection().selection().visibleEnd());
       frame().selection().modify(FrameSelection::AlterationMove,
                                  DirectionForward, CharacterGranularity);
     }
   }
 }
 
 void SpellChecker::updateMarkersForWordsAffectedByEditing(
     bool doNotRemoveIfSelectionAtWordBoundary) {
   DCHECK(frame().selection().isAvailable());
   TRACE_EVENT0("blink", "SpellChecker::updateMarkersForWordsAffectedByEditing");
   if (!isSpellCheckingEnabledFor(frame().selection().selection()))
     return;
 
   Document* document = frame().document();
   DCHECK(document);
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   document->updateStyleAndLayoutIgnorePendingStylesheets();
 
-  // We want to remove the markers from a word if an editing command will change the word. This can happen in one of
-  // several scenarios:
+  // We want to remove the markers from a word if an editing command will change
+  // the word. This can happen in one of several scenarios:
   // 1. Insert in the middle of a word.
   // 2. Appending non whitespace at the beginning of word.
   // 3. Appending non whitespace at the end of word.
-  // Note that, appending only whitespaces at the beginning or end of word won't change the word, so we don't need to
-  // remove the markers on that word.
-  // Of course, if current selection is a range, we potentially will edit two words that fall on the boundaries of
-  // selection, and remove words between the selection boundaries.
-  //
+  // Note that, appending only whitespaces at the beginning or end of word won't
+  // change the word, so we don't need to remove the markers on that word. Of
+  // course, if current selection is a range, we potentially will edit two words
+  // that fall on the boundaries of selection, and remove words between the
+  // selection boundaries.
   VisiblePosition startOfSelection =
       frame().selection().selection().visibleStart();
   VisiblePosition endOfSelection = frame().selection().selection().visibleEnd();
   if (startOfSelection.isNull())
     return;
   // First word is the word that ends after or on the start of selection.
   VisiblePosition startOfFirstWord =
       startOfWord(startOfSelection, LeftWordIfOnBoundary);
   VisiblePosition endOfFirstWord =
       endOfWord(startOfSelection, LeftWordIfOnBoundary);
   // Last word is the word that begins before or on the end of selection
   VisiblePosition startOfLastWord =
       startOfWord(endOfSelection, RightWordIfOnBoundary);
   VisiblePosition endOfLastWord =
       endOfWord(endOfSelection, RightWordIfOnBoundary);
 
   if (startOfFirstWord.isNull()) {
     startOfFirstWord = startOfWord(startOfSelection, RightWordIfOnBoundary);
     endOfFirstWord = endOfWord(startOfSelection, RightWordIfOnBoundary);
   }
 
   if (endOfLastWord.isNull()) {
     startOfLastWord = startOfWord(endOfSelection, LeftWordIfOnBoundary);
     endOfLastWord = endOfWord(endOfSelection, LeftWordIfOnBoundary);
   }
 
-  // If doNotRemoveIfSelectionAtWordBoundary is true, and first word ends at the start of selection,
-  // we choose next word as the first word.
+  // If doNotRemoveIfSelectionAtWordBoundary is true, and first word ends at the
+  // start of selection, we choose next word as the first word.
   if (doNotRemoveIfSelectionAtWordBoundary &&
       endOfFirstWord.deepEquivalent() == startOfSelection.deepEquivalent()) {
     startOfFirstWord = nextWordPosition(startOfFirstWord);
     endOfFirstWord = endOfWord(startOfFirstWord, RightWordIfOnBoundary);
     if (startOfFirstWord.deepEquivalent() == endOfSelection.deepEquivalent())
       return;
   }
 
-  // If doNotRemoveIfSelectionAtWordBoundary is true, and last word begins at the end of selection,
-  // we choose previous word as the last word.
+  // If doNotRemoveIfSelectionAtWordBoundary is true, and last word begins at
+  // the end of selection, we choose previous word as the last word.
   if (doNotRemoveIfSelectionAtWordBoundary &&
       startOfLastWord.deepEquivalent() == endOfSelection.deepEquivalent()) {
     startOfLastWord = previousWordPosition(startOfLastWord);
     endOfLastWord = endOfWord(startOfLastWord, RightWordIfOnBoundary);
     if (endOfLastWord.deepEquivalent() == startOfSelection.deepEquivalent())
       return;
   }
 
   if (startOfFirstWord.isNull() || endOfFirstWord.isNull() ||
       startOfLastWord.isNull() || endOfLastWord.isNull())
     return;
 
   const Position& removeMarkerStart = startOfFirstWord.deepEquivalent();
   const Position& removeMarkerEnd = endOfLastWord.deepEquivalent();
   if (removeMarkerStart > removeMarkerEnd) {
     // editing/inserting/insert-br-008.html and more reach here.
     // TODO(yosin): To avoid |DCHECK(removeMarkerStart <= removeMarkerEnd)|
     // in |EphemeralRange| constructor, we have this if-statement. Once we
     // fix |startOfWord()| and |endOfWord()|, we should remove this
     // if-statement.
     return;
   }
 
-  // Now we remove markers on everything between startOfFirstWord and endOfLastWord.
-  // However, if an autocorrection change a single word to multiple words, we want to remove correction mark from all the
-  // resulted words even we only edit one of them. For example, assuming autocorrection changes "avantgarde" to "avant
-  // garde", we will have CorrectionIndicator marker on both words and on the whitespace between them. If we then edit garde,
-  // we would like to remove the marker from word "avant" and whitespace as well. So we need to get the continous range of
-  // of marker that contains the word in question, and remove marker on that whole range.
+  // Now we remove markers on everything between startOfFirstWord and
+  // endOfLastWord. However, if an autocorrection change a single word to
+  // multiple words, we want to remove correction mark from all the resulted
+  // words even we only edit one of them. For example, assuming autocorrection
+  // changes "avantgarde" to "avant garde", we will have CorrectionIndicator
+  // marker on both words and on the whitespace between them. If we then edit
+  // garde, we would like to remove the marker from word "avant" and whitespace
+  // as well. So we need to get the continous range of of marker that contains
+  // the word in question, and remove marker on that whole range.
   const EphemeralRange wordRange(removeMarkerStart, removeMarkerEnd);
   document->markers().removeMarkers(
       wordRange, DocumentMarker::MisspellingMarkers(),
       DocumentMarkerController::RemovePartiallyOverlappingMarker);
 }
 
 void SpellChecker::didEndEditingOnTextField(Element* e) {
   TRACE_EVENT0("blink", "SpellChecker::didEndEditingOnTextField");
 
   // Remove markers when deactivating a selection in an <input type="text"/>.
@@ skipping 54 matching lines @@
   return oldSelection.isContentEditable();
 }
 
 void SpellChecker::respondToChangedSelection(
     const VisibleSelection& oldSelection,
     FrameSelection::SetSelectionOptions options) {
   TRACE_EVENT0("blink", "SpellChecker::respondToChangedSelection");
   if (!isSpellCheckingEnabledFor(oldSelection))
     return;
 
-  // When spell checking is off, existing markers disappear after the selection changes.
+  // When spell checking is off, existing markers disappear after the selection
+  // changes.
   if (!isSpellCheckingEnabled()) {
     frame().document()->markers().removeMarkers(DocumentMarker::Spelling);
     frame().document()->markers().removeMarkers(DocumentMarker::Grammar);
     return;
   }
 
   if (!(options & FrameSelection::CloseTyping))
     return;
   if (!shouldCheckOldSelection(oldSelection))
     return;
@@ skipping 199 matching lines @@
     }
     wordStart = wordEnd;
   }
   return results;
 }
 
 std::pair<String, int> SpellChecker::findFirstMisspelling(const Position& start,
                                                           const Position& end) {
   String misspelledWord;
 
-  // Initialize out parameters; they will be updated if we find something to return.
+  // Initialize out parameters; they will be updated if we find something to
+  // return.
   String firstFoundItem;
   int firstFoundOffset = 0;
 
-  // Expand the search range to encompass entire paragraphs, since text checking needs that much context.
-  // Determine the character offset from the start of the paragraph to the start of the original search range,
-  // since we will want to ignore results in this area.
+  // Expand the search range to encompass entire paragraphs, since text checking
+  // needs that much context. Determine the character offset from the start of
+  // the paragraph to the start of the original search range, since we will want
+  // to ignore results in this area.
   Position paragraphStart =
       startOfParagraph(createVisiblePosition(start)).toParentAnchoredPosition();
   Position paragraphEnd = end;
   int totalRangeLength =
       TextIterator::rangeLength(paragraphStart, paragraphEnd);
   paragraphEnd =
       endOfParagraph(createVisiblePosition(start)).toParentAnchoredPosition();
 
   int rangeStartOffset = TextIterator::rangeLength(paragraphStart, start);
   int totalLengthProcessed = 0;
 
   bool firstIteration = true;
   bool lastIteration = false;
   while (totalLengthProcessed < totalRangeLength) {
-    // Iterate through the search range by paragraphs, checking each one for spelling.
+    // Iterate through the search range by paragraphs, checking each one for
+    // spelling.
     int currentLength = TextIterator::rangeLength(paragraphStart, paragraphEnd);
     int currentStartOffset = firstIteration ? rangeStartOffset : 0;
     int currentEndOffset = currentLength;
     if (inSameParagraph(createVisiblePosition(paragraphStart),
                         createVisiblePosition(end))) {
-      // Determine the character offset from the end of the original search range to the end of the paragraph,
-      // since we will want to ignore results in this area.
+      // Determine the character offset from the end of the original search
+      // range to the end of the paragraph, since we will want to ignore results
+      // in this area.
       currentEndOffset = TextIterator::rangeLength(paragraphStart, end);
       lastIteration = true;
     }
     if (currentStartOffset < currentEndOffset) {
       String paragraphString =
           plainText(EphemeralRange(paragraphStart, paragraphEnd));
       if (paragraphString.length() > 0) {
         int spellingLocation = 0;
 
         Vector<TextCheckingResult> results = findMisspellings(paragraphString);
@@ skipping 29 matching lines @@
         startOfNextParagraph(createVisiblePosition(paragraphEnd));
     paragraphStart = newParagraphStart.toParentAnchoredPosition();
     paragraphEnd = endOfParagraph(newParagraphStart).toParentAnchoredPosition();
     firstIteration = false;
     totalLengthProcessed += currentLength;
   }
   return std::make_pair(firstFoundItem, firstFoundOffset);
 }
 
 }  // namespace blink