[MarkersInter...Range #2-9] Change behavior of SpellChecker::GetSpellCheckMarkerTouchingSelection()

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 77 matching lines @@
   // TODO(yosin): We should fix |startOfWord()| and |endOfWord()| not to return
   // null position.
   const VisiblePosition& start = StartOfWord(position, kLeftWordIfOnBoundary);
   const VisiblePosition& end = EndOfWord(position, kRightWordIfOnBoundary);
   return SelectionInDOMTree::Builder()
       .SetBaseAndExtentDeprecated(start.DeepEquivalent(), end.DeepEquivalent())
       .SetAffinity(start.Affinity())
       .Build();
 }
 
-EphemeralRange ExpandSelectionRangeIfNecessary(
-    const VisibleSelection& selection) {
-  DCHECK(!selection.IsNone());
-
-  // If some text is actually selected, we can use the selection range as-is to
-  // check for a marker. If no text is selected (we just have a caret
-  // somewhere), we need to expand one character on either side so we can find
-  // a spelling marker immediately before or after the caret.
-
-  // (The spelling markers on these words may be anchored to a different node
-  // than the collapsed selection's Position is, but once we expand the
-  // selection, if we're next to a marker, either the start or end point should
-  // now be anchored relative to the same text node as that marker.)
-
-  // Some text is actually selected
-  if (selection.IsRange())
-    return EphemeralRange(selection.Start(), selection.End());
-
-  // No text is actually selected, need to expand the selection range. This is
-  // to make sure we can find a marker touching the caret. E.g. if we have:
-  // <span>word1 <b>word2</b></span>
-  // with a caret selection immediately before "word2", there's one text node
-  // immediately before the caret ("word1 ") and one immediately after
-  // ("word2"). Expanding the selection by one character on either side ensures
-  // we get a range that intersects both neighboring text nodes (if they exist).
-  const VisiblePosition& caret_position = selection.VisibleStart();
-
-  const Position& previous_position =
-      PreviousPositionOf(caret_position).DeepEquivalent();
-
-  const Position& next_position =
-      NextPositionOf(caret_position).DeepEquivalent();
-
-  return EphemeralRange(
-      previous_position.IsNull() ? caret_position.DeepEquivalent()
-                                 : previous_position,
-      next_position.IsNull() ? caret_position.DeepEquivalent() : next_position);
-}
-
 }  // namespace
 
 SpellChecker* SpellChecker::Create(LocalFrame& frame) {
   return new SpellChecker(frame);
 }
 
 static SpellCheckerClient& GetEmptySpellCheckerClient() {
   DEFINE_STATIC_LOCAL(EmptySpellCheckerClient, client, ());
   return client;
 }
@@ skipping 715 matching lines @@
   marker_types.Add(DocumentMarker::kGrammar);
   for (Node& node : NodeTraversal::InclusiveDescendantsOf(element)) {
     if (elements_type == ElementsType::kAll || !HasEditableStyle(node)) {
       GetFrame().GetDocument()->Markers().RemoveMarkersForNode(&node,
                                                                marker_types);
     }
   }
 }
 
 Optional<std::pair<Node*, SpellCheckMarker*>>
-SpellChecker::GetSpellCheckMarkerTouchingSelection() {
+SpellChecker::GetSpellCheckMarkerUnderSelection() {
   const VisibleSelection& selection =
       GetFrame().Selection().ComputeVisibleSelectionInDOMTree();
   if (selection.IsNone())
     return Optional<std::pair<Node*, SpellCheckMarker*>>();
 
-  const EphemeralRange& range_to_check =
-      ExpandSelectionRangeIfNecessary(selection);
+  const EphemeralRange& range_to_check = FirstEphemeralRangeOf(selection);
 
   Node* const start_container =
       range_to_check.StartPosition().ComputeContainerNode();
   const unsigned start_offset =
       range_to_check.StartPosition().ComputeOffsetInContainerNode();
   Node* const end_container =
       range_to_check.EndPosition().ComputeContainerNode();
   const unsigned end_offset =
       range_to_check.EndPosition().ComputeOffsetInContainerNode();
 
@@ skipping 10 matching lines @@
       return std::make_pair(&node, &ToSpellCheckMarker(*marker));
     }
   }
 
   // No marker found
   return Optional<std::pair<Node*, SpellCheckMarker*>>();
 }
 
 void SpellChecker::ReplaceMisspelledRange(const String& text) {
   const Optional<std::pair<Node*, SpellCheckMarker*>>& node_and_marker =
-      GetSpellCheckMarkerTouchingSelection();
+      GetSpellCheckMarkerUnderSelection();
   if (!node_and_marker)
     return;
 
   Node* const container_node = node_and_marker.value().first;
   const SpellCheckMarker* const marker = node_and_marker.value().second;
 
   GetFrame().Selection().SetSelection(
       SelectionInDOMTree::Builder()
           .Collapse(Position(container_node, marker->StartOffset()))
           .Extend(Position(container_node, marker->EndOffset()))
@@ skipping 381 matching lines @@
       if (!input.IsFocusedElementInDocument())
         return false;
     }
   }
   HTMLElement* element =
       Traversal<HTMLElement>::FirstAncestorOrSelf(*position.AnchorNode());
   return element && element->IsSpellCheckingEnabled();
 }
 
 }  // namespace blink