[WIP][DO NOT LAND] Componentize spellcheck

components/spellcheck/browser/spelling_service_client.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/spelling_service_client.h"
+#include "components/spellcheck/browser/spelling_service_client.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
 #include "base/json/json_reader.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
-#include "chrome/common/pref_names.h"
-#include "chrome/common/spellcheck_common.h"
-#include "chrome/common/spellcheck_result.h"
+#include "components/spellcheck/browser/pref_names.h"
+#include "components/spellcheck/common/spellcheck_common.h"
+#include "components/spellcheck/common/spellcheck_result.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/prefs/pref_service.h"
 #include "components/user_prefs/user_prefs.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/storage_partition.h"
 #include "google_apis/google_api_keys.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_fetcher.h"
 #include "url/gurl.h"
 
@@ skipping 30 matching lines @@
   DCHECK(type == SUGGEST || type == SPELLCHECK);
   if (!context || !IsAvailable(context, type)) {
     callback.Run(false, text, std::vector<SpellCheckResult>());
     return false;
   }
 
   const PrefService* pref = user_prefs::UserPrefs::Get(context);
   DCHECK(pref);
 
   std::string dictionary;
-  pref->GetList(prefs::kSpellCheckDictionaries)->GetString(0, &dictionary);
+  pref->GetList(spellcheck::prefs::kSpellCheckDictionaries)->GetString(0, &dictionary);
 
   std::string language_code;
   std::string country_code;
-  chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
+  spellcheck_common::GetISOLanguageCountryCodeFromLocale(
       dictionary, &language_code, &country_code);
 
   // Replace typographical apostrophes with typewriter apostrophes, so that
   // server word breaker behaves correctly.
   const base::char16 kApostrophe = 0x27;
   const base::char16 kRightSingleQuotationMark = 0x2019;
   base::string16 text_copy = text;
   std::replace(text_copy.begin(), text_copy.end(), kRightSingleQuotationMark,
                kApostrophe);
 
@@ skipping 36 matching lines @@
 }
 
 bool SpellingServiceClient::IsAvailable(
     content::BrowserContext* context,
     ServiceType type) {
   const PrefService* pref = user_prefs::UserPrefs::Get(context);
   DCHECK(pref);
   // If prefs don't allow spellchecking, if the context is off the record, or if
   // multilingual spellchecking is enabled the spelling service should be
   // unavailable.
-  if (!pref->GetBoolean(prefs::kEnableContinuousSpellcheck) ||
-      !pref->GetBoolean(prefs::kSpellCheckUseSpellingService) ||
+  if (!pref->GetBoolean(spellcheck::prefs::kEnableContinuousSpellcheck) ||
+      !pref->GetBoolean(spellcheck::prefs::kSpellCheckUseSpellingService) ||
       context->IsOffTheRecord())
     return false;
 
   // If the locale for spelling has not been set, the user has not decided to
   // use spellcheck so we don't do anything remote (suggest or spelling).
   std::string locale;
-  pref->GetList(prefs::kSpellCheckDictionaries)->GetString(0, &locale);
+  pref->GetList(spellcheck::prefs::kSpellCheckDictionaries)->GetString(0, &locale);
   if (locale.empty())
     return false;
 
   // Finally, if all options are available, we only enable only SUGGEST
   // if SPELLCHECK is not available for our language because SPELLCHECK results
   // are a superset of SUGGEST results.
   for (const char* language : kValidLanguages) {
     if (!locale.compare(0, 2, language))
       return type == SPELLCHECK;
   }
@@ skipping 121 matching lines @@
 
   // The callback may release the last (transitive) dependency on |this|. It
   // MUST be the last function called.
   callback_data->callback.Run(success, callback_data->text, results);
 }
 
 std::unique_ptr<net::URLFetcher> SpellingServiceClient::CreateURLFetcher(
     const GURL& url) {
   return net::URLFetcher::Create(url, net::URLFetcher::POST, this);
 }