Enables the user to select multiple languages for spellchecking (UI)

chrome/browser/spellchecker/spellcheck_service.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/browser/spellchecker/spellcheck_service.h"
 
 #include "base/logging.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
+#include "base/supports_user_data.h"
 #include "base/synchronization/waitable_event.h"
 #include "chrome/browser/spellchecker/feedback_sender.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/spellchecker/spellcheck_hunspell_dictionary.h"
 #include "chrome/browser/spellchecker/spellcheck_platform_mac.h"
 #include "chrome/browser/spellchecker/spelling_service_client.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_messages.h"
@@ skipping 15 matching lines @@
 SpellcheckService::EventType g_status_type =
     SpellcheckService::BDICT_NOTINITIALIZED;
 
 SpellcheckService::SpellcheckService(content::BrowserContext* context)
     : context_(context),
       weak_ptr_factory_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   PrefService* prefs = user_prefs::UserPrefs::Get(context);
   pref_change_registrar_.Init(prefs);
 
-  StringListPrefMember dictionaries_pref;
-  dictionaries_pref.Init(prefs::kSpellCheckDictionaries, prefs);
   std::string first_of_dictionaries;
-  if (!dictionaries_pref.GetValue().empty())
-    first_of_dictionaries = dictionaries_pref.GetValue().front();
+  if (!chrome::spellcheck_common::GetDictionaryLanguagesPref(prefs).empty()) {
+    first_of_dictionaries =
+        chrome::spellcheck_common::GetDictionaryLanguagesPref(prefs).front();
+  }
 
   // For preference migration, set the new preference kSpellCheckDictionaries
   // to be the same as the old kSpellCheckDictionary.
   StringPrefMember single_dictionary_pref;
   single_dictionary_pref.Init(prefs::kSpellCheckDictionary, prefs);
   std::string single_dictionary = single_dictionary_pref.GetValue();
 
   if (first_of_dictionaries.empty() && !single_dictionary.empty()) {
     first_of_dictionaries = single_dictionary;
+    StringListPrefMember dictionaries_pref;
+    dictionaries_pref.Init(prefs::kSpellCheckDictionaries, prefs);
     dictionaries_pref.SetValue(
         std::vector<std::string>(1, first_of_dictionaries));
   }
 
   single_dictionary_pref.SetValue("");
 
   std::string language_code;
   std::string country_code;
   chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
       first_of_dictionaries,
       &language_code,
       &country_code);
   feedback_sender_.reset(new spellcheck::FeedbackSender(
       context->GetRequestContext(), language_code, country_code));
 
   pref_change_registrar_.Add(
       prefs::kEnableAutoSpellCorrect,
       base::Bind(&SpellcheckService::OnEnableAutoSpellCorrectChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kSpellCheckDictionaries,
-      base::Bind(&SpellcheckService::OnSpellCheckDictionaryChanged,
+      base::Bind(&SpellcheckService::OnSpellCheckDictionariesChanged,
                  base::Unretained(this)));
   if (!chrome::spellcheck_common::IsMultilingualSpellcheckEnabled()) {
     pref_change_registrar_.Add(
         prefs::kSpellCheckUseSpellingService,
         base::Bind(&SpellcheckService::OnUseSpellingServiceChanged,
                    base::Unretained(this)));
   }
+
   pref_change_registrar_.Add(
       prefs::kEnableContinuousSpellcheck,
       base::Bind(&SpellcheckService::InitForAllRenderers,
                  base::Unretained(this)));
 
-  OnSpellCheckDictionaryChanged();
+  OnSpellCheckDictionariesChanged();
 
   custom_dictionary_.reset(new SpellcheckCustomDictionary(context_->GetPath()));
   custom_dictionary_->AddObserver(this);
   custom_dictionary_->Load();
 
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllSources());
 }
 
 SpellcheckService::~SpellcheckService() {
   // Remove pref observers
   pref_change_registrar_.RemoveAll();
 }
 
 base::WeakPtr<SpellcheckService> SpellcheckService::GetWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 // static
