1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/spellchecker/spelling_service_client.h" 6 7 #include "base/json/json_reader.h" 8 #include "base/json/string_escape.h" 9 #include "base/logging.h" 10 #include "base/prefs/pref_service.h" 11 #include "base/stl_util.h" 12 #include "base/strings/string_util.h" 13 #include "base/strings/stringprintf.h" 14 #include "base/strings/utf_string_conversions.h" 15 #include "base/values.h" 16 #include "chrome/common/pref_names.h" 17 #include "chrome/common/spellcheck_common.h" 18 #include "chrome/common/spellcheck_result.h" 19 #include "components/user_prefs/user_prefs.h" 20 #include "content/public/browser/browser_context.h" 21 #include "google_apis/google_api_keys.h" 22 #include "net/base/load_flags.h" 23 #include "net/url_request/url_fetcher.h" 24 #include "url/gurl.h" 25 26 namespace { 27 28 // The URL for requesting spell checking and sending user feedback. 29 const char kSpellingServiceURL[] = "https://www.googleapis.com/rpc"; 30 31 // The location of spellcheck suggestions in JSON response from spelling 32 // service. 33 const char kMisspellingsPath[] = "result.spellingCheckResponse.misspellings"; 34 35 // The location of error messages in JSON response from spelling service. 36 const char kErrorPath[] = "error"; 37 38 } // namespace 39 40 SpellingServiceClient::SpellingServiceClient() { 41 } 42 43 SpellingServiceClient::~SpellingServiceClient() { 44 STLDeleteContainerPairPointers(spellcheck_fetchers_.begin(), 45 spellcheck_fetchers_.end()); 46 } 47 48 bool SpellingServiceClient::RequestTextCheck( 49 content::BrowserContext* context, 50 ServiceType type, 51 const base::string16& text, 52 const TextCheckCompleteCallback& callback) { 53 DCHECK(type == SUGGEST || type == SPELLCHECK); 54 if (!context || !IsAvailable(context, type)) { 55 callback.Run(false, text, std::vector<SpellCheckResult>()); 56 return false; 57 } 58 59 const PrefService* pref = user_prefs::UserPrefs::Get(context); 60 DCHECK(pref); 61 62 std::string language_code; 63 std::string country_code; 64 chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale( 65 pref->GetString(prefs::kSpellCheckDictionary), 66 &language_code, 67 &country_code); 68 69 // Format the JSON request to be sent to the Spelling service. 70 std::string encoded_text = base::GetQuotedJSONString(text); 71 72 static const char kSpellingRequest[] = 73 "{" 74 "\"method\":\"spelling.check\"," 75 "\"apiVersion\":\"v%d\"," 76 "\"params\":{" 77 "\"text\":%s," 78 "\"language\":\"%s\"," 79 "\"originCountry\":\"%s\"," 80 "\"key\":%s" 81 "}" 82 "}"; 83 std::string api_key = base::GetQuotedJSONString(google_apis::GetAPIKey()); 84 std::string request = base::StringPrintf( 85 kSpellingRequest, 86 type, 87 encoded_text.c_str(), 88 language_code.c_str(), 89 country_code.c_str(), 90 api_key.c_str()); 91 92 GURL url = GURL(kSpellingServiceURL); 93 net::URLFetcher* fetcher = CreateURLFetcher(url); 94 fetcher->SetRequestContext(context->GetRequestContext()); 95 fetcher->SetUploadData("application/json", request); 96 fetcher->SetLoadFlags( 97 net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES); 98 spellcheck_fetchers_[fetcher] = new TextCheckCallbackData(callback, text); 99 fetcher->Start(); 100 return true; 101 } 102 103 bool SpellingServiceClient::IsAvailable( 104 content::BrowserContext* context, 105 ServiceType type) { 106 const PrefService* pref = user_prefs::UserPrefs::Get(context); 107 DCHECK(pref); 108 // If prefs don't allow spellchecking or if the context is off the record, 109 // the spelling service should be unavailable. 110 if (!pref->GetBoolean(prefs::kEnableContinuousSpellcheck) || 111 !pref->GetBoolean(prefs::kSpellCheckUseSpellingService) || 112 context->IsOffTheRecord()) 113 return false; 114 115 // If the locale for spelling has not been set, the user has not decided to 116 // use spellcheck so we don't do anything remote (suggest or spelling). 117 std::string locale = pref->GetString(prefs::kSpellCheckDictionary); 118 if (locale.empty()) 119 return false; 120 121 // Finally, if all options are available, we only enable only SUGGEST 122 // if SPELLCHECK is not available for our language because SPELLCHECK results 123 // are a superset of SUGGEST results. 124 // TODO(rlp): Only available for English right now. Fix this line to include 125 // all languages SPELLCHECK covers. 126 bool language_available = !locale.compare(0, 2, "en"); 127 if (language_available) { 128 return type == SPELLCHECK; 129 } else { 130 // Only SUGGEST is allowed. 131 return type == SUGGEST; 132 } 133 } 134 135 bool SpellingServiceClient::ParseResponse( 136 const std::string& data, 137 std::vector<SpellCheckResult>* results) { 138 // When this JSON-RPC call finishes successfully, the Spelling service returns 139 // an JSON object listed below. 140 // * result - an envelope object representing the result from the APIARY 141 // server, which is the JSON-API front-end for the Spelling service. This 142 // object consists of the following variable: 143 // - spellingCheckResponse (SpellingCheckResponse). 144 // * SpellingCheckResponse - an object representing the result from the 145 // Spelling service. This object consists of the following variable: 146 // - misspellings (optional array of Misspelling) 147 // * Misspelling - an object representing a misspelling region and its 148 // suggestions. This object consists of the following variables: 149 // - charStart (number) - the beginning of the misspelled region; 150 // - charLength (number) - the length of the misspelled region; 151 // - suggestions (array of string) - the suggestions for the misspelling 152 // text, and; 153 // - canAutoCorrect (optional boolean) - whether we can use the first 154 // suggestion for auto-correction. 155 // For example, the Spelling service returns the following JSON when we send a 156 // spelling request for "duck goes quisk" as of 16 August, 2011. 157 // { 158 // "result": { 159 // "spellingCheckResponse": { 160 // "misspellings": [{ 161 // "charStart": 10, 162 // "charLength": 5, 163 // "suggestions": [{ "suggestion": "quack" }], 164 // "canAutoCorrect": false 165 // }] 166 // } 167 // } 168 // } 169 // If the service is not available, the Spelling service returns JSON with an 170 // error. 171 // { 172 // "error": { 173 // "code": 400, 174 // "message": "Bad Request", 175 // "data": [...] 176 // } 177 // } 178 scoped_ptr<base::DictionaryValue> value( 179 static_cast<base::DictionaryValue*>( 180 base::JSONReader::Read(data, base::JSON_ALLOW_TRAILING_COMMAS))); 181 if (!value.get() || !value->IsType(base::Value::TYPE_DICTIONARY)) 182 return false; 183 184 // Check for errors from spelling service. 185 base::DictionaryValue* error = NULL; 186 if (value->GetDictionary(kErrorPath, &error)) 187 return false; 188 189 // Retrieve the array of Misspelling objects. When the input text does not 190 // have misspelled words, it returns an empty JSON. (In this case, its HTTP 191 // status is 200.) We just return true for this case. 192 base::ListValue* misspellings = NULL; 193 if (!value->GetList(kMisspellingsPath, &misspellings)) 194 return true; 195 196 for (size_t i = 0; i < misspellings->GetSize(); ++i) { 197 // Retrieve the i-th misspelling region and put it to the given vector. When 198 // the Spelling service sends two or more suggestions, we read only the 199 // first one because SpellCheckResult can store only one suggestion. 200 base::DictionaryValue* misspelling = NULL; 201 if (!misspellings->GetDictionary(i, &misspelling)) 202 return false; 203 204 int start = 0; 205 int length = 0; 206 base::ListValue* suggestions = NULL; 207 if (!misspelling->GetInteger("charStart", &start) || 208 !misspelling->GetInteger("charLength", &length) || 209 !misspelling->GetList("suggestions", &suggestions)) { 210 return false; 211 } 212 213 base::DictionaryValue* suggestion = NULL; 214 base::string16 replacement; 215 if (!suggestions->GetDictionary(0, &suggestion) || 216 !suggestion->GetString("suggestion", &replacement)) { 217 return false; 218 } 219 SpellCheckResult result( 220 SpellCheckResult::SPELLING, start, length, replacement); 221 results->push_back(result); 222 } 223 return true; 224 } 225 226 SpellingServiceClient::TextCheckCallbackData::TextCheckCallbackData( 227 TextCheckCompleteCallback callback, 228 base::string16 text) 229 : callback(callback), 230 text(text) { 231 } 232 233 SpellingServiceClient::TextCheckCallbackData::~TextCheckCallbackData() { 234 } 235 236 void SpellingServiceClient::OnURLFetchComplete( 237 const net::URLFetcher* source) { 238 DCHECK(spellcheck_fetchers_[source]); 239 scoped_ptr<const net::URLFetcher> fetcher(source); 240 scoped_ptr<TextCheckCallbackData> 241 callback_data(spellcheck_fetchers_[fetcher.get()]); 242 bool success = false; 243 std::vector<SpellCheckResult> results; 244 if (fetcher->GetResponseCode() / 100 == 2) { 245 std::string data; 246 fetcher->GetResponseAsString(&data); 247 success = ParseResponse(data, &results); 248 } 249 spellcheck_fetchers_.erase(fetcher.get()); 250 251 // The callback may release the last (transitive) dependency on |this|. It 252 // MUST be the last function called. 253 callback_data->callback.Run(success, callback_data->text, results); 254 } 255 256 net::URLFetcher* SpellingServiceClient::CreateURLFetcher(const GURL& url) { 257 return net::URLFetcher::Create(url, net::URLFetcher::POST, this); 258 } 259
