[spellcheck] Don't spellcheck in removed language.

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 <algorithm>
+
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/supports_user_data.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.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.h"
@@ skipping 52 matching lines @@
   if (!dictionaries_pref.GetValue().empty())
     first_of_dictionaries = dictionaries_pref.GetValue().front();
 
   if (first_of_dictionaries.empty() && !single_dictionary.empty()) {
     first_of_dictionaries = single_dictionary;
     dictionaries_pref.SetValue(
         std::vector<std::string>(1, first_of_dictionaries));
   }
 
   single_dictionary_pref.SetValue("");
-
 #endif  // defined(USE_BROWSER_SPELLCHECKER)
 
   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::kSpellCheckDictionaries,
       base::Bind(&SpellcheckService::OnSpellCheckDictionariesChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kSpellCheckUseSpellingService,
       base::Bind(&SpellcheckService::OnUseSpellingServiceChanged,
                  base::Unretained(this)));
-
+  pref_change_registrar_.Add(
+      prefs::kAcceptLanguages,
+      base::Bind(&SpellcheckService::OnAcceptLanguagesChanged,
+                 base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kEnableContinuousSpellcheck,
       base::Bind(&SpellcheckService::InitForAllRenderers,
                  base::Unretained(this)));
 
   custom_dictionary_.reset(new SpellcheckCustomDictionary(context_->GetPath()));
   custom_dictionary_->AddObserver(this);
   custom_dictionary_->Load();
 
   registrar_.Add(this,
@@ skipping 219 matching lines @@
 }
 
 void SpellcheckService::OnUseSpellingServiceChanged() {
   bool enabled = pref_change_registrar_.prefs()->GetBoolean(
       prefs::kSpellCheckUseSpellingService);
   if (metrics_)
     metrics_->RecordSpellingServiceStats(enabled);
   UpdateFeedbackSenderState();
 }
 
+void SpellcheckService::OnAcceptLanguagesChanged() {
+  PrefService* prefs = user_prefs::UserPrefs::Get(context_);
+  std::vector<std::string> accept_languages =
+      base::SplitString(prefs->GetString(prefs::kAcceptLanguages), ",",

[groby-ooo-7-16, 2016/02/09 02:51:33]

Sigh. Why is this not a list? (Undirected grumbling. Not fixable in this CL)

[please use gerrit instead, 2016/02/09 20:45:49]

Acknowledged.

+                        base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
+  std::transform(
+      accept_languages.begin(), accept_languages.end(),
+      accept_languages.begin(),
+      &chrome::spellcheck_common::GetCorrespondingSpellCheckLanguage);
+
+  StringListPrefMember dictionaries_pref;
+  dictionaries_pref.Init(prefs::kSpellCheckDictionaries, prefs);

[groby-ooo-7-16, 2016/02/09 02:51:33]

If dictionaries and accept_languages were ordered, we could set_difference - but
we can't order them, right?

[please use gerrit instead, 2016/02/09 20:45:49]

Right, we can't order them, because we want to preserve the order as set in
chrome://settings/languages.

+  std::vector<std::string> dictionaries = dictionaries_pref.GetValue();
+  std::vector<std::string> filtered_dictionaries;
+
+  for (const auto& dictionary : dictionaries) {
+    if (std::find(accept_languages.begin(), accept_languages.end(),
+                  dictionary) != accept_languages.end()) {
+      filtered_dictionaries.push_back(dictionary);
+    }
+  }
+
+  dictionaries_pref.SetValue(filtered_dictionaries);
+}
+
 void SpellcheckService::UpdateFeedbackSenderState() {
   std::string feedback_language;
   if (!hunspell_dictionaries_.empty())
     feedback_language = hunspell_dictionaries_.front()->GetLanguage();
   std::string language_code;
   std::string country_code;
   chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
       feedback_language, &language_code, &country_code);
   feedback_sender_->OnLanguageCountryChange(language_code, country_code);
   if (SpellingServiceClient::IsAvailable(
           context_, SpellingServiceClient::SPELLCHECK)) {
     feedback_sender_->StartFeedbackCollection();
   } else {
     feedback_sender_->StopFeedbackCollection();
   }
 }