[chromium-reviews] Change the use of "Language" in Spell Check files to "SpellCheckLanguage". "L...

chrome/browser/spellchecker.cc

 // Copyright (c) 2006-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 "app/l10n_util.h"
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/spellchecker_common.h"
 #include "chrome/browser/spellchecker_platform_engine.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 61 matching lines @@
   {"ca", "ca-ES"},
   {"lv", "lv-LV"},
   // {"uk", "uk-UA"}, // Not to be included in Spellchecker as per B=1277824
   {"hi", "hi-IN"},
   {"et", "et-EE"},
   {"tr", "tr-TR"},
 };
 
 }
 
-void SpellChecker::SpellCheckLanguages(Languages* languages) {
+void SpellChecker::SpellCheckLanguages(std::vector<std::string>* languages) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
        ++i)
     languages->push_back(g_supported_spellchecker_languages[i].language);
 }
 
 // This function returns the language-region version of language name.
 // e.g. returns hi-IN for hi.
-SpellChecker::Language SpellChecker::GetSpellCheckLanguageRegion(
-    Language input_language) {
+std::string SpellChecker::GetSpellCheckLanguageRegion(
+    std::string input_language) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
        ++i) {
-    Language language(g_supported_spellchecker_languages[i].language);
+    std::string language(
+        g_supported_spellchecker_languages[i].language);
     if (language ==  input_language)
-      return Language(g_supported_spellchecker_languages[i].language_region);
+      return std::string(
+          g_supported_spellchecker_languages[i].language_region);
   }
 
   return input_language;
 }
 
 
-SpellChecker::Language SpellChecker::GetLanguageFromLanguageRegion(
-    Language input_language) {
+std::string SpellChecker::GetLanguageFromLanguageRegion(
+    std::string input_language) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
        ++i) {
-    Language language(g_supported_spellchecker_languages[i].language_region);
+    std::string language(
+        g_supported_spellchecker_languages[i].language_region);
     if (language ==  input_language)
-      return Language(g_supported_spellchecker_languages[i].language);
+      return std::string(g_supported_spellchecker_languages[i].language);
   }
 
   return input_language;
 }
 
-SpellChecker::Language SpellChecker::GetCorrespondingSpellCheckLanguage(
-    const Language& language) {
+std::string SpellChecker::
+    GetCorrespondingSpellCheckLanguage(const std::string& language) {

[brettw, 2009/07/01 23:11:34]

Can you wrap this like it used to be?

   // Look for exact match in the Spell Check language list.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
        ++i) {
     // First look for exact match in the language region of the list.
-    Language spellcheck_language(
+    std::string spellcheck_language(
         g_supported_spellchecker_languages[i].language);
     if (spellcheck_language == language)
       return language;
 
     // Next, look for exact match in the language_region part of the list.
-    Language spellcheck_language_region(
+    std::string spellcheck_language_region(
         g_supported_spellchecker_languages[i].language_region);
     if (spellcheck_language_region == language)
       return g_supported_spellchecker_languages[i].language;
   }
 
   // Look for a match by comparing only language parts. All the 'en-RR'
   // except for 'en-GB' exactly matched in the above loop, will match
   // 'en-US'. This is not ideal because 'en-ZA', 'en-NZ' had
   // better be matched with 'en-GB'. This does not handle cases like
   // 'az-Latn-AZ' vs 'az-Arab-AZ', either, but we don't use 3-part
   // locale ids with a script code in the middle, yet.
   // TODO(jungshik): Add a better fallback.
-  Language language_part(language, 0, language.find('-'));
+  std::string language_part(language, 0, language.find('-'));
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
        ++i) {
-    Language spellcheck_language(
+    std::string spellcheck_language(
         g_supported_spellchecker_languages[i].language_region);
     if (spellcheck_language.substr(0, spellcheck_language.find('-')) ==
         language_part)
       return spellcheck_language;
   }
 
   // No match found - return blank.
-  return Language();
+  return std::string();
 }
 
 int SpellChecker::GetSpellCheckLanguages(
     Profile* profile,
-    Languages* languages) {
+    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.
-  Languages accept_languages;
+  std::vector<std::string> accept_languages;
   SplitString(WideToASCII(accept_languages_pref.GetValue()), ',',
               &accept_languages);
-  for (Languages::const_iterator i = accept_languages.begin();
+  for (std::vector<std::string>::const_iterator i = accept_languages.begin();
        i != accept_languages.end(); ++i) {
     std::string language = 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)
@@ skipping 139 matching lines @@
 };
 
 void SpellChecker::set_file_is_downloading(bool value) {
   dic_is_downloading_ = value;
 }
 
 // ################################################################
 // This part of the code is used for spell checking.
 // ################################################################
 
-FilePath SpellChecker::GetVersionedFileName(const Language& input_language,
-                                            const FilePath& dict_dir) {
+FilePath SpellChecker::GetVersionedFileName(

[brettw, 2009/07/01 23:11:34]

I think the old wrapping was better here.

+    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;
@@ skipping 27 matching lines @@
       versioned_bdict_file_name =
           language + special_version_string[i].version + ".bdic";
       break;
     }
   }
 
   return dict_dir.AppendASCII(versioned_bdict_file_name);
 }
 
 SpellChecker::SpellChecker(const FilePath& dict_dir,
-                           const Language& language,
+                           const std::string& language,
                            URLRequestContext* request_context,
                            const FilePath& custom_dictionary_file_name)
     : custom_dictionary_file_name_(custom_dictionary_file_name),
       tried_to_init_(false),
 #ifndef NDEBUG
       worker_loop_(NULL),
 #endif
       tried_to_download_(false),
       file_loop_(NULL),
       url_request_context_(request_context),
@@ skipping 330 matching lines @@
 
   // Populate the vector of WideStrings.
   for (int i = 0; i < number_of_suggestions; i++) {
     if (i < kMaxSuggestions)
       optional_suggestions->push_back(UTF8ToWide(suggestions[i]));
     free(suggestions[i]);
   }
   if (suggestions != NULL)
     free(suggestions);
 }