Add 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 25 matching lines @@
 #include "core/dom/Range.h"
 #include "core/editing/EditingUtilities.h"
 #include "core/editing/Editor.h"
 #include "core/editing/EphemeralRange.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/commands/CompositeEditCommand.h"
 #include "core/editing/commands/ReplaceSelectionCommand.h"
 #include "core/editing/commands/TypingCommand.h"
 #include "core/editing/iterators/CharacterIterator.h"
 #include "core/editing/markers/DocumentMarkerController.h"
+#include "core/editing/markers/SpellCheckMarker.h"
 #include "core/editing/spellcheck/IdleSpellCheckCallback.h"
 #include "core/editing/spellcheck/SpellCheckRequester.h"
 #include "core/editing/spellcheck/SpellCheckerClient.h"
 #include "core/editing/spellcheck/TextCheckingParagraph.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/layout/LayoutTextControl.h"
 #include "core/loader/EmptyClients.h"
 #include "core/page/Page.h"
@@ skipping 550 matching lines @@
   // TODO(xiaochengh): The following comment does not match the current behavior
   // and should be rewritten.
   // Expand the range to encompass entire paragraphs, since text checking needs
   // that much context.
   int ambiguous_boundary_offset = -1;
 
   if (GetFrame().Selection().ComputeVisibleSelectionInDOMTree().IsCaret()) {
     // TODO(xiaochengh): The following comment does not match the current
     // behavior and should be rewritten.
     // Attempt to save the caret position so we can restore it later if needed
-    const Position& caret_position =
+    const Position& caret_positionition =

[Xiaocheng, 2017/06/09 04:17:26]

Irrelevant change.

         GetFrame().Selection().ComputeVisibleSelectionInDOMTree().End();
     const Position& paragraph_start = checking_range.StartPosition();
     const int selection_offset =
-        paragraph_start < caret_position
-            ? TextIterator::RangeLength(paragraph_start, caret_position)
+        paragraph_start < caret_positionition
+            ? TextIterator::RangeLength(paragraph_start, caret_positionition)
             : 0;
     if (selection_offset > 0 &&
         static_cast<unsigned>(selection_offset) <=
             paragraph.GetText().length() &&
         IsAmbiguousBoundaryCharacter(
             paragraph.TextCharAt(selection_offset - 1))) {
       ambiguous_boundary_offset = selection_offset - 1;
     }
   }
 
@@ skipping 172 matching lines @@
   DocumentMarker::MarkerTypes marker_types(DocumentMarker::kSpelling);
   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);
     }
   }
 }
 
+namespace {

[Xiaocheng, 2017/06/09 04:17:26]

We already have an anonymous namespace at the beginning of this file. No need to
create a new one.

+
+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
+  const VisiblePosition& caret_position = selection.VisibleStart();

[yosin_UTC9, 2017/06/09 03:28:15]

Could you add an example, your provided in reply?

+
+  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
+
+Optional<std::pair<Node*, SpellCheckMarker*>>
+SpellChecker::GetSpellCheckMarkerTouchingSelection() {
+  const VisibleSelection& selection =
+      GetFrame().Selection().ComputeVisibleSelectionInDOMTree();
+  if (selection.IsNone())
+    return Optional<std::pair<Node*, SpellCheckMarker*>>();
+
+  const EphemeralRange& range_to_check =
+      ExpandSelectionRangeIfNecessary(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();
+
+  for (Node& node : range_to_check.Nodes()) {
+    const DocumentMarkerVector& markers_in_node =
+        GetFrame().GetDocument()->Markers().MarkersFor(
+            &node, DocumentMarker::MisspellingMarkers());
+    for (DocumentMarker* marker : markers_in_node) {
+      if (node == start_container && marker->EndOffset() <= start_offset)
+        continue;
+      if (node == end_container && marker->StartOffset() >= end_offset)
+        continue;
+
+      return std::make_pair(&node, &ToSpellCheckMarker(*marker));
+    }
+  }
+
+  // No marker found
+  return Optional<std::pair<Node*, SpellCheckMarker*>>();
+}
+
 void SpellChecker::ReplaceMisspelledRange(const String& text) {
-  EphemeralRange caret_range = GetFrame()
-                                   .Selection()
-                                   .ComputeVisibleSelectionInDOMTree()
-                                   .ToNormalizedEphemeralRange();
-  if (caret_range.IsNull())
+  const Optional<std::pair<Node*, SpellCheckMarker*>>& node_and_marker =
+      GetSpellCheckMarkerTouchingSelection();
+  if (!node_and_marker)
     return;
 
-  Node* const caret_start_container =
-      caret_range.StartPosition().ComputeContainerNode();
-  Node* const caret_end_container =
-      caret_range.EndPosition().ComputeContainerNode();
-
-  // We don't currently support the case where a misspelling spans multiple
-  // nodes
-  if (caret_start_container != caret_end_container)
-    return;
-
-  const unsigned caret_start_offset =
-      caret_range.StartPosition().ComputeOffsetInContainerNode();
-  const unsigned caret_end_offset =
-      caret_range.EndPosition().ComputeOffsetInContainerNode();
-
-  const DocumentMarkerVector& markers_in_node =
-      GetFrame().GetDocument()->Markers().MarkersFor(
-          caret_start_container, DocumentMarker::MisspellingMarkers());
-
-  const auto marker_it =
-      std::find_if(markers_in_node.begin(), markers_in_node.end(),
-                   [=](const DocumentMarker* marker) {
-                     return marker->StartOffset() < caret_end_offset &&
-                            marker->EndOffset() > caret_start_offset;
-                   });
-  if (marker_it == markers_in_node.end())
-    return;
-
-  const DocumentMarker* found_marker = *marker_it;
-  EphemeralRange marker_range = EphemeralRange(
-      Position(caret_start_container, found_marker->StartOffset()),
-      Position(caret_start_container, found_marker->EndOffset()));
-  if (marker_range.IsNull())
-    return;
+  Node* const container_node = node_and_marker.value().first;
+  const SpellCheckMarker* const marker = node_and_marker.value().second;
 
   GetFrame().Selection().SetSelection(
-      SelectionInDOMTree::Builder().SetBaseAndExtent(marker_range).Build());
+      SelectionInDOMTree::Builder()
+          .Collapse(Position(container_node, marker->StartOffset()))
+          .Extend(Position(container_node, marker->EndOffset()))
+          .Build());
 
   Document& current_document = *GetFrame().GetDocument();
 
   // Dispatch 'beforeinput'.
   Element* const target = GetFrame().GetEditor().FindEventTargetFromSelection();
   DataTransfer* const data_transfer = DataTransfer::Create(
       DataTransfer::DataTransferType::kInsertReplacementText,
       DataTransferAccessPolicy::kDataTransferReadable,
       DataObject::CreateFromString(text));
 
@@ skipping 370 matching lines @@
       if (!input.IsFocusedElementInDocument())
         return false;
     }
   }
   HTMLElement* element =
       Traversal<HTMLElement>::FirstAncestorOrSelf(*position.AnchorNode());
   return element && element->IsSpellCheckingEnabled();
 }
 
 }  // namespace blink