Merge 174304

chrome/common/spellcheck_common.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/common/spellcheck_common.h"
 
 #include "base/file_path.h"
 
 namespace chrome {
 namespace spellcheck_common {
 
-static const struct {
-  // The language.
-  const char* language;
+struct LanguageRegion {
+  const char* language;  // The language.
+  const char* language_region;  // language & region, used by dictionaries.
+};
 
-  // The corresponding language and region, used by the dictionaries.
-  const char* language_region;
-} g_supported_spellchecker_languages[] = {
+struct LanguageVersion {
+  const char* language;  // The language input.
+  const char* version;   // The corresponding version.
+};
+
+static const LanguageRegion g_supported_spellchecker_languages[] = {
   // Several languages are not to be included in the spellchecker list:
   // th-TH
   {"af", "af-ZA"},
   {"bg", "bg-BG"},
   {"ca", "ca-ES"},
   {"cs", "cs-CZ"},
   {"da", "da-DK"},
   {"de", "de-DE"},
   {"el", "el-GR"},
   {"en-AU", "en-AU"},
@@ skipping 22 matching lines @@
   {"sk", "sk-SK"},
   {"sl", "sl-SI"},
   {"sh", "sh"},
   {"sr", "sr"},
   {"sv", "sv-SE"},
   {"tr", "tr-TR"},
   {"uk", "uk-UA"},
   {"vi", "vi-VN"},
 };
 
+bool IsValidRegion(const std::string& region) {
+  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages);
+       ++i) {
+    if (g_supported_spellchecker_languages[i].language_region == region)
+      return true;
+  }
+  return false;
+}
+
 // This function returns the language-region version of language name.
 // e.g. returns hi-IN for hi.
 std::string GetSpellCheckLanguageRegion(const std::string& input_language) {
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
+  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages);
        ++i) {
     if (g_supported_spellchecker_languages[i].language == input_language) {
       return std::string(
           g_supported_spellchecker_languages[i].language_region);
     }
   }
 
   return input_language;
 }
 
 FilePath GetVersionedFileName(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";
 
-  static const struct {
-    // The language input.
-    const char* language;
-
-    // The corresponding version.
-    const char* version;
-  } special_version_string[] = {
+  static LanguageVersion special_version_string[] = {
     {"es-ES", "-1-1"},  // 1-1: Have not been augmented with addtional words.
     {"nl-NL", "-1-1"},
     {"sv-SE", "-1-1"},
     {"he-IL", "-1-1"},
     {"el-GR", "-1-1"},
     {"hi-IN", "-1-1"},
     {"tr-TR", "-1-1"},
     {"et-EE", "-1-1"},
     {"lt-LT", "-1-3"},  // 1-3 (Feb 2009): new words, as well as an upgraded
                         // dictionary.
@@ skipping 16 matching lines @@
     {"en-GB", "-2-5"},  // 2-5 (Nov 2012): Added NOSUGGEST flag = !.
     {"en-AU", "-2-5"},  // Marked 1 word in each.
 
   };
 
   // Generate the bdict file name using default version string or special
   // version string, depending on the language.
   std::string language = GetSpellCheckLanguageRegion(input_language);
   std::string versioned_bdict_file_name(language + kDefaultVersionString +
                                         ".bdic");
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(special_version_string); ++i) {
+  for (size_t i = 0; i < arraysize(special_version_string); ++i) {
     if (language == special_version_string[i].language) {
       versioned_bdict_file_name =
           language + special_version_string[i].version + ".bdic";
       break;
     }
   }
 
   return dict_dir.AppendASCII(versioned_bdict_file_name);
 }
 
 std::string GetCorrespondingSpellCheckLanguage(const std::string& language) {
   // Look for exact match in the Spell Check language list.
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
+  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages);
        ++i) {
     // First look for exact match in the language region of the list.
     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.
     std::string spellcheck_language_region(
         g_supported_spellchecker_languages[i].language_region);
     if (spellcheck_language_region == language)
       return g_supported_spellchecker_languages[i].language;
   }
 
   // No match found - return blank.
   return std::string();
 }
 
 void SpellCheckLanguages(std::vector<std::string>* languages) {
-  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(g_supported_spellchecker_languages);
+  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages);
        ++i) {
     languages->push_back(g_supported_spellchecker_languages[i].language);
   }
 }
 
 }  // namespace spellcheck_common
 }  // namespace chrome