Code cleanup related to unified text checker

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 105 matching lines @@
     for (Frame* frame = this->frame().page()->mainFrame(); frame; frame = frame->tree().traverseNext()) {
         if (!frame->isLocalFrame())
             continue;
         for (Node& node : NodeTraversal::startsAt(toLocalFrame(frame)->document()->rootNode()))
             node.setAlreadySpellChecked(false);
     }
 }
 
 void SpellChecker::didBeginEditing(Element* element)
 {
-    if (isContinuousSpellCheckingEnabled() && unifiedTextCheckerEnabled()) {
-        bool isTextField = false;
-        HTMLTextFormControlElement* enclosingHTMLTextFormControlElement = 0;
-        if (!isHTMLTextFormControlElement(*element))
-            enclosingHTMLTextFormControlElement = enclosingTextFormControl(Position::firstPositionInNode(element));
-        element = enclosingHTMLTextFormControlElement ? enclosingHTMLTextFormControlElement : element;
-        Element* parent = element;
-        if (isHTMLTextFormControlElement(*element)) {
-            HTMLTextFormControlElement* textControl = toHTMLTextFormControlElement(element);
-            parent = textControl;
-            element = textControl->innerEditorElement();
-            if (!element)
-                return;
-            isTextField = isHTMLInputElement(*textControl) && toHTMLInputElement(*textControl).isTextField();
-        }
+    if (!isContinuousSpellCheckingEnabled())
+        return;
 
-        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);
-            if (!isTextField)
-                parent->setAlreadySpellChecked(true);
-        }
+    bool isTextField = false;
+    HTMLTextFormControlElement* enclosingHTMLTextFormControlElement = 0;
+    if (!isHTMLTextFormControlElement(*element))
+        enclosingHTMLTextFormControlElement = enclosingTextFormControl(Position::firstPositionInNode(element));
+    element = enclosingHTMLTextFormControlElement ? enclosingHTMLTextFormControlElement : element;
+    Element* parent = element;
+    if (isHTMLTextFormControlElement(*element)) {
+        HTMLTextFormControlElement* textControl = toHTMLTextFormControlElement(element);
+        parent = textControl;
+        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.
+        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)
 {
@@ skipping 58 matching lines @@
     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.
     Node* searchEndNodeAfterWrap = spellingSearchEnd.computeContainerNode();
     int searchEndOffsetAfterWrap = spellingSearchEnd.offsetInContainerNode();
 
     int misspellingOffset = 0;
-    String misspelledWord;
-
-    if (unifiedTextCheckerEnabled()) {
-        misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchStart, spellingSearchEnd).findFirstMisspellingOrBadGrammar(misspellingOffset);
-    } else {
-        misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchStart, spellingSearchEnd).findFirstMisspelling(misspellingOffset, false);
-    }
+    String misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchStart, spellingSearchEnd).findFirstMisspellingOrBadGrammar(misspellingOffset);
 
     // 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);
-
-        if (unifiedTextCheckerEnabled()) {
-            misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchStart, spellingSearchEnd).findFirstMisspellingOrBadGrammar(misspellingOffset);
-        } else {
-            misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchStart, spellingSearchEnd).findFirstMisspelling(misspellingOffset, false);
-        }
+        misspelledWord = TextCheckingHelper(spellCheckerClient(), spellingSearchStart, spellingSearchEnd).findFirstMisspellingOrBadGrammar(misspellingOffset);
     }
 
     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.
 
         const EphemeralRange misspellingRange = calculateCharacterSubrange(EphemeralRange(spellingSearchStart, spellingSearchEnd), misspellingOffset, misspelledWord.length());
         frame().selection().setSelection(VisibleSelection(misspellingRange));
         frame().selection().revealSelection();
         spellCheckerClient().updateSpellingUIWithMisspelledWord(misspelledWord);
