Rename "ContinuousSpellChecking" to "SpellChecking" in Blink

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 110 matching lines @@
 {
     return spellCheckerClient().textChecker();
 }
 
 SpellChecker::SpellChecker(LocalFrame& frame)
     : m_frame(&frame)
     , m_spellCheckRequester(SpellCheckRequester::create(frame))
 {
 }
 
-bool SpellChecker::isContinuousSpellCheckingEnabled() const
+bool SpellChecker::isSpellCheckingEnabled() const
 {
-    return spellCheckerClient().isContinuousSpellCheckingEnabled();
+    return spellCheckerClient().isSpellCheckingEnabled();
 }
 
-void SpellChecker::toggleContinuousSpellChecking()
+void SpellChecker::toggleSpellCheckingEnabled()
 {
-    spellCheckerClient().toggleContinuousSpellChecking();
-    if (isContinuousSpellCheckingEnabled())
+    spellCheckerClient().toggleSpellCheckingEnabled();
+    if (isSpellCheckingEnabled())
         return;
     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())
+    if (!isSpellCheckingEnabled())
         return;
 
     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);
@@ skipping 126 matching lines @@
     spellCheckerClient().showSpellingUI(true);
 }
 
 void SpellChecker::clearMisspellingsAndBadGrammar(const VisibleSelection &movingSelection)
 {
     removeMarkers(movingSelection, DocumentMarker::MisspellingMarkers());
 }
 
 void SpellChecker::markMisspellingsAndBadGrammar(const VisibleSelection& selection)
 {
-    if (!isContinuousSpellCheckingEnabled())
+    if (!isSpellCheckingEnabled())
         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())
+    if (!isSpellCheckingEnabled())
         return;
 
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterLineBreak");
 
     markMisspellingsAndBadGrammar(wordSelection);
 }
 
 void SpellChecker::markMisspellingsAfterTypingToWord(const VisiblePosition &wordStart, const VisibleSelection& selectionAfterTyping)
 {
-    if (!isContinuousSpellCheckingEnabled())
+    if (!isSpellCheckingEnabled())
         return;
 
     TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterTypingToWord");
 
     VisibleSelection adjacentWords = VisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary), endOfWord(wordStart, RightWordIfOnBoundary));
     markMisspellingsAndBadGrammar(adjacentWords);
 }
 
 bool SpellChecker::isSpellCheckingEnabledFor(Node* node) const
 {
@@ skipping 295 matching lines @@
     oldSelection.start().document()->updateStyleAndLayoutIgnorePendingStylesheets();
     return oldSelection.isContentEditable();
 }
 
 void SpellChecker::respondToChangedSelection(const VisibleSelection& oldSelection, FrameSelection::SetSelectionOptions options)
 {
     TRACE_EVENT0("blink", "SpellChecker::respondToChangedSelection");
     if (!isSpellCheckingEnabledFor(oldSelection))
         return;
 
-    // When continuous spell checking is off, existing markers disappear after the selection changes.
-    if (!isContinuousSpellCheckingEnabled()) {
+    // 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 42 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())
+    if (!isSpellCheckingEnabled())
         return;
 
     TRACE_EVENT0("blink", "SpellChecker::spellCheckOldSelection");
 
     VisiblePosition oldStart(oldSelection.visibleStart());
     VisibleSelection oldAdjacentWords = VisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary), endOfWord(oldStart, RightWordIfOnBoundary));
     if (oldAdjacentWords == newAdjacentWords)
         return;
     markMisspellingsAndBadGrammar(oldAdjacentWords);
 }
@@ skipping 169 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