[SelectMiss...Async #2] Change ContextMenuClient::SelectMisspellingAsync() to return pair of strings

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 820 matching lines @@
                                                                marker_types);
     }
   }
 }
 
 Optional<std::pair<Node*, SpellCheckMarker*>>
 SpellChecker::GetSpellCheckMarkerUnderSelection() {
   const VisibleSelection& selection =
       GetFrame().Selection().ComputeVisibleSelectionInDOMTree();
   if (selection.IsNone())
-    return Optional<std::pair<Node*, SpellCheckMarker*>>();
+    return {};
 
   // Caret and range selections always return valid normalized ranges.
   const EphemeralRange& selection_range = FirstEphemeralRangeOf(selection);
 
   Node* const selection_start_container =
       selection_range.StartPosition().ComputeContainerNode();
   Node* const selection_end_container =
       selection_range.EndPosition().ComputeContainerNode();
 
   // We don't currently support the case where a misspelling spans multiple
   // nodes. See crbug.com/720065
   if (selection_start_container != selection_end_container)
     return {};
 
   if (!selection_start_container->IsTextNode())
     return {};
 
   const unsigned selection_start_offset =
       selection_range.StartPosition().ComputeOffsetInContainerNode();
   const unsigned selection_end_offset =
       selection_range.EndPosition().ComputeOffsetInContainerNode();
 
   DocumentMarker* const marker =
       GetFrame().GetDocument()->Markers().FirstMarkerIntersectingOffsetRange(
           ToText(*selection_start_container), selection_start_offset,
           selection_end_offset, DocumentMarker::MisspellingMarkers());
   if (!marker)
-    return Optional<std::pair<Node*, SpellCheckMarker*>>();
+    return {};
 
   return std::make_pair(selection_start_container, ToSpellCheckMarker(marker));
 }
 
-String SpellChecker::SelectMisspellingAsync(String& description) {
+std::pair<String, String> SpellChecker::SelectMisspellingAsync() {
   VisibleSelection selection =
       GetFrame().Selection().ComputeVisibleSelectionInDOMTree();
   if (selection.IsNone())
-    return String();
+    return {};
 
   // Caret and range selections always return valid normalized ranges.
   const EphemeralRange& selection_range =
       selection.ToNormalizedEphemeralRange();
 
   Node* const selection_start_container =
       selection_range.StartPosition().ComputeContainerNode();
   Node* const selection_end_container =
       selection_range.EndPosition().ComputeContainerNode();
 
   // We don't currently support the case where a misspelling spans multiple
   // nodes. See crbug.com/720065
   if (selection_start_container != selection_end_container)
-    return String();
+    return {};
 
   const unsigned selection_start_offset =
       selection_range.StartPosition().ComputeOffsetInContainerNode();
   const unsigned selection_end_offset =
       selection_range.EndPosition().ComputeOffsetInContainerNode();
 
   const DocumentMarkerVector& markers_in_node =
       GetFrame().GetDocument()->Markers().MarkersFor(
           selection_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() < selection_end_offset &&
                             marker->EndOffset() > selection_start_offset;
                    });
   if (marker_it == markers_in_node.end())
-    return String();
+    return {};
 
   const SpellCheckMarker* const found_marker = ToSpellCheckMarker(*marker_it);
-  description = found_marker->Description();
 
   Range* const marker_range =
       Range::Create(*GetFrame().GetDocument(), selection_start_container,
                     found_marker->StartOffset(), selection_start_container,
                     found_marker->EndOffset());
 
   if (marker_range->GetText().StripWhiteSpace(&IsWhiteSpaceOrPunctuation) !=
       CreateRange(selection_range)
           ->GetText()
           .StripWhiteSpace(&IsWhiteSpaceOrPunctuation))
-    return String();
+    return {};
 
-  return marker_range->GetText();
+  return std::make_pair(marker_range->GetText(), found_marker->Description());
 }
 
 void SpellChecker::ReplaceMisspelledRange(const String& text) {
   const Optional<std::pair<Node*, SpellCheckMarker*>>& node_and_marker =
       GetSpellCheckMarkerUnderSelection();
   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