Componentize spellcheck [2]: move common/ files to component.

components/spellcheck/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 "components/spellcheck/common/spellcheck_common.h"
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
-#include "chrome/common/chrome_switches.h"
 #include "third_party/icu/source/common/unicode/uloc.h"
 #include "third_party/icu/source/common/unicode/urename.h"
 #include "third_party/icu/source/common/unicode/utypes.h"
 
-namespace chrome {
-namespace spellcheck_common {
+namespace spellcheck {
 
 struct LanguageRegion {
-  const char* language;  // The language.
+  const char* language;         // The language.
   const char* language_region;  // language & region, used by dictionaries.
 };
 
 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:
@@ skipping 42 matching lines @@
   {"sr", "sr"},
   {"sv", "sv-SE"},
   {"ta", "ta-IN"},
   {"tg", "tg-TG"},
   {"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) {
+  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(g_supported_spellchecker_languages);
-       ++i) {
+  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 std::string(g_supported_spellchecker_languages[i].language_region);
     }
   }
 
   return input_language;
 }
 
 base::FilePath GetVersionedFileName(const std::string& input_language,
                                     const base::FilePath& dict_dir) {
   // The default dictionary version is 3-0. This version indicates that the bdic
   // file contains a checksum.
@@ skipping 29 matching lines @@
       break;
     }
   }
 
   return dict_dir.AppendASCII(versioned_bdict_file_name);
 }
 
 std::string GetCorrespondingSpellCheckLanguage(const std::string& language) {
   std::string best_match;
   // Look for exact match in the Spell Check language list.
-  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages);
-       ++i) {
+  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) {
       if (best_match.empty())
         best_match = g_supported_spellchecker_languages[i].language;
     }
   }
 
   // No match found - return best match, if any.
   return best_match;
 }
 
 void SpellCheckLanguages(std::vector<std::string>* languages) {
-  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages);
-       ++i) {
+  for (size_t i = 0; i < arraysize(g_supported_spellchecker_languages); ++i) {
     languages->push_back(g_supported_spellchecker_languages[i].language);
   }
 }
 
 void GetISOLanguageCountryCodeFromLocale(const std::string& locale,
                                          std::string* language_code,
                                          std::string* country_code) {
   DCHECK(language_code);
   DCHECK(country_code);
   char language[ULOC_LANG_CAPACITY] = ULOC_ENGLISH;
   const char* country = "USA";
   if (!locale.empty()) {
     UErrorCode error = U_ZERO_ERROR;
     char id[ULOC_LANG_CAPACITY + ULOC_SCRIPT_CAPACITY + ULOC_COUNTRY_CAPACITY];
     uloc_addLikelySubtags(locale.c_str(), id, arraysize(id), &error);
     error = U_ZERO_ERROR;
     uloc_getLanguage(id, language, arraysize(language), &error);
     country = uloc_getISO3Country(id);
   }
   *language_code = std::string(language);
   *country_code = std::string(country);
 }
 
-}  // namespace spellcheck_common
-}  // namespace chrome
+}  // namespace spellcheck