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

chrome/browser/spellchecker/spellcheck_service_unittest.cc

Index: chrome/browser/spellchecker/spellcheck_service_unittest.cc
diff --git a/chrome/browser/spellchecker/spellcheck_service_unittest.cc b/chrome/browser/spellchecker/spellcheck_service_unittest.cc
index f2fd9f0fff6ec1c0396a87c99f5a38026f8f5f6a..cc2e36f35ff12b189055b129433992552a028cb1 100644
--- a/chrome/browser/spellchecker/spellcheck_service_unittest.cc
+++ b/chrome/browser/spellchecker/spellcheck_service_unittest.cc
@@ -4,104 +4,147 @@
 
 #include "chrome/browser/spellchecker/spellcheck_service.h"
 
-#include <algorithm>
-
-#include "base/memory/scoped_ptr.h"
-#include "chrome/browser/spellchecker/feedback_sender.h"
-#include "chrome/browser/spellchecker/spellcheck_factory.h"
-#include "chrome/test/base/testing_profile.h"
-#include "content/public/test/test_browser_thread_bundle.h"
+#include <string>
+#include <vector>
+
+#include "base/command_line.h"
+#include "base/message_loop/message_loop.h"
+#include "base/prefs/pref_registry_simple.h"
+#include "base/prefs/testing_pref_service.h"
+#include "base/strings/string_split.h"
+#include "base/supports_user_data.h"
+#include "chrome/common/chrome_switches.h"
+#include "chrome/common/pref_names.h"
+#include "components/user_prefs/user_prefs.h"
+#include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-static scoped_ptr<KeyedService> BuildSpellcheckService(
-    content::BrowserContext* profile) {
-  return make_scoped_ptr(new SpellcheckService(static_cast<Profile*>(profile)));
-}
 
