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

chrome/browser/spellchecker/spellcheck_service.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 <set>
 
 #include "base/logging.h"
 #include "base/strings/string_split.h"
 #include "base/supports_user_data.h"
 #include "base/synchronization/waitable_event.h"
 #include "build/build_config.h"
 #include "chrome/browser/spellchecker/feedback_sender.h"
 #include "chrome/browser/spellchecker/spellcheck_factory.h"
 #include "chrome/browser/spellchecker/spellcheck_host_metrics.h"
 #include "chrome/browser/spellchecker/spellcheck_hunspell_dictionary.h"
 #include "chrome/browser/spellchecker/spellcheck_platform.h"
 #include "chrome/browser/spellchecker/spelling_service_client.h"
 #include "chrome/common/pref_names.h"
-#include "chrome/common/spellcheck_bdict_language.h"
-#include "chrome/common/spellcheck_common.h"
-#include "chrome/common/spellcheck_messages.h"
 #include "components/prefs/pref_member.h"
 #include "components/prefs/pref_service.h"
+#include "components/spellcheck/common/spellcheck_bdict_language.h"
+#include "components/spellcheck/common/spellcheck_common.h"
+#include "components/spellcheck/common/spellcheck_messages.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/storage_partition.h"
 #include "ipc/ipc_platform_file.h"
 
 using content::BrowserThread;
@@ skipping 40 matching lines @@
     first_of_dictionaries = single_dictionary;
     dictionaries_pref.SetValue(
         std::vector<std::string>(1, first_of_dictionaries));
   }
 
   single_dictionary_pref.SetValue("");
 #endif  // defined(USE_BROWSER_SPELLCHECKER)
 
   std::string language_code;
   std::string country_code;
-  chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
-      first_of_dictionaries,
-      &language_code,
-      &country_code);
+  spellcheck::GetISOLanguageCountryCodeFromLocale(
+      first_of_dictionaries, &language_code, &country_code);
   feedback_sender_.reset(new spellcheck::FeedbackSender(
       content::BrowserContext::GetDefaultStoragePartition(context)->
             GetURLRequestContext(),
       language_code, country_code));
 
   pref_change_registrar_.Add(
       prefs::kSpellCheckDictionaries,
       base::Bind(&SpellcheckService::OnSpellCheckDictionariesChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
@@ skipping 42 matching lines @@
       spellcheck_dictionaries.insert(dictionary);
   }
 
   dictionaries->clear();
   std::vector<std::string> accept_languages =
       base::SplitString(prefs->GetString(prefs::kAcceptLanguages), ",",
                         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   for (const auto& accept_language : accept_languages) {
     Dictionary dictionary;
     dictionary.language =
-        chrome::spellcheck_common::GetCorrespondingSpellCheckLanguage(
-            accept_language);
+        spellcheck::GetCorrespondingSpellCheckLanguage(accept_language);
     if (dictionary.language.empty())
       continue;
 
     dictionary.used_for_spellcheck =
         spellcheck_dictionaries.count(dictionary.language) > 0;
     dictionaries->push_back(dictionary);
   }
 }
 #endif  // !OS_MACOSX
 
@@ skipping 176 matching lines @@
   if (metrics_)
     metrics_->RecordSpellingServiceStats(enabled);
   UpdateFeedbackSenderState();
 }
 
 void SpellcheckService::OnAcceptLanguagesChanged() {
   PrefService* prefs = user_prefs::UserPrefs::Get(context_);
   std::vector<std::string> accept_languages =
       base::SplitString(prefs->GetString(prefs::kAcceptLanguages), ",",
                         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-  std::transform(
-      accept_languages.begin(), accept_languages.end(),
-      accept_languages.begin(),
-      &chrome::spellcheck_common::GetCorrespondingSpellCheckLanguage);
+  std::transform(accept_languages.begin(), accept_languages.end(),
+                 accept_languages.begin(),
+                 &spellcheck::GetCorrespondingSpellCheckLanguage);
 
   StringListPrefMember dictionaries_pref;
   dictionaries_pref.Init(prefs::kSpellCheckDictionaries, prefs);
   std::vector<std::string> dictionaries = dictionaries_pref.GetValue();
   std::vector<std::string> filtered_dictionaries;
 
   for (const auto& dictionary : dictionaries) {
     if (std::find(accept_languages.begin(), accept_languages.end(),
                   dictionary) != accept_languages.end()) {
       filtered_dictionaries.push_back(dictionary);
     }
   }
 
   dictionaries_pref.SetValue(filtered_dictionaries);
 }
 
 void SpellcheckService::UpdateFeedbackSenderState() {
   std::string feedback_language;
   if (!hunspell_dictionaries_.empty())
     feedback_language = hunspell_dictionaries_.front()->GetLanguage();
   std::string language_code;
   std::string country_code;
-  chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
+  spellcheck::GetISOLanguageCountryCodeFromLocale(
       feedback_language, &language_code, &country_code);
   feedback_sender_->OnLanguageCountryChange(language_code, country_code);
   if (SpellingServiceClient::IsAvailable(
           context_, SpellingServiceClient::SPELLCHECK)) {
     feedback_sender_->StartFeedbackCollection();
   } else {
     feedback_sender_->StopFeedbackCollection();
   }
 }