Cleanup overloads of isSpellCheckingEnabledFor

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 58 matching lines @@
 {
     HTMLTextFormControlElement* textControl = enclosingTextFormControl(selection.start());
     return isHTMLTextAreaElement(textControl);
 }
 
 bool isSelectionInTextFormControl(const VisibleSelection& selection)
 {
     return !!enclosingTextFormControl(selection.start());
 }
 
+static bool isSpellCheckingEnabledFor(const VisibleSelection& selection)
+{
+    if (selection.isNone())
+        return false;
+    // TODO(tkent): The following password type check should be done in
+    // HTMLElement::spellcheck(). crbug.com/371567
+    if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(selection.start())) {
+        if (isHTMLInputElement(textControl) && toHTMLInputElement(textControl)->type() == InputTypeNames::password)
+            return false;
+    }
+    if (HTMLElement* element = Traversal<HTMLElement>::firstAncestorOrSelf(*selection.start().anchorNode())) {
+        if (element->isSpellCheckingEnabled())
+            return true;
+    }
+    return false;
+}
+
 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());
@@ skipping 202 matching lines @@
     spellCheckerClient().showSpellingUI(true);
 }
 
 void SpellChecker::clearMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
 {
     removeMarkers(movingSelection, DocumentMarker::MisspellingMarkers());
 }
 
 void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection& selection)
 {
-    if (!isSpellCheckingEnabled())
+    if (!isSpellCheckingEnabled() || !isSpellCheckingEnabledFor(selection))
         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;
-
     chunkAndMarkAllMisspellingsAndBadGrammar(range);
 }
 
 void SpellChecker::markMisspellingsAfterApplyingCommand(const CompositeEditCommand& cmd)
 {
     if (!isSpellCheckingEnabled())
         return;
     if (!isSpellCheckingEnabledFor(cmd.endingSelection()))
         return;
 
@@ skipping 53 matching lines @@
 }
 
 void SpellChecker::markMisspellingsAfterTypingToWord(const VisiblePosition &wordStart)
 {
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterTypingToWord");
 
     VisibleSelection adjacentWords = VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary));
     markMisspellingsAndBadGrammar(adjacentWords);
 }
 
-bool SpellChecker::isSpellCheckingEnabledFor(const Node* node) const
+bool SpellChecker::isSpellCheckingEnabledInFocusedNode() const
 {
-    if (!node)
+    Node* focusedNode = frame().selection().start().anchorNode();
+    if (!focusedNode)
         return false;
-    const Element* focusedElement = node->isElementNode() ? toElement(node) : node->parentElement();
+    const Element* focusedElement = focusedNode->isElementNode() ? toElement(focusedNode) : focusedNode->parentElement();
     if (!focusedElement)
         return false;
     return focusedElement->isSpellCheckingEnabled();
 }
 
-bool SpellChecker::isSpellCheckingEnabledInFocusedNode() const
-{
-    return isSpellCheckingEnabledFor(frame().selection().start().anchorNode());
-}
-
-bool SpellChecker::isSpellCheckingEnabledFor(const VisibleSelection& selection)
-{
-    if (selection.isNone())
-        return false;
-    // TODO(tkent): The following password type check should be done in
-    // HTMLElement::spellcheck(). crbug.com/371567
-    if (HTMLTextFormControlElement* textControl = enclosingTextFormControl(selection.start())) {
-        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::markMisspellingsAfterReplaceSelectionCommand(const ReplaceSelectionCommand& cmd)
 {
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterReplaceSelectionCommand");
 
     chunkAndMarkAllMisspellingsAndBadGrammar(cmd.insertedRange());
 }
 
 void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(const EphemeralRange& range)
 {
     if (range.isNull())
@@ skipping 392 matching lines @@
     frame().document()->markers().removeMarkers(range, markerTypes);
 }
 
 void SpellChecker::cancelCheck()
 {
     m_spellCheckRequester->cancelCheck();
 }
 
 void SpellChecker::requestTextChecking(const Element& element)
 {
-    if (!isSpellCheckingEnabledFor(&element))
+    if (!element.isSpellCheckingEnabled())
         return;
     const EphemeralRange rangeToCheck = EphemeralRange::rangeOfContents(element);
     m_spellCheckRequester->requestCheckingFor(SpellCheckRequest::create(TextCheckingProcessBatch, rangeToCheck));
 }
 
 DEFINE_TRACE(SpellChecker)
 {
     visitor->trace(m_frame);
     visitor->trace(m_spellCheckRequester);
 }
@@ skipping 103 matching lines @@
         VisiblePosition newParagraphStart = startOfNextParagraph(createVisiblePosition(paragraphEnd));
         paragraphStart = newParagraphStart.toParentAnchoredPosition();
         paragraphEnd = endOfParagraph(newParagraphStart).toParentAnchoredPosition();
         firstIteration = false;
         totalLengthProcessed += currentLength;
     }
     return std::make_pair(firstFoundItem, firstFoundOffset);
 }
 
 } // namespace blink