Cleanup function names in SpellChecker and TextCheckingHelper

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 126 matching lines @@
             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.
             VisibleSelection selection = VisibleSelection::selectionFromContentsOfNode(element);
-            markMisspellingsAndBadGrammar(selection);
+            markMisspellings(selection);
             if (!isTextField)
                 parent->setAlreadySpellChecked(true);
         }
     }
 }
 
 void SpellChecker::ignoreSpelling()
 {
     removeMarkers(frame().selection().selection(), DocumentMarker::Spelling);
 }
@@ skipping 73 matching lines @@
     // 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);
         misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchStart, spellingSearchEnd).findFirstMisspelling(misspellingOffset, false);
     }
 
     if (!misspelledWord.isEmpty()) {
-        // We found a misspelling, but not any earlier bad grammar. 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(VisibleSelection(misspellingRange));
         frame().selection().revealSelection();
         spellCheckerClient().updateSpellingUIWithMisspelledWord(misspelledWord);
         frame().document()->markers().addMarker(misspellingRange.startPosition(), misspellingRange.endPosition(), DocumentMarker::Spelling);
     }
 }
 
 void SpellChecker::showSpellingGuessPanel()
 {
     if (spellCheckerClient().spellingUIIsShowing()) {
         spellCheckerClient().showSpellingUI(false);
         return;
     }
 
     advanceToNextMisspelling(true);
     spellCheckerClient().showSpellingUI(true);
 }
 
-void SpellChecker::clearMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
+void SpellChecker::clearMisspellings(const VisibleSelection &movingSelection)
 {
     removeMarkers(movingSelection, DocumentMarker::MisspellingMarkers());
 }
 
-void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
+void SpellChecker::markMisspellings(const VisibleSelection &movingSelection)
 {
     if (unifiedTextCheckerEnabled()) {
         if (!isContinuousSpellCheckingEnabled())
             return;
 
-        // markMisspellingsAndBadGrammar() is triggered by selection change, in which case we check spelling, but don't autocorrect misspellings.
+        // markMisspellings() is triggered by selection change, in which
+        // case we check spelling, but don't autocorrect misspellings.
         markAllMisspellingsInRange(movingSelection.toNormalizedEphemeralRange());
         return;
     }
 
-    markMisspellings(movingSelection);
+    markMisspellingsWithTextCheckingHelper(movingSelection);
 }
 
 void SpellChecker::markMisspellingsAfterLineBreak(const VisibleSelection& wordSelection)
 {
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterLineBreak");
 
     if (!unifiedTextCheckerEnabled()) {
-        markMisspellings(wordSelection);
+        markMisspellingsWithTextCheckingHelper(wordSelection);
         return;
     }
 
     if (isContinuousSpellCheckingEnabled())
         markAllMisspellingsInRange(wordSelection.toNormalizedEphemeralRange());
 }
 
 void SpellChecker::markMisspellingsAfterTypingToWord(const VisiblePosition &wordStart, const VisibleSelection& selectionAfterTyping)
 {
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterTypingToWord");
 
     if (unifiedTextCheckerEnabled()) {
         TextCheckingTypeMask textCheckingOptions = 0;
 
         if (isContinuousSpellCheckingEnabled())
             textCheckingOptions |= TextCheckingTypeSpelling;
 
         if (!(textCheckingOptions & TextCheckingTypeSpelling))
             return;
 
         VisibleSelection adjacentWords = VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary));
         markAllMisspellingsInRange(adjacentWords.toNormalizedEphemeralRange());
         return;
     }
 
     if (!isContinuousSpellCheckingEnabled())
         return;
 
     // Check spelling of one word
