Adds support for the os x spelling panel to chromium. Users can...

chrome/browser/spellchecker.cc

 // Copyright (c) 2006-2009 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 "app/l10n_util.h"
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/spellchecker_common.h"
 #include "chrome/browser/spellchecker_platform_engine.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 515 matching lines @@
   if (bdict_file_->Initialize(bdic_file_name)) {
     hunspell_.reset(new Hunspell(bdict_file_->data(), bdict_file_->length()));
     AddCustomWordsToHunspell();
   }
   DHISTOGRAM_TIMES("Spellcheck.InitTime", TimeTicks::Now() - begin_time);
 
   tried_to_init_ = true;
   return false;
 }
 
-void SpellChecker::GetAutoCorrectionWord(const std::wstring& word,
+void SpellChecker::GetAutoCorrectionWord(const std::wstring& word, int tag,
                                          std::wstring* autocorrect_word) {
   autocorrect_word->clear();
   if (!auto_spell_correct_turned_on_)
     return;
 
   int word_length = static_cast<int>(word.size());
   if (word_length < 2 || word_length > kMaxAutoCorrectWordSize)
     return;
 
   wchar_t misspelled_word[kMaxAutoCorrectWordSize + 1];
   const wchar_t* word_char = word.c_str();
   for (int i = 0; i <= kMaxAutoCorrectWordSize; i++) {
     if (i >= word_length)
       misspelled_word[i] = NULL;
     else
       misspelled_word[i] = word_char[i];
   }
 
   // Swap adjacent characters and spellcheck.
   int misspelling_start, misspelling_len;
   for (int i = 0; i < word_length - 1; i++) {
     // Swap.
     std::swap(misspelled_word[i], misspelled_word[i + 1]);
 
     // Check spelling.
     misspelling_start = misspelling_len = 0;
-    SpellCheckWord(misspelled_word, word_length, &misspelling_start,
+    SpellCheckWord(misspelled_word, word_length, tag, &misspelling_start,
         &misspelling_len, NULL);
 
     // Make decision: if only one swap produced a valid word, then we want to
     // return it. If we found two or more, we don't do autocorrection.
     if (misspelling_len == 0) {
       if (autocorrect_word->empty()) {
         autocorrect_word->assign(misspelled_word);
       } else {
         autocorrect_word->clear();
         return;
@@ skipping 23 matching lines @@
          it != list_of_words.end(); ++it) {
       hunspell_->add(it->c_str());
     }
   }
 }
 
 // Returns whether or not the given string is a valid contraction.
 // This function is a fall-back when the SpellcheckWordIterator class
 // returns a concatenated word which is not in the selected dictionary
 // (e.g. "in'n'out") but each word is valid.
-bool SpellChecker::IsValidContraction(const string16& contraction) {
+bool SpellChecker::IsValidContraction(const string16& contraction, int tag) {
   SpellcheckWordIterator word_iterator;
   word_iterator.Initialize(&character_attributes_, contraction.c_str(),
                            contraction.length(), false);
 
   string16 word;
   int word_start;
   int word_length;
   while (word_iterator.GetNextWord(&word, &word_start, &word_length)) {
-    if (!CheckSpelling(UTF16ToUTF8(word)))
+    if (!CheckSpelling(UTF16ToUTF8(word), tag))
       return false;
   }
   return true;
 }
 
 bool SpellChecker::SpellCheckWord(
     const wchar_t* in_word,
     int in_word_len,
+    int tag,
     int* misspelling_start,
     int* misspelling_len,
     std::vector<std::wstring>* optional_suggestions) {
   DCHECK(in_word_len >= 0);
   DCHECK(misspelling_start && misspelling_len) << "Out vars must be given.";
 
 #ifndef NDEBUG
   // This must always be called on the same thread (normally the I/O thread).
   if (worker_loop_)
     DCHECK(MessageLoop::current() == worker_loop_);
@@ skipping 23 matching lines @@
   string16 in_word_utf16;
   WideToUTF16(in_word, in_word_len, &in_word_utf16);
   int word_start;
   int word_length;
   word_iterator.Initialize(&character_attributes_, in_word_utf16.c_str(),
                            in_word_len, true);
   while (word_iterator.GetNextWord(&word, &word_start, &word_length)) {
     // Found a word (or a contraction) that the spellchecker can check the
     // spelling of.
     std::string encoded_word = UTF16ToUTF8(word);
-    bool word_ok = CheckSpelling(encoded_word);
+    bool word_ok = CheckSpelling(encoded_word, tag);
     if (word_ok)
       continue;
 
     // If the given word is a concatenated word of two or more valid words
     // (e.g. "hello:hello"), we should treat it as a valid word.
-    if (IsValidContraction(word))
+    if (IsValidContraction(word, tag))
       continue;
 
     *misspelling_start = word_start;
     *misspelling_len = word_length;
 
     // Get the list of suggested words.
     if (optional_suggestions) {
       FillSuggestionList(encoded_word, optional_suggestions);
     }
     return false;
@@ skipping 47 matching lines @@
 
   // Now add the word to the custom dictionary file.
   Task* write_word_task =
       new AddWordToCustomDictionaryTask(custom_dictionary_file_name_, word);
   if (file_loop_)
     file_loop_->PostTask(FROM_HERE, write_word_task);
   else
     write_word_task->Run();
 }
 
-bool SpellChecker::CheckSpelling(const std::string& word_to_check) {
+bool SpellChecker::CheckSpelling(const std::string& word_to_check, int tag) {
   bool word_correct = false;
 
   TimeTicks begin_time = TimeTicks::Now();
   if (is_using_platform_spelling_engine_) {
-    word_correct = SpellCheckerPlatform::CheckSpelling(word_to_check);
+    word_correct = SpellCheckerPlatform::CheckSpelling(word_to_check, tag);
   } else {
     // |hunspell_->spell| returns 0 if the word is spelled correctly and
     // non-zero otherwsie.
     word_correct = (hunspell_->spell(word_to_check.c_str()) != 0);
   }
   DHISTOGRAM_TIMES("Spellcheck.CheckTime", TimeTicks::Now() - begin_time);
 
   return word_correct;
 }
 
@@ skipping 13 matching lines @@
 
   // Populate the vector of WideStrings.
   for (int i = 0; i < number_of_suggestions; i++) {
     if (i < kMaxSuggestions)
       optional_suggestions->push_back(UTF8ToWide(suggestions[i]));
     free(suggestions[i]);
   }
   if (suggestions != NULL)
     free(suggestions);
 }