@@ skipping 12 matching lines @@
     spellCheckerClient().showSpellingUI(true);
 }
 
 void SpellChecker::clearMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
 {
     removeMarkers(movingSelection, DocumentMarker::MisspellingMarkers());
 }
 
 void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
 {
-    markMisspellingsAndBadGrammar(movingSelection, movingSelection);
+    markAllMisspellingsAndBadGrammar(movingSelection, movingSelection);
 }
 
 void SpellChecker::markMisspellingsAfterLineBreak(const VisibleSelection& wordSelection)
 {
-    TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterLineBreak");
-
-    if (!unifiedTextCheckerEnabled()) {
-        markMisspellings(wordSelection);
-        return;
-    }
-
     if (!isContinuousSpellCheckingEnabled())
         return;
 
+    TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterLineBreak");
+
     VisibleSelection wholeParagraph(
         startOfParagraph(wordSelection.visibleStart()),
         endOfParagraph(wordSelection.visibleEnd()));
 
-    markAllMisspellingsAndBadGrammarInRanges(wordSelection.toNormalizedEphemeralRange(), wholeParagraph.toNormalizedEphemeralRange());
+    markAllMisspellingsAndBadGrammar(wordSelection, wholeParagraph);
 }
 
 void SpellChecker::markMisspellingsAfterTypingToWord(const VisiblePosition &wordStart, const VisibleSelection& selectionAfterTyping)
 {
     if (!isContinuousSpellCheckingEnabled())
         return;
 
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterTypingToWord");
 
-    if (unifiedTextCheckerEnabled()) {
-        VisibleSelection adjacentWords = VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary));
-        VisibleSelection selectedSentence = VisibleSelection(startOfSentence(wordStart), endOfSentence(wordStart));
-        markAllMisspellingsAndBadGrammarInRanges(adjacentWords.toNormalizedEphemeralRange(), selectedSentence.toNormalizedEphemeralRange());
-        return;
-    }
-
-    // Check spelling of one word
-    bool result = markMisspellings(VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary)));
-
-    if (!result)
-        return;
-
-    // Check grammar of entire sentence
-    markBadGrammar(VisibleSelection(startOfSentence(wordStart), endOfSentence(wordStart)));
-}
-
-bool SpellChecker::markMisspellingsOrBadGrammar(const VisibleSelection& selection, bool checkSpelling)
-{
-    // This function is called with a selection already expanded to word boundaries.
-    // 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.
-    if (!isContinuousSpellCheckingEnabled())
-        return false;
-
-    TRACE_EVENT0("blink", "SpellChecker::markMisspellingsOrBadGrammar");
-
-    const EphemeralRange range = selection.toNormalizedEphemeralRange();
-    if (range.isNull())
-        return false;
-
-    // If we're not in an editable node, bail.
-    Node* editableNode = range.startPosition().computeContainerNode();
-    if (!editableNode || !hasEditableStyle(*editableNode))
-        return false;
-
-    if (!isSpellCheckingEnabledFor(editableNode))
-        return false;
-
-    TextCheckingHelper checker(spellCheckerClient(), range.startPosition(), range.endPosition());
-    if (checkSpelling)
-        return checker.markAllMisspellings();
-
-    return false;
+    VisibleSelection adjacentWords = VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary));
+    VisibleSelection selectedSentence = VisibleSelection(startOfSentence(wordStart), endOfSentence(wordStart));
+    markAllMisspellingsAndBadGrammar(adjacentWords, selectedSentence);
 }
 
 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;
 }
 
-bool SpellChecker::markMisspellings(const VisibleSelection& selection)
+void SpellChecker::markAllMisspellingsAndBadGrammar(const VisibleSelection& spellingSelection, const VisibleSelection& grammarSelection)
 {
-    return markMisspellingsOrBadGrammar(selection, true);
-}
-
-void SpellChecker::markBadGrammar(const VisibleSelection& selection)
-{
-    markMisspellingsOrBadGrammar(selection, false);
-}
-
-void SpellChecker::markAllMisspellingsAndBadGrammarInRanges(const EphemeralRange& spellingRange, const EphemeralRange& grammarRange)
-{
-    DCHECK(unifiedTextCheckerEnabled());
+    if (!isContinuousSpellCheckingEnabled())
+        return;
 
     // This function is called with selections already expanded to word boundaries.
+    // This function is triggered by selection change, in which case we check
+    // spelling and grammar, but don't autocorrect misspellings.
+
+    const EphemeralRange& spellingRange = spellingSelection.toNormalizedEphemeralRange();
+    const EphemeralRange& grammarRange = grammarSelection.toNormalizedEphemeralRange();
     if (spellingRange.isNull() || grammarRange.isNull())
         return;
 
     // If we're not in an editable node, bail.
     Node* editableNode = spellingRange.startPosition().computeContainerNode();
     if (!editableNode || !hasEditableStyle(*editableNode))
         return;
 
     if (!isSpellCheckingEnabledFor(editableNode))
         return;
@@ skipping 158 matching lines @@
             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
             frame().selection().moveTo(frame().selection().selection().visibleEnd());
             frame().selection().modify(FrameSelection::AlterationMove, DirectionForward, CharacterGranularity);
         }
     }
 }
 
