Componentize spellcheck [4]: spellcheck/browser and android java-side.

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 "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/prefs/pref_service.h"
+#include "components/spellcheck/browser/pref_names.h"
 #include "components/spellcheck/common/spellcheck_common.h"
 #include "components/spellcheck/common/spellcheck_result.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"
 
 namespace {
 
 // The URL for requesting spell checking and sending user feedback.
 const char kSpellingServiceURL[] = "https://www.googleapis.com/rpc";
 
 // The location of spellcheck suggestions in JSON response from spelling
 // service.
 const char kMisspellingsPath[] = "result.spellingCheckResponse.misspellings";
 
 // The location of error messages in JSON response from spelling service.
 const char kErrorPath[] = "error";
 
 // Languages currently supported by SPELLCHECK.
 const char* const kValidLanguages[] = {"en", "es", "fi", "da"};
 
 }  // namespace
 
-SpellingServiceClient::SpellingServiceClient() {
-}
+SpellingServiceClient::SpellingServiceClient() {}
 
 SpellingServiceClient::~SpellingServiceClient() {
   base::STLDeleteContainerPairPointers(spellcheck_fetchers_.begin(),
                                        spellcheck_fetchers_.end());
 }
 
 bool SpellingServiceClient::RequestTextCheck(
     content::BrowserContext* context,
     ServiceType type,
     const base::string16& text,
     const TextCheckCompleteCallback& callback) {
   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;
   spellcheck::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;
@@ skipping 10 matching lines @@
       "\"apiVersion\":\"v%d\","
       "\"params\":{"
       "\"text\":%s,"
       "\"language\":\"%s\","
       "\"originCountry\":\"%s\","
       "\"key\":%s"
       "}"
       "}";
   std::string api_key = base::GetQuotedJSONString(google_apis::GetAPIKey());
   std::string request = base::StringPrintf(
-      kSpellingRequest,
-      type,
-      encoded_text.c_str(),
-      language_code.c_str(),
-      country_code.c_str(),
-      api_key.c_str());
+      kSpellingRequest, type, encoded_text.c_str(), language_code.c_str(),
+      country_code.c_str(), api_key.c_str());
 
   GURL url = GURL(kSpellingServiceURL);
   net::URLFetcher* fetcher = CreateURLFetcher(url).release();
   data_use_measurement::DataUseUserData::AttachToFetcher(
       fetcher, data_use_measurement::DataUseUserData::SPELL_CHECKER);
   fetcher->SetRequestContext(
-      content::BrowserContext::GetDefaultStoragePartition(context)->
-          GetURLRequestContext());
+      content::BrowserContext::GetDefaultStoragePartition(context)
+          ->GetURLRequestContext());
   fetcher->SetUploadData("application/json", request);
-  fetcher->SetLoadFlags(
-      net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES);
+  fetcher->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
+                        net::LOAD_DO_NOT_SAVE_COOKIES);
   spellcheck_fetchers_[fetcher] = new TextCheckCallbackData(callback, text);
   fetcher->Start();
   return true;
 }
 
-bool SpellingServiceClient::IsAvailable(
-    content::BrowserContext* context,
-    ServiceType type) {
+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 80 matching lines @@
         !misspelling->GetList("suggestions", &suggestions)) {
       return false;
     }
 
     base::DictionaryValue* suggestion = NULL;
     base::string16 replacement;
     if (!suggestions->GetDictionary(0, &suggestion) ||
         !suggestion->GetString("suggestion", &replacement)) {
       return false;
     }
-    SpellCheckResult result(
-        SpellCheckResult::SPELLING, start, length, replacement);
+    SpellCheckResult result(SpellCheckResult::SPELLING, start, length,
+                            replacement);
     results->push_back(result);
   }
   return true;
 }
 
 SpellingServiceClient::TextCheckCallbackData::TextCheckCallbackData(
     TextCheckCompleteCallback callback,
     base::string16 text)
-      : callback(callback),
-        text(text) {
-}
+    : callback(callback), text(text) {}
 
-SpellingServiceClient::TextCheckCallbackData::~TextCheckCallbackData() {
-}
+SpellingServiceClient::TextCheckCallbackData::~TextCheckCallbackData() {}
 
-void SpellingServiceClient::OnURLFetchComplete(
-    const net::URLFetcher* source) {
+void SpellingServiceClient::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(spellcheck_fetchers_[source]);
   std::unique_ptr<const net::URLFetcher> fetcher(source);
   std::unique_ptr<TextCheckCallbackData> callback_data(
       spellcheck_fetchers_[fetcher.get()]);
   bool success = false;
   std::vector<SpellCheckResult> results;
   if (fetcher->GetResponseCode() / 100 == 2) {
     std::string data;
     fetcher->GetResponseAsString(&data);
     success = ParseResponse(data, &results);
   }
   spellcheck_fetchers_.erase(fetcher.get());
 
   // 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);
 }