Make SpellChecker::respondToChangedSelection() to take Position instead of VisibleSelection

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 41 matching lines @@
 #include "core/page/SpellCheckerClient.h"
 #include "platform/text/TextBreakIterator.h"
 #include "platform/text/TextCheckerClient.h"
 
 namespace blink {
 
 using namespace HTMLNames;
 
 namespace {
 
-bool isSelectionInTextField(const VisibleSelection& selection) {
+bool isPositionInTextField(const Position& selectionStart) {
   HTMLTextFormControlElement* textControl =
-      enclosingTextFormControl(selection.start());
+      enclosingTextFormControl(selectionStart);
   return isHTMLInputElement(textControl) &&
          toHTMLInputElement(textControl)->isTextField();
 }
 
-bool isSelectionInTextArea(const VisibleSelection& selection) {
-  HTMLTextFormControlElement* textControl =
-      enclosingTextFormControl(selection.start());
+bool isPositionInTextArea(const Position& position) {
+  HTMLTextFormControlElement* textControl = enclosingTextFormControl(position);
   return isHTMLTextAreaElement(textControl);
 }
 
 bool isSelectionInTextFormControl(const VisibleSelection& selection) {
   return !!enclosingTextFormControl(selection.start());
 }
 
-static bool isSpellCheckingEnabledFor(const VisibleSelection& selection) {
-  if (selection.isNone())
+static bool isSpellCheckingEnabledFor(const Position& position) {
+  if (position.isNull())
     return false;
   // TODO(tkent): The following password type check should be done in
   // HTMLElement::spellcheck(). crbug.com/371567
   if (HTMLTextFormControlElement* textControl =
-          enclosingTextFormControl(selection.start())) {
+          enclosingTextFormControl(position)) {
     if (isHTMLInputElement(textControl) &&
         toHTMLInputElement(textControl)->type() == InputTypeNames::password)
       return false;
   }
-  if (HTMLElement* element = Traversal<HTMLElement>::firstAncestorOrSelf(
-          *selection.start().anchorNode())) {
+  if (HTMLElement* element =
+          Traversal<HTMLElement>::firstAncestorOrSelf(*position.anchorNode())) {
     if (element->isSpellCheckingEnabled())
       return true;
   }
   return false;
 }
 
+static bool isSpellCheckingEnabledFor(const VisibleSelection& selection) {
+  if (selection.isNone())
+    return false;
+  return isSpellCheckingEnabledFor(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.endPosition()| is possible,
   // which would trigger a DCHECK in EphemeralRange's constructor if we return
   // it directly. However, this shouldn't happen and needs to be fixed.
   return EphemeralRange(
@@ skipping 686 matching lines @@
   frame().selection().setSelection(createVisibleSelection(markerRange),
                                    CharacterGranularity);
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   frame().editor().replaceSelectionWithText(text, false, false);
 }
 
-static bool shouldCheckOldSelection(const VisibleSelection& oldSelection) {
-  if (!oldSelection.start().isConnected())
+static bool shouldCheckOldSelection(const Position& oldSelectionStart) {
+  if (!oldSelectionStart.isConnected())
     return false;
-  if (isSelectionInTextField(oldSelection))
+  if (isPositionInTextField(oldSelectionStart))
     return false;
-  if (isSelectionInTextArea(oldSelection))
+  if (isPositionInTextArea(oldSelectionStart))
     return true;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // In the long term we should use idle time spell checker to prevent
   // synchronous layout caused by spell checking (see crbug.com/517298).
-  oldSelection.start()
-      .document()
-      ->updateStyleAndLayoutIgnorePendingStylesheets();
+  oldSelectionStart.document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
-  return oldSelection.isContentEditable();
+  return isEditablePosition(oldSelectionStart);
 }
 
 void SpellChecker::respondToChangedSelection(
-    const VisibleSelection& oldSelection,
+    const Position& oldSelectionStart,
     FrameSelection::SetSelectionOptions options) {
   TRACE_EVENT0("blink", "SpellChecker::respondToChangedSelection");
-  if (!isSpellCheckingEnabledFor(oldSelection))
+  if (!isSpellCheckingEnabledFor(oldSelectionStart))
     return;
 
   // 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))
+  if (!shouldCheckOldSelection(oldSelectionStart))
     return;
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // In the long term we should use idle time spell checker to prevent
   // synchronous layout caused by spell checking (see crbug.com/517298).
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       frame().document()->lifecycle());
@@ skipping 12 matching lines @@
           createVisibleSelection(startOfWord(newStart, LeftWordIfOnBoundary),
                                  endOfWord(newStart, RightWordIfOnBoundary));
     }
   }
 
   // When typing we check spelling elsewhere, so don't redo it here.
   // If this is a change in selection resulting from a delete operation,
   // oldSelection may no longer be in the document.
   // FIXME(http://crbug.com/382809): if oldSelection is on a textarea
   // element, we cause synchronous layout.
-  spellCheckOldSelection(oldSelection, newAdjacentWords);
+  spellCheckOldSelection(oldSelectionStart, newAdjacentWords);
 }
 
 void SpellChecker::removeSpellingMarkers() {
   frame().document()->markers().removeMarkers(
       DocumentMarker::MisspellingMarkers());
 }
 
 void SpellChecker::removeSpellingMarkersUnderWords(
     const Vector<String>& words) {
   MarkerRemoverPredicate removerPredicate(words);
 
   DocumentMarkerController& markerController = frame().document()->markers();
   markerController.removeMarkers(removerPredicate);
   markerController.repaintMarkers();
 }
 
 void SpellChecker::spellCheckAfterBlur() {
   if (!frame().selection().selection().isContentEditable())
     return;
 
-  if (isSelectionInTextField(frame().selection().selection())) {
+  if (isPositionInTextField(frame().selection().selection().start())) {
     // textFieldDidEndEditing() and textFieldDidBeginEditing() handle this.
     return;
   }
 
   // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
   // needs to be audited.  See http://crbug.com/590369 for more details.
   // In the long term we should use idle time spell checker to prevent
   // synchronous layout caused by spell checking (see crbug.com/517298).
   frame().document()->updateStyleAndLayoutIgnorePendingStylesheets();
 
   DocumentLifecycle::DisallowTransitionScope disallowTransition(
       frame().document()->lifecycle());
 
   VisibleSelection empty;
-  spellCheckOldSelection(frame().selection().selection(), empty);
+  spellCheckOldSelection(frame().selection().selection().start(), empty);
 }
 
 void SpellChecker::spellCheckOldSelection(
-    const VisibleSelection& oldSelection,
+    const Position& oldSelectionStart,
     const VisibleSelection& newAdjacentWords) {
   if (!isSpellCheckingEnabled())
     return;
 
   TRACE_EVENT0("blink", "SpellChecker::spellCheckOldSelection");
 
-  VisiblePosition oldStart(oldSelection.visibleStart());
+  VisiblePosition oldStart = createVisiblePosition(oldSelectionStart);
   VisibleSelection oldAdjacentWords =
       createVisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary),
                              endOfWord(oldStart, RightWordIfOnBoundary));
   if (oldAdjacentWords == newAdjacentWords)
     return;
   markMisspellingsAndBadGrammar(oldAdjacentWords);
 }
 
 static Node* findFirstMarkable(Node* node) {
   while (node) {
@@ skipping 188 matching lines @@
         startOfNextParagraph(createVisiblePosition(paragraphEnd));
     paragraphStart = newParagraphStart.toParentAnchoredPosition();
     paragraphEnd = endOfParagraph(newParagraphStart).toParentAnchoredPosition();
     firstIteration = false;
     totalLengthProcessed += currentLength;
   }
   return std::make_pair(firstFoundItem, firstFoundOffset);
 }
 
 }  // namespace blink