-class SpellcheckServiceTest : public testing::Test {
- protected:
-  void SetUp() override {
-    // Use SetTestingFactoryAndUse to force creation and initialization.
-    SpellcheckServiceFactory::GetInstance()->SetTestingFactoryAndUse(
-        &profile_, &BuildSpellcheckService);
+struct SpellcheckLanguageTestCase {

[groby-ooo-7-16, 2015/06/24 22:12:23]

FWIW, you're both adding new test cases and turning the old test cases into a
TEST_CASE_P - you might want to factor out the latter and do that in a separate
CL. It'll make reviewing and understanding changes easier.

[Julius, 2015/07/06 22:38:53]

Done.

+  SpellcheckLanguageTestCase(const std::string& spellcheck_dictionaries,
+                             const std::string& accept_languages,
+                             size_t num_expected_enabled_spellcheck_languages,
+                             const std::string& unsplit_expected_languages)
+      : spellcheck_dictionaries(spellcheck_dictionaries),
+        accept_languages(accept_languages),
+        num_expected_enabled_spellcheck_languages(
+            num_expected_enabled_spellcheck_languages) {
+    base::SplitString(unsplit_expected_languages, ',',
+                      &expected_spellcheck_languages);
   }
+  ~SpellcheckLanguageTestCase() {}
 
- private:
-  content::TestBrowserThreadBundle thread_bundle_;
-  TestingProfile profile_;
+  const std::string spellcheck_dictionaries;
+  const std::string accept_languages;
+  size_t num_expected_enabled_spellcheck_languages;
+  std::vector<std::string> expected_spellcheck_languages;
 };
 
-TEST_F(SpellcheckServiceTest, GetSpellCheckLanguages1) {
-  std::vector<std::string> accept_languages;
-  accept_languages.push_back("en");
-  accept_languages.push_back("en-US");
-  std::vector<std::string> languages;
-
-  SpellcheckService::GetSpellCheckLanguagesFromAcceptLanguages(
-      accept_languages, "en-US", &languages);
+struct TestSupportsUserData : public base::SupportsUserData {};
 
-  EXPECT_EQ(1U, languages.size());
-  EXPECT_EQ("en-US", languages[0]);
-}
-
-TEST_F(SpellcheckServiceTest, GetSpellCheckLanguages2) {
-  std::vector<std::string> accept_languages;
-  accept_languages.push_back("en-US");
-  accept_languages.push_back("en");
-  std::vector<std::string> languages;
-
-  SpellcheckService::GetSpellCheckLanguagesFromAcceptLanguages(
-      accept_languages, "en-US", &languages);
+class SpellcheckServiceUnitTest
+    : public testing::TestWithParam<SpellcheckLanguageTestCase> {
+ public:
+  SpellcheckServiceUnitTest()
+      : ui_thread_(content::BrowserThread::UI, &message_loop_){
+    user_prefs::UserPrefs::Set(&context_, &prefs_);
+  }
+  ~SpellcheckServiceUnitTest() override {}
 
-  EXPECT_EQ(1U, languages.size());
-  EXPECT_EQ("en-US", languages[0]);
-}
+  void SetUp() override {
+    prefs()->registry()->RegisterStringPref(prefs::kSpellCheckDictionary,
+                                            "spellcheck_dictionary");
+    prefs()->registry()->RegisterStringPref(prefs::kAcceptLanguages,
+                                            "accept_languages");
+  }
 
-TEST_F(SpellcheckServiceTest, GetSpellCheckLanguages3) {
-  std::vector<std::string> accept_languages;
-  accept_languages.push_back("en");
-  accept_languages.push_back("en-US");
-  accept_languages.push_back("en-AU");
-  std::vector<std::string> languages;
+  base::SupportsUserData* context() { return &context_; }
+  TestingPrefServiceSimple* prefs() { return &prefs_; }
 
-  SpellcheckService::GetSpellCheckLanguagesFromAcceptLanguages(
-      accept_languages, "en-US", &languages);
+ private:
+  TestSupportsUserData context_;
+  TestingPrefServiceSimple prefs_;
+  base::MessageLoop message_loop_;
+  content::TestBrowserThread ui_thread_;
 
-  EXPECT_EQ(2U, languages.size());
+  DISALLOW_COPY_AND_ASSIGN(SpellcheckServiceUnitTest);
+};
 
-  std::sort(languages.begin(), languages.end());
-  EXPECT_EQ("en-AU", languages[0]);
-  EXPECT_EQ("en-US", languages[1]);
+INSTANTIATE_TEST_CASE_P(
+    SpellcheckLanguageTestCases,
+    SpellcheckServiceUnitTest,
+    testing::Values(
+        SpellcheckLanguageTestCase("en-US", "en,en-US", 1UL, "en-US"),
+        SpellcheckLanguageTestCase("en-US", "en-US,en", 1UL, "en-US"),
+        SpellcheckLanguageTestCase("en-US",
+                                   "en,fr,en-US,en-AU",
+                                   1UL,
+                                   "en-US,fr,en-AU"),
+        SpellcheckLanguageTestCase("fr",
+                                   "en,en-JP,fr,zz,en-US",
+                                   1UL,
+                                   "fr,en-US")));
+
+TEST_P(SpellcheckServiceUnitTest, GetSpellcheckLanguages) {
+  prefs()->SetString(prefs::kSpellCheckDictionary,
+                     GetParam().spellcheck_dictionaries);
+  prefs()->SetString(prefs::kAcceptLanguages, GetParam().accept_languages);
+
+  std::vector<std::string> spellcheck_languages;
+  size_t enabled_spellcheck_languages =
+      SpellcheckService::GetSpellCheckLanguages(
+          context(),
+          &spellcheck_languages);
+
+  EXPECT_EQ(GetParam().num_expected_enabled_spellcheck_languages,
+            enabled_spellcheck_languages);
+  EXPECT_EQ(GetParam().expected_spellcheck_languages, spellcheck_languages);
 }
 
-TEST_F(SpellcheckServiceTest, GetSpellCheckLanguages4) {
-  std::vector<std::string> accept_languages;
-  accept_languages.push_back("en");
-  accept_languages.push_back("en-US");
-  accept_languages.push_back("fr");
-  std::vector<std::string> languages;
+class MultilingualSpellcheckServiceUnitTest : public SpellcheckServiceUnitTest {
+ public:
+  MultilingualSpellcheckServiceUnitTest() {}
+  ~MultilingualSpellcheckServiceUnitTest() override {}
 
-  SpellcheckService::GetSpellCheckLanguagesFromAcceptLanguages(
-      accept_languages, "en-US", &languages);
-
-  EXPECT_EQ(2U, languages.size());
-
-  std::sort(languages.begin(), languages.end());
-  EXPECT_EQ("en-US", languages[0]);
-  EXPECT_EQ("fr", languages[1]);
-}
-
-TEST_F(SpellcheckServiceTest, GetSpellCheckLanguages5) {
-  std::vector<std::string> accept_languages;
-  accept_languages.push_back("en");
-  accept_languages.push_back("en-JP");  // Will not exist.
-  accept_languages.push_back("fr");
-  accept_languages.push_back("aa");  // Will not exist.
-  std::vector<std::string> languages;
+  void SetUp() override {
+    prefs()->registry()->RegisterStringPref(prefs::kSpellCheckDictionaries,
+                                            "spellcheck_dictionary");
+    prefs()->registry()->RegisterStringPref(prefs::kAcceptLanguages,
+                                            "accept_languages");
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kEnableMultilingualSpellChecker);
+  }
 
-  SpellcheckService::GetSpellCheckLanguagesFromAcceptLanguages(
-      accept_languages, "fr", &languages);
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MultilingualSpellcheckServiceUnitTest);
+};
 
-  EXPECT_EQ(1U, languages.size());
-  EXPECT_EQ("fr", languages[0]);
+INSTANTIATE_TEST_CASE_P(
+    MultilingualSpellcheckLanguageTestCases,
+    MultilingualSpellcheckServiceUnitTest,
+    testing::Values(
+        SpellcheckLanguageTestCase("en-US", "en,en-US", 1UL, "en-US"),
+        SpellcheckLanguageTestCase("en-US", "en-US,en", 1UL, "en-US"),
+        SpellcheckLanguageTestCase("en-US,fr",
+                                   "en,fr,en-US,en-AU",
+                                   2UL,
+                                   "en-US,fr,en-AU"),
+        SpellcheckLanguageTestCase("fr",
+                                   "en,en-JP,fr,zz,en-US",
+                                   1UL,
+                                   "fr,en-US")));
+
+TEST_P(MultilingualSpellcheckServiceUnitTest, GetSpellcheckLanguages) {
+  prefs()->SetString(prefs::kSpellCheckDictionaries,
+                     GetParam().spellcheck_dictionaries);
+  prefs()->SetString(prefs::kAcceptLanguages, GetParam().accept_languages);
+
+  std::vector<std::string> spellcheck_languages;
+  size_t enabled_spellcheck_languages =
+      SpellcheckService::GetSpellCheckLanguages(context(),
+                                                &spellcheck_languages);
+
+  EXPECT_EQ(GetParam().num_expected_enabled_spellcheck_languages,
+            enabled_spellcheck_languages);
+  EXPECT_EQ(GetParam().expected_spellcheck_languages, spellcheck_languages);
 }