Simplify SpellChecker::markAllMisspellingsAndBadGrammar()

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 54 matching lines @@
 {
     HTMLTextFormControlElement* textControl = enclosingTextFormControl(selection.start());
     return isHTMLTextAreaElement(textControl);
 }
 
 bool isSelectionInTextFormControl(const VisibleSelection& selection)
 {
     return !!enclosingTextFormControl(selection.start());
 }
 
+static EphemeralRange expandEndToSentenceBoundary(const EphemeralRange& range)
+{
+    DCHECK(range.isNotNull());
+    const VisiblePosition& visibleEnd = createVisiblePosition(range.endPosition());
+    DCHECK(visibleEnd.isNotNull());
+    const Position& sentenceEnd = endOfSentence(visibleEnd).deepEquivalent();
+    // TODO(xiaochengh): |sentenceEnd < range.startPosition()| seems possible,
+    // which would trigger a DCHECK in EphemeralRange's constructor. Need more
+    // investigation, and if that is really the case, fix it.
+    return EphemeralRange(range.startPosition(), sentenceEnd.isNotNull() ? sentenceEnd : range.endPosition());
+}
+
+static EphemeralRange expandRangeToSentenceBoundary(const EphemeralRange& range)
+{
+    DCHECK(range.isNotNull());
+    const VisiblePosition& visibleStart = createVisiblePosition(range.startPosition());
+    DCHECK(visibleStart.isNotNull());
+    const Position& sentenceStart = startOfSentence(visibleStart).deepEquivalent();
+    const VisiblePosition& visibleEnd = createVisiblePosition(range.endPosition());
+    DCHECK(visibleStart.isNotNull());
+    const Position& sentenceEnd = endOfSentence(visibleEnd).deepEquivalent();
+    return EphemeralRange(sentenceStart.isNull() ? range.startPosition() : sentenceStart, sentenceEnd.isNull() ? range.endPosition() : sentenceEnd);
+}
+
 } // namespace
 
 SpellChecker* SpellChecker::create(LocalFrame& frame)
 {
     return new SpellChecker(frame);
 }
 
 static SpellCheckerClient& emptySpellCheckerClient()
 {
     DEFINE_STATIC_LOCAL(EmptySpellCheckerClient, client, ());
@@ skipping 174 matching lines @@
 
     advanceToNextMisspelling(true);
     spellCheckerClient().showSpellingUI(true);
 }
 
 void SpellChecker::clearMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
 {
     removeMarkers(movingSelection, DocumentMarker::MisspellingMarkers());
 }
 
-void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
+void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection& selection)
 {
-    markAllMisspellingsAndBadGrammar(movingSelection, movingSelection);
+    if (!isContinuousSpellCheckingEnabled())

[yosin_UTC9, 2016/08/16 02:28:47]

BTW, Could you rename |isContinuousSpellCheckingEnabled()| to
|isSpellCheckingEnabled()|?
|isContinuousSpellCheckingEnabled()| makes us confusing. (~_~)

+        return;
+
+    const EphemeralRange& range = selection.toNormalizedEphemeralRange();
+    if (range.isNull())
+        return;
+
+    // If we're not in an editable node, bail.
+    Node* editableNode = range.startPosition().computeContainerNode();
+    if (!editableNode || !hasEditableStyle(*editableNode))
+        return;
+
+    if (!isSpellCheckingEnabledFor(editableNode))
+        return;
+
+    TextCheckingParagraph fullParagraphToCheck(expandRangeToSentenceBoundary(range));
+    chunkAndMarkAllMisspellingsAndBadGrammar(fullParagraphToCheck);
 }
 
 void SpellChecker::markMisspellingsAfterLineBreak(const VisibleSelection& wordSelection)
 {
     if (!isContinuousSpellCheckingEnabled())
         return;
 
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterLineBreak");
 
-    VisibleSelection wholeParagraph(
-        startOfParagraph(wordSelection.visibleStart()),
-        endOfParagraph(wordSelection.visibleEnd()));
-
-    markAllMisspellingsAndBadGrammar(wordSelection, wholeParagraph);
+    markMisspellingsAndBadGrammar(wordSelection);
 }
 
 void SpellChecker::markMisspellingsAfterTypingToWord(const VisiblePosition &wordStart, const VisibleSelection& selectionAfterTyping)
 {
     if (!isContinuousSpellCheckingEnabled())
         return;
 
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterTypingToWord");
 
     VisibleSelection adjacentWords = VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary));
-    VisibleSelection selectedSentence = VisibleSelection(startOfSentence(wordStart), endOfSentence(wordStart));
-    markAllMisspellingsAndBadGrammar(adjacentWords, selectedSentence);
+    markMisspellingsAndBadGrammar(adjacentWords);
 }
 
 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::markAllMisspellingsAndBadGrammar(const VisibleSelection& spellingSelection, const VisibleSelection& grammarSelection)
-{
-    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;
-
-    TextCheckingParagraph fullParagraphToCheck(grammarRange);
-    chunkAndMarkAllMisspellingsAndBadGrammar(fullParagraphToCheck);
-}
-
-static EphemeralRange expandEndToSentenceBoundary(const EphemeralRange& range)
-{
-    DCHECK(range.isNotNull());
-    const VisiblePosition& visibleEnd = createVisiblePosition(range.endPosition());
-    DCHECK(visibleEnd.isNotNull());
-    const Position& sentenceEnd = endOfSentence(visibleEnd).deepEquivalent();
-    return EphemeralRange(range.startPosition(), sentenceEnd.isNotNull() ? sentenceEnd : range.endPosition());
-}
-
-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)
 {
     TRACE_EVENT0("blink", "SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar");
     if (!node)
         return;
     EphemeralRange paragraphRange(Position::firstPositionInNode(node), Position::lastPositionInNode(node));
     TextCheckingParagraph textToCheck(insertedRange, paragraphRange);
     chunkAndMarkAllMisspellingsAndBadGrammar(textToCheck);
 }
 
@@ skipping 328 matching lines @@
 {
     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;
-    VisibleSelection selectedSentence = VisibleSelection(startOfSentence(oldStart), endOfSentence(oldStart));
-    markAllMisspellingsAndBadGrammar(oldAdjacentWords, selectedSentence);
+    markMisspellingsAndBadGrammar(oldAdjacentWords);
 }
 
 static Node* findFirstMarkable(Node* node)
 {
     while (node) {
         if (!node->layoutObject())
             return 0;
         if (node->layoutObject()->isText())
             return node;
         if (node->layoutObject()->isTextControl())
@@ skipping 54 matching lines @@
     visitor->trace(m_frame);
     visitor->trace(m_spellCheckRequester);
 }
 
 void SpellChecker::prepareForLeakDetection()
 {
     m_spellCheckRequester->prepareForLeakDetection();
 }
 
 } // namespace blink