Move Mac to using renderer spellchecker.

chrome/browser/spellcheck_host.cc

 // Copyright (c) 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 "chrome/browser/spellcheck_host.h"
 
 #include <fcntl.h>
 
 #include "app/l10n_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
+#include "chrome/browser/profile.h"
+#include "chrome/browser/spellchecker_platform_engine.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/notification_service.h"
+#include "chrome/common/pref_member.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/spellcheck_common.h"
 #include "googleurl/src/gurl.h"
 
 namespace {
 
-static const struct {
-  // The language.
-  const char* language;
-
-  // The corresponding language and region, used by the dictionaries.
-  const char* language_region;
-} g_supported_spellchecker_languages[] = {
-  // Several languages are not to be included in the spellchecker list:
-  //   th-TH, hu-HU, bg-BG, uk-UA
-  {"ca", "ca-ES"},
-  {"cs", "cs-CZ"},
-  {"da", "da-DK"},
-  {"de", "de-DE"},
-  {"el", "el-GR"},
-  {"en-AU", "en-AU"},
-  {"en-GB", "en-GB"},
-  {"en-US", "en-US"},
-  {"es", "es-ES"},
-  {"et", "et-EE"},
-  {"fr", "fr-FR"},
-  {"he", "he-IL"},
-  {"hi", "hi-IN"},
-  {"hr", "hr-HR"},
-  {"id", "id-ID"},
-  {"it", "it-IT"},
-  {"lt", "lt-LT"},
-  {"lv", "lv-LV"},
-  {"nb", "nb-NO"},
-  {"nl", "nl-NL"},
-  {"pl", "pl-PL"},
-  {"pt-BR", "pt-BR"},
-  {"pt-PT", "pt-PT"},
-  {"ro", "ro-RO"},
-  {"ru", "ru-RU"},
-  {"sk", "sk-SK"},
-  {"sl", "sl-SI"},
-  {"sv", "sv-SE"},
-  {"tr", "tr-TR"},
-  {"vi", "vi-VN"},
-};
-
-// This function returns the language-region version of language name.
-// e.g. returns hi-IN for hi.
-std::string GetSpellCheckLanguageRegion(const std::string& input_language) {
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
-       ++i) {
-    if (g_supported_spellchecker_languages[i].language == input_language) {
-      return std::string(
-          g_supported_spellchecker_languages[i].language_region);
-    }
-  }
-
-  return input_language;
-}
-
-FilePath GetVersionedFileName(const std::string& input_language,
-                              const FilePath& dict_dir) {
-  // The default dictionary version is 1-2. These versions have been augmented
-  // with additional words found by the translation team.
-  static const char kDefaultVersionString[] = "-1-2";
-
-  // The following dictionaries have either not been augmented with additional
-  // words (version 1-1) or have new words, as well as an upgraded dictionary
-  // as of Feb 2009 (version 1-3).
-  static const struct {
-    // The language input.
-    const char* language;
-
-    // The corresponding version.
-    const char* version;
-  } special_version_string[] = {
-    {"en-AU", "-1-1"},
-    {"en-GB", "-1-1"},
-    {"es-ES", "-1-1"},
-    {"nl-NL", "-1-1"},
-    {"ru-RU", "-1-1"},
-    {"sv-SE", "-1-1"},
-    {"he-IL", "-1-1"},
-    {"el-GR", "-1-1"},
-    {"hi-IN", "-1-1"},
-    {"tr-TR", "-1-1"},
-    {"et-EE", "-1-1"},
-    {"fr-FR", "-1-4"},  // To fix a crash, fr dictionary was updated to 1.4.
-    {"lt-LT", "-1-3"},
-    {"pl-PL", "-1-3"}
-  };
-
-  // Generate the bdict file name using default version string or special
-  // version string, depending on the language.
-  std::string language = GetSpellCheckLanguageRegion(input_language);
-  std::string versioned_bdict_file_name(language + kDefaultVersionString +
-                                        ".bdic");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(special_version_string); ++i) {
-    if (language == special_version_string[i].language) {
-      versioned_bdict_file_name =
-          language + special_version_string[i].version + ".bdic";
-      break;
-    }
-  }
-
-  return dict_dir.AppendASCII(versioned_bdict_file_name);
-}
-
 FilePath GetFirstChoiceFilePath(const std::string& language) {
   FilePath dict_dir;
   PathService::Get(chrome::DIR_APP_DICTIONARIES, &dict_dir);
-  return GetVersionedFileName(language, dict_dir);
+  return SpellCheckCommon::GetVersionedFileName(language, dict_dir);
 }
 
 FilePath GetFallbackFilePath(const FilePath& first_choice) {
   FilePath dict_dir;
   PathService::Get(chrome::DIR_USER_DATA, &dict_dir);
   return dict_dir.Append(first_choice.BaseName());
 }
 
 }  // namespace
 
 // Constructed on UI thread.
 SpellCheckHost::SpellCheckHost(Observer* observer,
                                const std::string& language,
                                URLRequestContextGetter* request_context_getter)
     : observer_(observer),
       language_(language),
       file_(base::kInvalidPlatformFileValue),
       tried_to_download_(false),
