Refactor dependency on Profile to BrowserContext in spell check.

chrome/browser/spellchecker/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 "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/prefs/pref_service.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/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/spellcheck_common.h"
 #include "chrome/common/spellcheck_result.h"
+#include "components/user_prefs/user_prefs.h"
+#include "content/public/browser/browser_context.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";
 
 }  // namespace
 
 SpellingServiceClient::SpellingServiceClient() {
 }
 
 SpellingServiceClient::~SpellingServiceClient() {
   STLDeleteContainerPairPointers(spellcheck_fetchers_.begin(),
                                  spellcheck_fetchers_.end());
 }
 
 bool SpellingServiceClient::RequestTextCheck(
-    Profile* profile,
+    content::BrowserContext* context,
     ServiceType type,
     const string16& text,
     const TextCheckCompleteCallback& callback) {
   DCHECK(type == SUGGEST || type == SPELLCHECK);
-  if (!profile || !IsAvailable(profile, type)) {
+  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 language_code;
   std::string country_code;
   chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
-      profile->GetPrefs()->GetString(prefs::kSpellCheckDictionary),
+      pref->GetString(prefs::kSpellCheckDictionary),
       &language_code,
       &country_code);
 
   // Format the JSON request to be sent to the Spelling service.
   std::string encoded_text;
   base::JsonDoubleQuote(text, false, &encoded_text);
 
   static const char kSpellingRequest[] =
       "{"
       "\"method\":\"spelling.check\","
       "\"apiVersion\":\"v%d\","
       "\"params\":{"
       "\"text\":\"%s\","
       "\"language\":\"%s\","
       "\"originCountry\":\"%s\","
       "\"key\":%s"
       "}"
       "}";
   std::string api_key = base::GetDoubleQuotedJson(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());
 
   GURL url = GURL(kSpellingServiceURL);
   net::URLFetcher* fetcher = CreateURLFetcher(url);
-  fetcher->SetRequestContext(profile->GetRequestContext());
+  fetcher->SetRequestContext(context->GetRequestContext());
   fetcher->SetUploadData("application/json", request);
   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(Profile* profile, ServiceType type) {
-  const PrefService* pref = profile->GetPrefs();
-  // If prefs don't allow spellchecking or if the profile is off the record,
+bool SpellingServiceClient::IsAvailable(
+    content::BrowserContext* context,
+    ServiceType type) {
+  const PrefService* pref = user_prefs::UserPrefs::Get(context);
+  DCHECK(pref);
+  // If prefs don't allow spellchecking or if the context is off the record,
   // the spelling service should be unavailable.
   if (!pref->GetBoolean(prefs::kEnableContinuousSpellcheck) ||
       !pref->GetBoolean(prefs::kSpellCheckUseSpellingService) ||
-      profile->IsOffTheRecord())
+      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->GetString(prefs::kSpellCheckDictionary);
   if (locale.empty())
     return false;
 
   // If we do not have the spelling service enabled, then we are only available
   // for SUGGEST.
@@ skipping 129 matching lines @@
     fetcher->GetResponseAsString(&data);
     success = ParseResponse(data, &results);
   }
   callback_data->callback.Run(success, callback_data->text, results);
   spellcheck_fetchers_.erase(fetcher.get());
 }
 
 net::URLFetcher* SpellingServiceClient::CreateURLFetcher(const GURL& url) {
   return net::URLFetcher::Create(url, net::URLFetcher::POST, this);
 }