[Reland] Allow storing multiple replacements on SpellCheckResult

components/spellcheck/renderer/spellcheck.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/spellcheck/renderer/spellcheck.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <utility>
@@ skipping 95 matching lines @@
     if (IsApostrophe(c)) {
       it = std::find_if(it, spelling_suggestion->end(), IsApostrophe);
       if (it == spelling_suggestion->end())
         return;
 
       *it++ = c;
     }
   }
 }
 
+std::vector<WebString> FilterReplacementSuggestions(
+    const base::string16& misspelled_word,
+    const std::vector<base::string16>& replacements) {
+  std::vector<WebString> replacements_filtered;
+  for (base::string16 replacement : replacements) {
+    // Use the same types of apostrophes as in the mispelled word.
+    PreserveOriginalApostropheTypes(misspelled_word, &replacement);
+
+    // Ignore suggestions that are just changing the apostrophe type
+    // (straight vs. typographical)
+    if (replacement == misspelled_word)
+      continue;
+
+    replacements_filtered.push_back(WebString::FromUTF16(replacement));
+  }
+
+  return replacements_filtered;
+}
+
 }  // namespace
 
 class SpellCheck::SpellcheckRequest {
  public:
   SpellcheckRequest(const base::string16& text,
                     blink::WebTextCheckingCompletion* completion)
       : text_(text), completion_(completion) {
     DCHECK(completion);
   }
   ~SpellcheckRequest() {}
@@ skipping 340 matching lines @@
   std::vector<WebTextCheckingResult> results;
   for (const SpellCheckResult& spellcheck_result : spellcheck_results) {
     DCHECK_LE(static_cast<size_t>(spellcheck_result.location),
               line_text.length());
     DCHECK_LE(static_cast<size_t>(spellcheck_result.location +
                                   spellcheck_result.length),
               line_text.length());
 
     const base::string16& misspelled_word =
         line_text.substr(spellcheck_result.location, spellcheck_result.length);
-    base::string16 replacement = spellcheck_result.replacement;
+    const std::vector<base::string16>& replacements =
+        spellcheck_result.replacements;
     SpellCheckResult::Decoration decoration = spellcheck_result.decoration;
 
     // Ignore words in custom dictionary.
     if (custom_dictionary_.SpellCheckWord(misspelled_word, 0,
                                           misspelled_word.length())) {
       continue;
     }
 
-    // Use the same types of appostrophes as in the mispelled word.
-    PreserveOriginalApostropheTypes(misspelled_word, &replacement);
+    std::vector<WebString> replacements_filtered =
+        FilterReplacementSuggestions(misspelled_word, replacements);
 
-    // Ignore misspellings due the typographical apostrophe.
-    if (misspelled_word == replacement)
+    // If the spellchecker suggested replacements, but they were all just
+    // changing apostrophe styles, ignore this misspelling. If there were never
+    // any suggested replacements, keep the misspelling.
+    if (replacements_filtered.empty() && !replacements.empty())
       continue;
 
     if (filter == USE_NATIVE_CHECKER) {
       // Double-check misspelled words with out spellchecker and attach grammar
       // markers to them if our spellchecker tells us they are correct words,
       // i.e. they are probably contextually-misspelled words.
       int unused_misspelling_start = 0;
       int unused_misspelling_length = 0;
       if (decoration == SpellCheckResult::SPELLING &&
           SpellCheckWord(misspelled_word.c_str(), kNoOffset,
                          misspelled_word.length(), kNoTag,
                          &unused_misspelling_start, &unused_misspelling_length,
                          nullptr)) {
         decoration = SpellCheckResult::GRAMMAR;
       }
     }
 
-    results.push_back(WebTextCheckingResult(
-        static_cast<WebTextDecorationType>(decoration),
-        line_offset + spellcheck_result.location, spellcheck_result.length,
-        blink::WebString::FromUTF16(replacement)));
+    results.push_back(
+        WebTextCheckingResult(static_cast<WebTextDecorationType>(decoration),
+                              line_offset + spellcheck_result.location,
+                              spellcheck_result.length, replacements_filtered));
   }
 
   textcheck_results->Assign(results);
 }
 
 bool SpellCheck::IsSpellcheckEnabled() {
 #if defined(OS_ANDROID)
   if (!spellcheck::IsAndroidSpellCheckFeatureEnabled()) return false;
 #endif
   return spellcheck_enabled_;
 }