[spellcheck] Don't spellcheck in removed language.

chrome/browser/spellchecker/spellcheck_service_browsertest.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 <stddef.h>
 #include <stdint.h>
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
+#include "base/strings/string_split.h"
+#include "base/strings/string_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/tuple.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/spellcheck_common.h"
@@ skipping 53 matching lines @@
   BrowserContext* GetContext() {
     return static_cast<BrowserContext*>(browser()->profile());
   }
 
   PrefService* GetPrefs() {
     return prefs_;
   }
 
   void InitSpellcheck(bool enable_spellcheck,
                       const std::string& single_dictionary,
-                      const std::vector<std::string>& multiple_dictionaries) {
+                      const std::string& multiple_dictionaries) {
     prefs_->SetBoolean(prefs::kEnableContinuousSpellcheck, enable_spellcheck);
     prefs_->SetString(prefs::kSpellCheckDictionary, single_dictionary);
     base::ListValue dictionaries_value;
-    dictionaries_value.AppendStrings(multiple_dictionaries);
+    dictionaries_value.AppendStrings(
+        base::SplitString(multiple_dictionaries, ",", base::TRIM_WHITESPACE,
+                          base::SPLIT_WANT_NONEMPTY));
     prefs_->Set(prefs::kSpellCheckDictionaries, dictionaries_value);
     SpellcheckService* spellcheck =
         SpellcheckServiceFactory::GetForRenderProcessId(renderer_->GetID());
     ASSERT_NE(nullptr, spellcheck);
     spellcheck->InitForRenderer(renderer_.get());
   }
 
   void EnableSpellcheck(bool enable_spellcheck) {
     ScopedPreferenceChange scope(&renderer_->sink());
     prefs_->SetBoolean(prefs::kEnableContinuousSpellcheck, enable_spellcheck);
   }
 
   void SetSingleLanguageDictionary(const std::string& single_dictionary) {
     ScopedPreferenceChange scope(&renderer_->sink());
     prefs_->SetString(prefs::kSpellCheckDictionary, single_dictionary);
   }
 
-  void SetMultiLingualDictionaries(
-      const std::vector<std::string>& multiple_dictionaries) {
+  void SetMultiLingualDictionaries(const std::string& multiple_dictionaries) {
     ScopedPreferenceChange scope(&renderer_->sink());
     base::ListValue dictionaries_value;
-    dictionaries_value.AppendStrings(multiple_dictionaries);
+    dictionaries_value.AppendStrings(
+        base::SplitString(multiple_dictionaries, ",", base::TRIM_WHITESPACE,
+                          base::SPLIT_WANT_NONEMPTY));
     prefs_->Set(prefs::kSpellCheckDictionaries, dictionaries_value);
   }
 
+  std::string GetMultilingualDictionaries() {
+    const base::ListValue* list_value =
+        prefs_->GetList(prefs::kSpellCheckDictionaries);
+    std::vector<std::string> dictionaries;
+    for (const auto& item_value : *list_value) {
+      std::string dictionary;
+      EXPECT_TRUE(item_value->GetAsString(&dictionary));
+      dictionaries.push_back(dictionary);
+    }
+    return base::JoinString(dictionaries, ",");
+  }
+
+  void SetAcceptLanguages(const std::string& accept_languages) {
+    ScopedPreferenceChange scope(&renderer_->sink());
+    prefs_->SetString(prefs::kAcceptLanguages, accept_languages);
+  }
+
   // Returns the boolean parameter sent in the first
   // SpellCheckMsg_EnableSpellCheck message. For example, if spellcheck service
   // sent the SpellCheckMsg_EnableSpellCheck(true) message, then this method
   // returns true.
   bool GetFirstEnableSpellcheckMessageParam() {
     const IPC::Message* message = renderer_->sink().GetFirstMessageMatching(
         SpellCheckMsg_EnableSpellCheck::ID);
     EXPECT_NE(nullptr, message);
     if (!message)
       return false;
 
     SpellCheckMsg_EnableSpellCheck::Param param;
     bool ok = SpellCheckMsg_EnableSpellCheck::Read(message, &param);
     EXPECT_TRUE(ok);
     if (!ok)
       return false;
 
     return base::get<0>(param);
   }
 
  private:
   scoped_ptr<content::MockRenderProcessHost> renderer_;
 
   // Not owned preferences service.
   PrefService* prefs_;
 };
 
