Offers suggestions for each language that marks a word misspelled.

chrome/renderer/spellchecker/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 "chrome/renderer/spellchecker/spellcheck.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 154 matching lines @@
 // values.
 // TODO(groby): Simplify this.
 SpellCheck::SpellCheck()
     : auto_spell_correct_turned_on_(false),
       spellcheck_enabled_(true) {
 }
 
 SpellCheck::~SpellCheck() {
 }
 
+void SpellCheck::FillSuggestions(
+    const std::vector<std::vector<base::string16>>& suggestions_list,
+    std::vector<base::string16>* optional_suggestions) {
+  // A vector containing the indices of the current suggestion for each
+  // language's suggestion list.
+  std::vector<size_t> indices(suggestions_list.size(), 0);
+  // Take one suggestion at a time from each language's suggestions and add it
+  // to |optional_suggestions|.
+  for (size_t i = 0, num_empty = 0;
+       num_empty < suggestions_list.size() &&
+       optional_suggestions->size() <
+           chrome::spellcheck_common::kMaxSuggestions;
+       i = (i + 1) % suggestions_list.size()) {
+    if (indices[i] < suggestions_list[i].size()) {
+      const base::string16& suggestion = suggestions_list[i][indices[i]];
+      // Only add the suggestion if it's unique.
+      if (std::find(optional_suggestions->begin(), optional_suggestions->end(),
+                    suggestion) == optional_suggestions->end()) {
+        optional_suggestions->push_back(suggestion);
+      }
+      if (++indices[i] == suggestions_list[i].size())
+        num_empty++;
+    }
+  }
+}
+
 bool SpellCheck::OnControlMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SpellCheck, message)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_Init, OnInit)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_CustomDictionaryChanged,
                         OnCustomDictionaryChanged)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_EnableAutoSpellCorrect,
                         OnEnableAutoSpellCorrect)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_EnableSpellCheck, OnEnableSpellCheck)
     IPC_MESSAGE_HANDLER(SpellCheckMsg_RequestDocumentMarkers,
@@ skipping 72 matching lines @@
   // report the word as correctly spelled.)
   if (InitializeIfNeeded())
     return true;
 
   // These are for holding misspelling or skippable word positions and lengths
   // between calls to SpellcheckLanguage::SpellCheckWord.
   int possible_misspelling_start;
   int possible_misspelling_len;
   // The longest sequence of text that all languages agree is skippable.
   int agreed_skippable_len;
+  // A vector of vectors containing spelling suggestions from different
+  // languages.
+  std::vector<std::vector<base::string16>> suggestions_list;
+  // A vector to hold a language's misspelling suggestions between spellcheck
+  // calls.
+  std::vector<base::string16> language_suggestions;
 
   // This loop only advances if all languages agree that a sequence of text is
   // skippable.
   for (; position_in_text <= text_length;
        position_in_text += agreed_skippable_len) {
     // Reseting |agreed_skippable_len| to the worst-case length each time
     // prevents some unnecessary iterations.
     agreed_skippable_len = text_length;
     *misspelling_start = 0;
     *misspelling_len = 0;
-
-    if (optional_suggestions)
-      optional_suggestions->clear();
+    suggestions_list.clear();
 
     for (ScopedVector<SpellcheckLanguage>::iterator language =
              languages_.begin();
          language != languages_.end();) {
+      language_suggestions.clear();
       SpellcheckLanguage::SpellcheckWordResult result =
-          (*language)->SpellCheckWord(text_begin, position_in_text, text_length,
-                                      tag, &possible_misspelling_start,
-                                      &possible_misspelling_len,
-                                      optional_suggestions);
+          (*language)->SpellCheckWord(
+              text_begin, position_in_text, text_length, tag,
+              &possible_misspelling_start, &possible_misspelling_len,
+              optional_suggestions ? &language_suggestions : nullptr);
 
       switch (result) {
         case SpellcheckLanguage::SpellcheckWordResult::IS_CORRECT:
           *misspelling_start = 0;
           *misspelling_len = 0;
           return true;
         case SpellcheckLanguage::SpellcheckWordResult::IS_SKIPPABLE:
           agreed_skippable_len =
               std::min(agreed_skippable_len, possible_misspelling_len);
           // If true, this means the spellchecker moved past a word that was
           // previously determined to be misspelled or skippable, which means
           // another spellcheck language marked it as correct.
           if (position_in_text != possible_misspelling_start) {
             *misspelling_len = 0;
             position_in_text = possible_misspelling_start;
+            suggestions_list.clear();
             language = languages_.begin();
           } else {
             language++;
           }
           break;
         case SpellcheckLanguage::SpellcheckWordResult::IS_MISSPELLED:
           *misspelling_start = possible_misspelling_start;
           *misspelling_len = possible_misspelling_len;
           // If true, this means the spellchecker moved past a word that was
           // previously determined to be misspelled or skippable, which means
           // another spellcheck language marked it as correct.
-          language = position_in_text != *misspelling_start ? languages_.begin()
-                                                            : language + 1;
-          position_in_text = *misspelling_start;
+          if (position_in_text != *misspelling_start) {
+            suggestions_list.clear();
+            language = languages_.begin();
+            position_in_text = *misspelling_start;
+          } else {
+            suggestions_list.push_back(language_suggestions);
+            language++;
+          }
           break;
       }
     }
 
     // If |*misspelling_len| is non-zero, that means at least one language
     // marked a word misspelled and no other language considered it correct.
-    if (*misspelling_len != 0)
+    if (*misspelling_len != 0) {
+      if (optional_suggestions)
+        FillSuggestions(suggestions_list, optional_suggestions);
       return false;
+    }
   }
 
   NOTREACHED();
   return true;
 }
 
 bool SpellCheck::SpellCheckParagraph(
     const base::string16& text,
     WebVector<WebTextCheckingResult>* results) {
 #if !defined(USE_BROWSER_SPELLCHECKER)
@@ skipping 217 matching lines @@
 
 bool SpellCheck::IsSpellcheckEnabled() {
 #if defined(OS_ANDROID)
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAndroidSpellChecker)) {
     return false;
   }
 #endif
   return spellcheck_enabled_;
 }