-void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection& spellingSelection, const VisibleSelection& grammarSelection)
-{
-    if (unifiedTextCheckerEnabled()) {
-        if (!isContinuousSpellCheckingEnabled())
-            return;
-
-        // markMisspellingsAndBadGrammar() is triggered by selection change, in which case we check spelling and grammar, but don't autocorrect misspellings.
-        markAllMisspellingsAndBadGrammarInRanges(spellingSelection.toNormalizedEphemeralRange(), grammarSelection.toNormalizedEphemeralRange());
-        return;
-    }
-
-    markMisspellings(spellingSelection);
-    if (isContinuousSpellCheckingEnabled())
-        markBadGrammar(grammarSelection);
-}
-
 void SpellChecker::updateMarkersForWordsAffectedByEditing(bool doNotRemoveIfSelectionAtWordBoundary)
 {
     DCHECK(frame().selection().isAvailable());
     TRACE_EVENT0("blink", "SpellChecker::updateMarkersForWordsAffectedByEditing");
     if (!isSpellCheckingEnabledFor(frame().selection().selection()))
         return;
 
     // 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.
@@ skipping 72 matching lines @@
 void SpellChecker::didEndEditingOnTextField(Element* e)
 {
     TRACE_EVENT0("blink", "SpellChecker::didEndEditingOnTextField");
 
     // Remove markers when deactivating a selection in an <input type="text"/>.
     // Prevent new ones from appearing too.
     m_spellCheckRequester->cancelCheck();
     HTMLTextFormControlElement* textFormControlElement = toHTMLTextFormControlElement(e);
     HTMLElement* innerEditor = textFormControlElement->innerEditorElement();
     DocumentMarker::MarkerTypes markerTypes(DocumentMarker::Spelling);
-    if (unifiedTextCheckerEnabled())
-        markerTypes.add(DocumentMarker::Grammar);
+    markerTypes.add(DocumentMarker::Grammar);
     for (Node& node : NodeTraversal::inclusiveDescendantsOf(*innerEditor))
         frame().document()->markers().removeMarkers(&node, markerTypes);
 }
 
 void SpellChecker::replaceMisspelledRange(const String& text)
 {
     EphemeralRange caretRange = frame().selection().selection().toNormalizedEphemeralRange();
     if (caretRange.isNull())
         return;
     DocumentMarkerVector markers = frame().document()->markers().markersInRange(caretRange, DocumentMarker::MisspellingMarkers());
@@ skipping 81 matching lines @@
         // textFieldDidEndEditing() and textFieldDidBeginEditing() handle this.
         return;
     }
 
     VisibleSelection empty;
     spellCheckOldSelection(frame().selection().selection(), empty);
 }
 
 void SpellChecker::spellCheckOldSelection(const VisibleSelection& oldSelection, const VisibleSelection& newAdjacentWords)
 {
+    if (!isContinuousSpellCheckingEnabled())
+        return;
+
     TRACE_EVENT0("blink", "SpellChecker::spellCheckOldSelection");
 
     VisiblePosition oldStart(oldSelection.visibleStart());
     VisibleSelection oldAdjacentWords = VisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary), endOfWord(oldStart, RightWordIfOnBoundary));
     if (oldAdjacentWords == newAdjacentWords)
         return;
-    if (isContinuousSpellCheckingEnabled()) {
-        VisibleSelection selectedSentence = VisibleSelection(startOfSentence(oldStart), endOfSentence(oldStart));
-        markMisspellingsAndBadGrammar(oldAdjacentWords, selectedSentence);
-        return;
-    }
-    markMisspellingsAndBadGrammar(oldAdjacentWords, oldAdjacentWords);
+    VisibleSelection selectedSentence = VisibleSelection(startOfSentence(oldStart), endOfSentence(oldStart));
+    markAllMisspellingsAndBadGrammar(oldAdjacentWords, selectedSentence);
 }
 
 static Node* findFirstMarkable(Node* node)
 {
     while (node) {
         if (!node->layoutObject())
             return 0;
         if (node->layoutObject()->isText())
             return node;
         if (node->layoutObject()->isTextControl())
@@ skipping 31 matching lines @@
 }
 
 void SpellChecker::removeMarkers(const VisibleSelection& selection, DocumentMarker::MarkerTypes markerTypes)
 {
     const EphemeralRange range = selection.toNormalizedEphemeralRange();
     if (range.isNull())
         return;
     frame().document()->markers().removeMarkers(range, markerTypes);
 }
 
-bool SpellChecker::unifiedTextCheckerEnabled() const
-{
-    return blink::unifiedTextCheckerEnabled(m_frame);
-}
-
 void SpellChecker::cancelCheck()
 {
     m_spellCheckRequester->cancelCheck();
 }
 
 void SpellChecker::requestTextChecking(const Element& element)
 {
     const EphemeralRange rangeToCheck = EphemeralRange::rangeOfContents(element);
     m_spellCheckRequester->requestCheckingFor(SpellCheckRequest::create(TextCheckingProcessBatch, rangeToCheck, rangeToCheck));
 }
 
 DEFINE_TRACE(SpellChecker)
 {
     visitor->trace(m_frame);
     visitor->trace(m_spellCheckRequester);
 }
 
 void SpellChecker::prepareForLeakDetection()
 {
     m_spellCheckRequester->prepareForLeakDetection();
 }
 
 } // namespace blink