-int SpellcheckService::GetSpellCheckLanguages(
+size_t SpellcheckService::GetSpellCheckLanguages(
     base::SupportsUserData* context,
     std::vector<std::string>* languages) {
   PrefService* prefs = user_prefs::UserPrefs::Get(context);
   StringPrefMember accept_languages_pref;
   accept_languages_pref.Init(prefs::kAcceptLanguages, prefs);
 
-  std::string dictionary_language;
-  prefs->GetList(prefs::kSpellCheckDictionaries)
-      ->GetString(0, &dictionary_language);
+  std::vector<std::string> accept_languages;
+  base::SplitString(accept_languages_pref.GetValue(), ',', &accept_languages);
 
-  // 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 defined(OS_MACOSX)

[please use gerrit instead, 2015/07/06 23:28:15]

If you're removing Mac specific code because this function is not called on Mac,
please put the whole function into "#if !defined(OS_MACOSX)" block.

[Julius, 2015/07/07 01:14:21]

Done.

-  if (spellcheck_mac::SpellCheckerAvailable())
-    spellcheck_mac::GetAvailableLanguages(&accept_languages);
-  else
-    base::SplitString(accept_languages_pref.GetValue(), ',', &accept_languages);
-#else
-  base::SplitString(accept_languages_pref.GetValue(), ',', &accept_languages);
-#endif  // !OS_MACOSX
-
-  languages->push_back(dictionary_language);
+  *languages = chrome::spellcheck_common::GetDictionaryLanguagesPref(prefs);
+  size_t enabled_spellcheck_languages = languages->size();
 
   for (std::vector<std::string>::const_iterator i = accept_languages.begin();
        i != accept_languages.end(); ++i) {
     std::string language =
         chrome::spellcheck_common::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;
+  return enabled_spellcheck_languages;
 }
 
 // static
 bool SpellcheckService::SignalStatusEvent(
     SpellcheckService::EventType status_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   if (!g_status_event)
     return false;
   g_status_type = status_type;
@@ skipping 124 matching lines @@
   bool enabled = pref_change_registrar_.prefs()->GetBoolean(
       prefs::kEnableAutoSpellCorrect);
   for (content::RenderProcessHost::iterator i(
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     content::RenderProcessHost* process = i.GetCurrentValue();
     process->Send(new SpellCheckMsg_EnableAutoSpellCorrect(enabled));
   }
 }
 
-void SpellcheckService::OnSpellCheckDictionaryChanged() {
+void SpellcheckService::OnSpellCheckDictionariesChanged() {
   if (hunspell_dictionary_.get())
     hunspell_dictionary_->RemoveObserver(this);
-  PrefService* prefs = user_prefs::UserPrefs::Get(context_);
-  DCHECK(prefs);
 
   std::string dictionary;
-  prefs->GetList(prefs::kSpellCheckDictionaries)->GetString(0, &dictionary);

[please use gerrit instead, 2015/07/06 23:28:15]

The current implementation is fine as is. Why change it?

[Julius, 2015/07/07 01:14:21]

Probably the better way.

+  std::vector<std::string> languages;
+  size_t dictionary_languages = GetSpellCheckLanguages(context_, &languages);
+  if (dictionary_languages > 0) {
+    DCHECK(!languages.empty());
+    dictionary = languages.front();
+  }
 
   hunspell_dictionary_.reset(new SpellcheckHunspellDictionary(
       dictionary, context_->GetRequestContext(), this));
   hunspell_dictionary_->AddObserver(this);
   hunspell_dictionary_->Load();
   std::string language_code;
   std::string country_code;
   chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
       dictionary, &language_code, &country_code);
   feedback_sender_->OnLanguageCountryChange(language_code, country_code);
   UpdateFeedbackSenderState();
 }
 
 void SpellcheckService::OnUseSpellingServiceChanged() {
   bool enabled = pref_change_registrar_.prefs()->GetBoolean(
       prefs::kSpellCheckUseSpellingService);
   if (metrics_)
     metrics_->RecordSpellingServiceStats(enabled);
   UpdateFeedbackSenderState();
 }
 
 void SpellcheckService::UpdateFeedbackSenderState() {
   if (SpellingServiceClient::IsAvailable(
           context_, SpellingServiceClient::SPELLCHECK)) {
     feedback_sender_->StartFeedbackCollection();
   } else {
     feedback_sender_->StopFeedbackCollection();
   }
 }