+      use_platform_spellchecker_(false),
       request_context_getter_(request_context_getter) {
   DCHECK(observer_);
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   FilePath personal_file_directory;
   PathService::Get(chrome::DIR_USER_DATA, &personal_file_directory);
   custom_dictionary_file_ =
       personal_file_directory.Append(chrome::kCustomDictionaryFileName);
 
   bdict_file_path_ = GetFirstChoiceFilePath(language);
 }
 
 SpellCheckHost::~SpellCheckHost() {
   if (file_ != base::kInvalidPlatformFileValue)
     base::ClosePlatformFile(file_);
 }
 
 void SpellCheckHost::Initialize() {
+  if (SpellCheckerPlatform::SpellCheckerAvailable() &&
+      SpellCheckerPlatform::PlatformSupportsLanguage(language_)) {
+    use_platform_spellchecker_ = true;
+    SpellCheckerPlatform::SetLanguage(language_);
+    MessageLoop::current()->PostTask(FROM_HERE,
+        NewRunnableMethod(this,
+            &SpellCheckHost::InformObserverOfInitialization));
+    return;
+  }
+
   ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this, &SpellCheckHost::InitializeDictionaryLocation));
 }
 
 void SpellCheckHost::UnsetObserver() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   observer_ = NULL;
   request_context_getter_ = NULL;
   fetcher_.reset();
 }
 
 void SpellCheckHost::AddWord(const std::string& word) {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
 
   custom_words_.push_back(word);
   ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
       NewRunnableMethod(this,
           &SpellCheckHost::WriteWordToCustomDictionary, word));
   NotificationService::current()->Notify(
       NotificationType::SPELLCHECK_WORD_ADDED,
       Source<SpellCheckHost>(this), NotificationService::NoDetails());
 }
 
+// static
+int SpellCheckHost::GetSpellCheckLanguages(
+    Profile* profile,
+    std::vector<std::string>* languages) {
+  StringPrefMember accept_languages_pref;
+  StringPrefMember dictionary_language_pref;
+  accept_languages_pref.Init(prefs::kAcceptLanguages, profile->GetPrefs(),
+                             NULL);
+  dictionary_language_pref.Init(prefs::kSpellCheckDictionary,
+                                profile->GetPrefs(), NULL);
+  std::string dictionary_language =
+      WideToASCII(dictionary_language_pref.GetValue());
+
+  // The current dictionary language should be there.
+  languages->push_back(dictionary_language);
+
+  // Now scan through the list of accept languages, and find possible mappings
+  // from this list to the existing list of spell check languages.
+  std::vector<std::string> accept_languages;
+
+  if (SpellCheckerPlatform::SpellCheckerAvailable()) {
+    SpellCheckerPlatform::GetAvailableLanguages(&accept_languages);
+  } else {
+    SplitString(WideToASCII(accept_languages_pref.GetValue()), ',',
+                &accept_languages);
+  }
+  for (std::vector<std::string>::const_iterator i = accept_languages.begin();
+       i != accept_languages.end(); ++i) {
+    std::string language =
+        SpellCheckCommon::GetCorrespondingSpellCheckLanguage(*i);
+    if (!language.empty() &&
+        std::find(languages->begin(), languages->end(), language) ==
+        languages->end()) {
+      languages->push_back(language);
+    }
+  }
+
+  for (size_t i = 0; i < languages->size(); ++i) {
+    if ((*languages)[i] == dictionary_language)
+      return i;
+  }
+  return -1;
+}
+
 void SpellCheckHost::InitializeDictionaryLocation() {
   DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
 #if defined(OS_WIN)
   // Check if the dictionary exists in the fallback location. If so, use it
   // rather than downloading anew.
   FilePath fallback = GetFallbackFilePath(bdict_file_path_);
   if (!file_util::PathExists(bdict_file_path_) &&
       file_util::PathExists(fallback)) {
     bdict_file_path_ = fallback;
@@ skipping 142 matching lines @@
       ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
           NewRunnableMethod(this,
               &SpellCheckHost::InformObserverOfInitialization));
       return;
     }
   }
 
   data_.clear();
   Initialize();
 }