[MarkersIntersectingRange #3] Optimize SpellChecker::GetSpellCheckMarkerUnderSelection()

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 857 matching lines @@
 }
 
 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);

[rlanday, 2017/06/22 04:05:13]

I think I'm probably going to get rid of this and only do this check in
TextSuggestionController (once in HandlePotentialMisspelledWordTap() and once in
the replace method I'm going to implement instead of calling the one in
SpellChecker)

 
-  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));
-    }
-  }
+  const Vector<std::pair<Node*, DocumentMarker*>>& node_marker_pairs =
+      GetFrame().GetDocument()->Markers().MarkersIntersectingRange(
+          range_to_check, DocumentMarker::MisspellingMarkers());
 
   // No marker found
-  return Optional<std::pair<Node*, SpellCheckMarker*>>();
+  if (node_marker_pairs.IsEmpty())
+    return Optional<std::pair<Node*, SpellCheckMarker*>>();
+
+  return std::make_pair(node_marker_pairs.front().first,
+                        ToSpellCheckMarker(node_marker_pairs.front().second));
 }
 
 void SpellChecker::ReplaceMisspelledRange(const String& text) {
   const Optional<std::pair<Node*, SpellCheckMarker*>>& node_and_marker =
       GetSpellCheckMarkerTouchingSelection();
   if (!node_and_marker)
     return;
 
   Node* const container_node = node_and_marker.value().first;
   const SpellCheckMarker* const marker = node_and_marker.value().second;
@@ skipping 386 matching lines @@
       if (!input.IsFocusedElementInDocument())
         return false;
     }
   }
   HTMLElement* element =
       Traversal<HTMLElement>::FirstAncestorOrSelf(*position.AnchorNode());
   return element && element->IsSpellCheckingEnabled();
 }
 
 }  // namespace blink