+// Removing a spellcheck language from accept languages should remove it from
+// spellcheck languages list as well.
+IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest,
+                       RemoveSpellcheckLanguageFromAcceptLanguages) {
+  InitSpellcheck(true, "", "en-US,fr");
+  SetAcceptLanguages("en-US,es,ru");
+  EXPECT_EQ("en-US", GetMultilingualDictionaries());
+}
+
+// Keeping spellcheck languages in accept languages should not alter spellcheck
+// languages list.
+IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest,
+                       KeepSpellcheckLanguagesInAcceptLanguages) {
+  InitSpellcheck(true, "", "en-US,fr");
+  SetAcceptLanguages("en-US,fr,es");
+  EXPECT_EQ("en-US,fr", GetMultilingualDictionaries());
+}
+
 // Starting with spellcheck enabled should send the 'enable spellcheck' message
 // to the renderer. Consequently disabling spellcheck should send the 'disable
 // spellcheck' message to the renderer.
 IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest, StartWithSpellcheck) {
-  std::vector<std::string> dictionaries;
-  dictionaries.push_back("en-US");
-  dictionaries.push_back("fr");
-  InitSpellcheck(true, "", dictionaries);
+  InitSpellcheck(true, "", "en-US,fr");
   EXPECT_TRUE(GetFirstEnableSpellcheckMessageParam());
 
   EnableSpellcheck(false);
   EXPECT_FALSE(GetFirstEnableSpellcheckMessageParam());
 }
 
 // Starting with only a single-language spellcheck setting should send the
 // 'enable spellcheck' message to the renderer. Consequently removing spellcheck
 // languages should disable spellcheck.
 IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest,
                        StartWithSingularLanguagePreference) {
-  InitSpellcheck(true, "en-US", std::vector<std::string>());
+  InitSpellcheck(true, "en-US", "");
   EXPECT_TRUE(GetFirstEnableSpellcheckMessageParam());
 
-  SetMultiLingualDictionaries(std::vector<std::string>());
+  SetMultiLingualDictionaries("");
   EXPECT_FALSE(GetFirstEnableSpellcheckMessageParam());
 }
 
 // Starting with a multi-language spellcheck setting should send the 'enable
 // spellcheck' message to the renderer. Consequently removing spellcheck
 // languages should disable spellcheck.
 IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest,
                        StartWithMultiLanguagePreference) {
-  std::vector<std::string> dictionaries;
-  dictionaries.push_back("en-US");
-  dictionaries.push_back("fr");
-  InitSpellcheck(true, "", dictionaries);
+  InitSpellcheck(true, "", "en-US,fr");
   EXPECT_TRUE(GetFirstEnableSpellcheckMessageParam());
 
-  SetMultiLingualDictionaries(std::vector<std::string>());
+  SetMultiLingualDictionaries("");
   EXPECT_FALSE(GetFirstEnableSpellcheckMessageParam());
 }
 
 // Starting with both single-language and multi-language spellcheck settings
 // should send the 'enable spellcheck' message to the renderer. Consequently
 // removing spellcheck languages should disable spellcheck.
 IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest,
                        StartWithBothLanguagePreferences) {
-  std::vector<std::string> dictionaries;
-  dictionaries.push_back("en-US");
-  dictionaries.push_back("fr");
-  InitSpellcheck(true, "en-US", dictionaries);
+  InitSpellcheck(true, "en-US", "en-US,fr");
   EXPECT_TRUE(GetFirstEnableSpellcheckMessageParam());
 
-  SetMultiLingualDictionaries(std::vector<std::string>());
+  SetMultiLingualDictionaries("");
   EXPECT_FALSE(GetFirstEnableSpellcheckMessageParam());
 }
 
 // Starting without spellcheck languages should send the 'disable spellcheck'
 // message to the renderer. Consequently adding spellchecking languages should
 // enable spellcheck.
 IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest, StartWithoutLanguages) {
-  InitSpellcheck(true, "", std::vector<std::string>());
+  InitSpellcheck(true, "", "");
   EXPECT_FALSE(GetFirstEnableSpellcheckMessageParam());
 
-  SetMultiLingualDictionaries(std::vector<std::string>(1, "en-US"));
+  SetMultiLingualDictionaries("en-US");
   EXPECT_TRUE(GetFirstEnableSpellcheckMessageParam());
 }
 
 // Starting with spellcheck disabled should send the 'disable spellcheck'
 // message to the renderer. Consequently enabling spellcheck should send the
 // 'enable spellcheck' message to the renderer.
 IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest, StartWithoutSpellcheck) {
-  std::vector<std::string> dictionaries;
-  dictionaries.push_back("en-US");
-  dictionaries.push_back("fr");
-  InitSpellcheck(false, "", dictionaries);
+  InitSpellcheck(false, "", "en-US,fr");
   EXPECT_FALSE(GetFirstEnableSpellcheckMessageParam());
 
   EnableSpellcheck(true);
   EXPECT_TRUE(GetFirstEnableSpellcheckMessageParam());
 }
 
 // Tests that we can delete a corrupted BDICT file used by hunspell. We do not
 // run this test on Mac because Mac does not use hunspell by default.
 IN_PROC_BROWSER_TEST_F(SpellcheckServiceBrowserTest, DeleteCorruptedBDICT) {
   // Write the corrupted BDICT data to create a corrupted BDICT file.
@@ skipping 109 matching lines @@
   EXPECT_TRUE(GetPrefs()->GetBoolean(prefs::kEnableContinuousSpellcheck));
   EXPECT_EQ(2U, GetPrefs()->GetList(prefs::kSpellCheckDictionaries)->GetSize());
   std::string pref;
   ASSERT_TRUE(
       GetPrefs()->GetList(prefs::kSpellCheckDictionaries)->GetString(0, &pref));
   EXPECT_EQ("en-US", pref);
   ASSERT_TRUE(
       GetPrefs()->GetList(prefs::kSpellCheckDictionaries)->GetString(1, &pref));
   EXPECT_EQ("fr", pref);
 }