Remove dead code in spell 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 499 matching lines @@
     if (fullParagraphToCheck.isEmpty())
         return;
     const EphemeralRange& paragraphRange = fullParagraphToCheck.paragraphRange();
 
     // Since the text may be quite big chunk it up and adjust to the sentence boundary.
     const int kChunkSize = 16 * 1024;
 
     // Check the full paragraph instead if the paragraph is short, which saves
     // the cost on sentence boundary finding.
     if (fullParagraphToCheck.rangeLength() <= kChunkSize) {
-        SpellCheckRequest* request = SpellCheckRequest::create(TextCheckingTypeSpelling | TextCheckingTypeGrammar, TextCheckingProcessBatch, paragraphRange, paragraphRange, 0);
+        SpellCheckRequest* request = SpellCheckRequest::create(TextCheckingProcessBatch, paragraphRange, paragraphRange, 0);
         if (request)
             m_spellCheckRequester->requestCheckingFor(request);
         return;
     }
 
     CharacterIterator checkRangeIterator(fullParagraphToCheck.checkingRange(), TextIteratorEmitsObjectReplacementCharacter);
     for (int requestNum = 0; !checkRangeIterator.atEnd(); requestNum++) {
         EphemeralRange chunkRange = checkRangeIterator.calculateCharacterSubrange(0, kChunkSize);
         EphemeralRange checkRange = requestNum ? expandEndToSentenceBoundary(chunkRange) : expandRangeToSentenceBoundary(chunkRange);
 
-        SpellCheckRequest* request = SpellCheckRequest::create(TextCheckingTypeSpelling | TextCheckingTypeGrammar, TextCheckingProcessBatch, checkRange, paragraphRange, requestNum);
+        SpellCheckRequest* request = SpellCheckRequest::create(TextCheckingProcessBatch, checkRange, paragraphRange, requestNum);
         if (request)
             m_spellCheckRequester->requestCheckingFor(request);
 
         if (!checkRangeIterator.atEnd()) {
             checkRangeIterator.advance(1);
             // The layout should be already update due to the initialization of checkRangeIterator,
             // so comparePositions can be directly called.
             if (comparePositions(chunkRange.endPosition(), checkRange.endPosition()) < 0)
                 checkRangeIterator.advance(TextIterator::rangeLength(chunkRange.endPosition(), checkRange.endPosition()));
         }
     }
 }
 
 void SpellChecker::markAndReplaceFor(SpellCheckRequest* request, const Vector<TextCheckingResult>& results)
 {
     TRACE_EVENT0("blink", "SpellChecker::markAndReplaceFor");
     DCHECK(request);
     if (!frame().selection().isAvailable()) {
         // "editing/spelling/spellcheck-async-remove-frame.html" reaches here.
         return;
     }
     if (!request->isValid())
         return;
     if (request->rootEditableElement()->document() != frame().selection().document()) {
         // we ignore |request| made for another document.
         // "editing/spelling/spellcheck-sequencenum.html" and others reach here.
         return;
     }
 
-    TextCheckingTypeMask textCheckingOptions = request->data().mask();
     TextCheckingParagraph paragraph(request->checkingRange(), request->paragraphRange());
 
-    bool shouldMarkSpelling = textCheckingOptions & TextCheckingTypeSpelling;
-    bool shouldMarkGrammar = textCheckingOptions & TextCheckingTypeGrammar;
-
     // Expand the range to encompass entire paragraphs, since text checking needs that much context.
     int selectionOffset = 0;
     int ambiguousBoundaryOffset = -1;
     bool selectionChanged = false;
     bool restoreSelectionAfterChange = false;
     bool adjustSelectionForParagraphBoundaries = false;
 
-    if (shouldMarkSpelling) {
-        if (frame().selection().isCaret()) {
-            // Attempt to save the caret position so we can restore it later if needed
-            Position caretPosition = frame().selection().end();
-            selectionOffset = paragraph.offsetTo(caretPosition);
-            restoreSelectionAfterChange = true;
-            if (selectionOffset > 0 && (static_cast<unsigned>(selectionOffset) > paragraph.text().length() || paragraph.textCharAt(selectionOffset - 1) == newlineCharacter))
-                adjustSelectionForParagraphBoundaries = true;
-            if (selectionOffset > 0 && static_cast<unsigned>(selectionOffset) <= paragraph.text().length() && isAmbiguousBoundaryCharacter(paragraph.textCharAt(selectionOffset - 1)))
-                ambiguousBoundaryOffset = selectionOffset - 1;
-        }
+    if (frame().selection().isCaret()) {
+        // Attempt to save the caret position so we can restore it later if needed
+        Position caretPosition = frame().selection().end();
+        selectionOffset = paragraph.offsetTo(caretPosition);
+        restoreSelectionAfterChange = true;
+        if (selectionOffset > 0 && (static_cast<unsigned>(selectionOffset) > paragraph.text().length() || paragraph.textCharAt(selectionOffset - 1) == newlineCharacter))
+            adjustSelectionForParagraphBoundaries = true;
+        if (selectionOffset > 0 && static_cast<unsigned>(selectionOffset) <= paragraph.text().length() && isAmbiguousBoundaryCharacter(paragraph.textCharAt(selectionOffset - 1)))
+            ambiguousBoundaryOffset = selectionOffset - 1;
     }
 
     // TODO(dglazkov): The use of updateStyleAndLayoutIgnorePendingStylesheets needs to be audited.
     // see http://crbug.com/590369 for more details.
     frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
     {
         DocumentLifecycle::DisallowTransitionScope(frame().document()->lifecycle());
 
         for (unsigned i = 0; i < results.size(); i++) {
             int spellingRangeEndOffset = paragraph.checkingEnd();
             const TextCheckingResult* result = &results[i];
             int resultLocation = result->location + paragraph.checkingStart();
             int resultLength = result->length;
             bool resultEndsAtAmbiguousBoundary = ambiguousBoundaryOffset >= 0 && resultLocation + resultLength == ambiguousBoundaryOffset;
 
             // Only mark misspelling if:
-            // 1. Current text checking isn't done for autocorrection, in which case shouldMarkSpelling is false.
+            // 1. Current text checking isn't done for autocorrection.
             // 2. Result falls within spellingRange.
             // 3. The word in question doesn't end at an ambiguous boundary. For instance, we would not mark
             //    "wouldn'" as misspelled right after apostrophe is typed.
-            if (shouldMarkSpelling && result->decoration == TextDecorationTypeSpelling && resultLocation >= paragraph.checkingStart() && resultLocation + resultLength <= spellingRangeEndOffset && !resultEndsAtAmbiguousBoundary) {
+            if (result->decoration == TextDecorationTypeSpelling && resultLocation >= paragraph.checkingStart() && resultLocation + resultLength <= spellingRangeEndOffset && !resultEndsAtAmbiguousBoundary) {
                 DCHECK_GT(resultLength, 0);
                 DCHECK_GE(resultLocation, 0);
                 const EphemeralRange misspellingRange = calculateCharacterSubrange(paragraph.paragraphRange(), resultLocation, resultLength);
                 frame().document()->markers().addMarker(misspellingRange.startPosition(), misspellingRange.endPosition(), DocumentMarker::Spelling, result->replacement, result->hash);
-            } else if (shouldMarkGrammar && result->decoration == TextDecorationTypeGrammar && paragraph.checkingRangeCovers(resultLocation, resultLength)) {
+            } else if (result->decoration == TextDecorationTypeGrammar && paragraph.checkingRangeCovers(resultLocation, resultLength)) {
                 DCHECK_GT(resultLength, 0);
                 DCHECK_GE(resultLocation, 0);
                 for (unsigned j = 0; j < result->details.size(); j++) {
                     const GrammarDetail* detail = &result->details[j];
                     DCHECK_GT(detail->length, 0);
                     DCHECK_GE(detail->location, 0);
                     if (paragraph.checkingRangeCovers(resultLocation + detail->location, detail->length)) {
                         const EphemeralRange badGrammarRange = calculateCharacterSubrange(paragraph.paragraphRange(), resultLocation + detail->location, detail->length);
                         frame().document()->markers().addMarker(badGrammarRange.startPosition(), badGrammarRange.endPosition(), DocumentMarker::Grammar, detail->userDescription, result->hash);
                     }
@@ skipping 304 matching lines @@
 }
 
 void SpellChecker::cancelCheck()
 {
     m_spellCheckRequester->cancelCheck();
 }
 
 void SpellChecker::requestTextChecking(const Element& element)
 {
     const EphemeralRange rangeToCheck = EphemeralRange::rangeOfContents(element);
-    m_spellCheckRequester->requestCheckingFor(SpellCheckRequest::create(TextCheckingTypeSpelling | TextCheckingTypeGrammar, TextCheckingProcessBatch, rangeToCheck, rangeToCheck));
+    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