-    markMisspellings(VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary)));
+    markMisspellingsWithTextCheckingHelper(VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary)));
 }
 
 bool SpellChecker::isSpellCheckingEnabledFor(Node* node) const
 {
     if (!node)
         return false;
     const Element* focusedElement = node->isElementNode() ? toElement(node) : node->parentElement();
     if (!focusedElement)
         return false;
     return focusedElement->isSpellCheckingEnabled();
@@ skipping 14 matching lines @@
         if (isHTMLInputElement(textControl) && toHTMLInputElement(textControl)->type() == InputTypeNames::password)
             return false;
     }
     if (HTMLElement* element = Traversal<HTMLElement>::firstAncestorOrSelf(*selection.start().anchorNode())) {
         if (element->spellcheck())
             return true;
     }
     return false;
 }
 
-void SpellChecker::markMisspellings(const VisibleSelection& selection)
+void SpellChecker::markMisspellingsWithTextCheckingHelper(const VisibleSelection& selection)
 {
     // This function is called with a selection already expanded to word boundaries.
     // TODO(xiaochengh): Might be nice to assert that here.
 
-    // This function is used only for as-you-type checking, so if that's off we do nothing. Note that
-    // grammar checking can only be on if spell checking is also on.
+    // This function is used only for as-you-type checking, so if that's off we do nothing.
     if (!isContinuousSpellCheckingEnabled())
         return;
 
     TRACE_EVENT0("blink", "SpellChecker::markMisspellings");
 
     const EphemeralRange& range = selection.toNormalizedEphemeralRange();
     if (range.isNull())
         return;
 
     // If we're not in an editable node, bail.
@@ skipping 39 matching lines @@
 
 static EphemeralRange expandRangeToSentenceBoundary(const EphemeralRange& range)
 {
     DCHECK(range.isNotNull());
     const VisiblePosition& visibleStart = createVisiblePosition(range.startPosition());
     DCHECK(visibleStart.isNotNull());
     const Position& sentenceStart = startOfSentence(visibleStart).deepEquivalent();
     return expandEndToSentenceBoundary(EphemeralRange(sentenceStart.isNull() ? range.startPosition() : sentenceStart, range.endPosition()));
 }
 
-void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(Node* node, const EphemeralRange& insertedRange)
+void SpellChecker::chunkAndMarkAllMisspellings(Node* node, const EphemeralRange& insertedRange)
 {
-    TRACE_EVENT0("blink", "SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar");
+    TRACE_EVENT0("blink", "SpellChecker::chunkAndMarkAllMisspellings");
     if (!node)
         return;
     EphemeralRange paragraphRange(Position::firstPositionInNode(node), Position::lastPositionInNode(node));
     TextCheckingParagraph textToCheck(insertedRange, paragraphRange);
     chunkAndMarkAllMisspellings(textToCheck);
 }
 
 void SpellChecker::chunkAndMarkAllMisspellings(const TextCheckingParagraph& fullParagraphToCheck)
 {
     if (fullParagraphToCheck.isEmpty())
@@ skipping 313 matching lines @@
 }
 
 void SpellChecker::spellCheckOldSelection(const VisibleSelection& oldSelection, const VisibleSelection& newAdjacentWords)
 {
     TRACE_EVENT0("blink", "SpellChecker::spellCheckOldSelection");
 
     VisiblePosition oldStart(oldSelection.visibleStart());
     VisibleSelection oldAdjacentWords = VisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary), endOfWord(oldStart, RightWordIfOnBoundary));
     if (oldAdjacentWords == newAdjacentWords)
         return;
-    markMisspellingsAndBadGrammar(oldAdjacentWords);
+    markMisspellings(oldAdjacentWords);
 }
 
 static Node* findFirstMarkable(Node* node)
 {
     while (node) {
         if (!node->layoutObject())
             return 0;
         if (node->layoutObject()->isText())
             return node;
         if (node->layoutObject()->isTextControl())
@@ skipping 59 matching lines @@
     visitor->trace(m_frame);
     visitor->trace(m_spellCheckRequester);
 }
 
 void SpellChecker::prepareForLeakDetection()
 {
     m_spellCheckRequester->prepareForLeakDetection();
 }
 
 } // namespace blink