Get rid of flat tree version of createVisibleSelection() taking two VisiblePosition

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 116 matching lines @@
   // TODO(xiaochengh): |sentenceStart > range.startPosition()| 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 expandEndToSentenceBoundary(EphemeralRange(
       sentenceStart.isNotNull() && sentenceStart < range.startPosition()
           ? sentenceStart
           : range.startPosition(),
       range.endPosition()));
 }
 
+SelectionInDOMTree selectWord(const VisiblePosition& position) {
+  // TODO(yosin): We should fix |startOfWord()| and |endOfWord()| not to return
+  // null position.
+  const VisiblePosition& start = startOfWord(position, LeftWordIfOnBoundary);
+  const VisiblePosition& end = endOfWord(position, RightWordIfOnBoundary);
+  return SelectionInDOMTree::Builder()
+      .setBaseAndExtentDeprecated(start.deepEquivalent(), end.deepEquivalent())
+      .setAffinity(start.affinity())
+      .build();
+}
+
 }  // namespace
 
 SpellChecker* SpellChecker::create(LocalFrame& frame) {
   return new SpellChecker(frame);
 }
 
 static SpellCheckerClient& emptySpellCheckerClient() {
   DEFINE_STATIC_LOCAL(EmptySpellCheckerClient, client, ());
   return client;
 }
@@ skipping 290 matching lines @@
   VisiblePosition start = createVisiblePosition(
       cmd.endingSelection().start(), cmd.endingSelection().affinity());
   VisiblePosition previous = previousPositionOf(start);
 
   VisiblePosition wordStartOfPrevious =
       startOfWord(previous, LeftWordIfOnBoundary);
 
   if (cmd.commandTypeOfOpenCommand() ==
       TypingCommand::InsertParagraphSeparator) {
     VisiblePosition nextWord = nextWordPosition(start);
-    VisibleSelection words =
-        createVisibleSelection(wordStartOfPrevious, endOfWord(nextWord));
+    // TODO(yosin): We should make |endOfWord()| not to return null position.
+    VisibleSelection words = createVisibleSelection(
+        SelectionInDOMTree::Builder()
+            .setBaseAndExtentDeprecated(wordStartOfPrevious.deepEquivalent(),
+                                        endOfWord(nextWord).deepEquivalent())
+            .setAffinity(wordStartOfPrevious.affinity())
+            .build());
     markMisspellingsAfterLineBreak(words);
     return;
   }
 
   if (previous.isNull())
     return;
   VisiblePosition currentWordStart = startOfWord(start, LeftWordIfOnBoundary);
   if (wordStartOfPrevious.deepEquivalent() == currentWordStart.deepEquivalent())
     return;
   markMisspellingsAfterTypingToWord(wordStartOfPrevious);
 }
 
 void SpellChecker::markMisspellingsAfterLineBreak(
     const VisibleSelection& wordSelection) {
   TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterLineBreak");
 
   markMisspellingsAndBadGrammar(wordSelection);
 }
 
 void SpellChecker::markMisspellingsAfterTypingToWord(
     const VisiblePosition& wordStart) {
   TRACE_EVENT0("blink", "SpellChecker::markMisspellingsAfterTypingToWord");
 
   VisibleSelection adjacentWords =
-      createVisibleSelection(startOfWord(wordStart, LeftWordIfOnBoundary),
-                             endOfWord(wordStart, RightWordIfOnBoundary));
+      createVisibleSelection(selectWord(wordStart));
   markMisspellingsAndBadGrammar(adjacentWords);
 }
 
 bool SpellChecker::isSpellCheckingEnabledInFocusedNode() const {
   Node* focusedNode = frame().selection().start().anchorNode();
   if (!focusedNode)
     return false;
   const Element* focusedElement = focusedNode->isElementNode()
                                       ? toElement(focusedNode)
                                       : focusedNode->parentElement();
@@ skipping 376 matching lines @@
 
   VisibleSelection newAdjacentWords;
   const VisibleSelection newSelection = frame().selection().selection();
   if (isSelectionInTextFormControl(newSelection)) {
     const Position newStart = newSelection.start();
     newAdjacentWords.setWithoutValidation(
         HTMLTextFormControlElement::startOfWord(newStart),
         HTMLTextFormControlElement::endOfWord(newStart));
   } else {
     if (newSelection.isContentEditable()) {
-      const VisiblePosition newStart(newSelection.visibleStart());
       newAdjacentWords =
-          createVisibleSelection(startOfWord(newStart, LeftWordIfOnBoundary),
-                                 endOfWord(newStart, RightWordIfOnBoundary));
+          createVisibleSelection(selectWord(newSelection.visibleStart()));
     }
   }
 
   // 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(oldSelectionStart, newAdjacentWords);
 }
@@ skipping 37 matching lines @@
 void SpellChecker::spellCheckOldSelection(
     const Position& oldSelectionStart,
     const VisibleSelection& newAdjacentWords) {
   if (!isSpellCheckingEnabled())
     return;
 
   TRACE_EVENT0("blink", "SpellChecker::spellCheckOldSelection");
 
   VisiblePosition oldStart = createVisiblePosition(oldSelectionStart);
   VisibleSelection oldAdjacentWords =
-      createVisibleSelection(startOfWord(oldStart, LeftWordIfOnBoundary),
-                             endOfWord(oldStart, RightWordIfOnBoundary));
+      createVisibleSelection(selectWord(oldStart));
   if (oldAdjacentWords == newAdjacentWords)
     return;
   markMisspellingsAndBadGrammar(oldAdjacentWords);
 }
 
 static Node* findFirstMarkable(Node* node) {
   while (node) {
     if (!node->layoutObject())
       return 0;
     if (node->layoutObject()->isText())
@@ skipping 185 matching lines @@
         startOfNextParagraph(createVisiblePosition(paragraphEnd));
     paragraphStart = newParagraphStart.toParentAnchoredPosition();
     paragraphEnd = endOfParagraph(newParagraphStart).toParentAnchoredPosition();
     firstIteration = false;
     totalLengthProcessed += currentLength;
   }
   return std::make_pair(firstFoundItem, firstFoundOffset);
 }
 
 }  // namespace blink