Refactor dependency on Profile to BrowserContext in spell check.

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 "base/platform_file.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_split.h"
 #include "base/synchronization/waitable_event.h"
-#include "chrome/browser/profiles/profile.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_mac.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/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 "ipc/ipc_platform_file.h"
 
 using content::BrowserThread;
 using chrome::spellcheck_common::WordList;
 
 // TODO(rlp): I do not like globals, but keeping these for now during
 // transition.
 // An event used by browser tests to receive status events from this class and
 // its derived classes.
 base::WaitableEvent* g_status_event = NULL;
 SpellcheckService::EventType g_status_type =
     SpellcheckService::BDICT_NOTINITIALIZED;
 
-SpellcheckService::SpellcheckService(Profile* profile)
-    : profile_(profile),
+SpellcheckService::SpellcheckService(content::BrowserContext* context)
+    : context_(context),
       weak_ptr_factory_(this) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  PrefService* prefs = profile_->GetPrefs();
+  PrefService* prefs = user_prefs::UserPrefs::Get(context);
   pref_change_registrar_.Init(prefs);
 
   std::string language_code;
   std::string country_code;
   chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
       prefs->GetString(prefs::kSpellCheckDictionary),
       &language_code,
       &country_code);
   feedback_sender_.reset(new spellcheck::FeedbackSender(
-      profile->GetRequestContext(), language_code, country_code));
+      context->GetRequestContext(), language_code, country_code));
 
   pref_change_registrar_.Add(
       prefs::kEnableAutoSpellCorrect,
       base::Bind(&SpellcheckService::OnEnableAutoSpellCorrectChanged,
                  base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kSpellCheckDictionary,
       base::Bind(&SpellcheckService::OnSpellCheckDictionaryChanged,
                  base::Unretained(this)));
  pref_change_registrar_.Add(
      prefs::kSpellCheckUseSpellingService,
      base::Bind(&SpellcheckService::OnUseSpellingServiceChanged,
                 base::Unretained(this)));
   pref_change_registrar_.Add(
       prefs::kEnableContinuousSpellcheck,
       base::Bind(&SpellcheckService::InitForAllRenderers,
                  base::Unretained(this)));
 
   OnSpellCheckDictionaryChanged();
 
-  custom_dictionary_.reset(new SpellcheckCustomDictionary(profile_->GetPath()));
+  custom_dictionary_.reset(new SpellcheckCustomDictionary(context_->GetPath()));
   custom_dictionary_->AddObserver(this);
   custom_dictionary_->Load();
 
   registrar_.Add(this,
                  content::NOTIFICATION_RENDERER_PROCESS_CREATED,
                  content::NotificationService::AllSources());
 }
 
 SpellcheckService::~SpellcheckService() {
   // Remove pref observers
   pref_change_registrar_.RemoveAll();
 }
 
 // static
 int SpellcheckService::GetSpellCheckLanguages(
-    Profile* profile,
+    content::BrowserContext* context,
     std::vector<std::string>* languages) {
+  PrefService* prefs = user_prefs::UserPrefs::Get(context);
   StringPrefMember accept_languages_pref;
   StringPrefMember dictionary_language_pref;
-  accept_languages_pref.Init(prefs::kAcceptLanguages, profile->GetPrefs());
-  dictionary_language_pref.Init(prefs::kSpellCheckDictionary,
-                                profile->GetPrefs());
+  accept_languages_pref.Init(prefs::kAcceptLanguages, prefs);
+  dictionary_language_pref.Init(prefs::kSpellCheckDictionary, prefs);
   std::string dictionary_language = dictionary_language_pref.GetValue();
 
   // Now scan through the list of accept languages, and find possible mappings
   // from this list to the existing list of spell check languages.
   std::vector<std::string> accept_languages;
 
 #if defined(OS_MACOSX)
   if (spellcheck_mac::SpellCheckerAvailable())
     spellcheck_mac::GetAvailableLanguages(&accept_languages);
   else
@@ skipping 46 matching lines @@
 
 void SpellcheckService::StartRecordingMetrics(bool spellcheck_enabled) {
   metrics_.reset(new SpellCheckHostMetrics());
   metrics_->RecordEnabledStats(spellcheck_enabled);
   OnUseSpellingServiceChanged();
 }
 
 void SpellcheckService::InitForRenderer(content::RenderProcessHost* process) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  Profile* profile = Profile::FromBrowserContext(process->GetBrowserContext());
-  if (SpellcheckServiceFactory::GetForProfile(profile) != this)
+  content::BrowserContext* context = process->GetBrowserContext();
+  if (SpellcheckServiceFactory::GetForContext(context) != this)
     return;
 
-  PrefService* prefs = profile->GetPrefs();
+  PrefService* prefs = user_prefs::UserPrefs::Get(context);
   IPC::PlatformFileForTransit file = IPC::InvalidPlatformFileForTransit();
 
   if (hunspell_dictionary_->GetDictionaryFile() !=
       base::kInvalidPlatformFileValue) {
 #if defined(OS_POSIX)
     file = base::FileDescriptor(hunspell_dictionary_->GetDictionaryFile(),
                                 false);
 #elif defined(OS_WIN)
     BOOL ok = ::DuplicateHandle(::GetCurrentProcess(),
                                 hunspell_dictionary_->GetDictionaryFile(),
@@ skipping 110 matching lines @@
            content::RenderProcessHost::AllHostsIterator());
        !i.IsAtEnd(); i.Advance()) {
     content::RenderProcessHost* process = i.GetCurrentValue();
     process->Send(new SpellCheckMsg_EnableAutoSpellCorrect(enabled));
   }
 }
 
 void SpellcheckService::OnSpellCheckDictionaryChanged() {
   if (hunspell_dictionary_.get())
     hunspell_dictionary_->RemoveObserver(this);
+  PrefService* prefs = user_prefs::UserPrefs::Get(context_);
+  DCHECK(prefs);
+
   std::string dictionary =
-      profile_->GetPrefs()->GetString(prefs::kSpellCheckDictionary);
+      prefs->GetString(prefs::kSpellCheckDictionary);
   hunspell_dictionary_.reset(new SpellcheckHunspellDictionary(
-      dictionary, profile_->GetRequestContext(), this));
+      dictionary, context_->GetRequestContext(), this));
   hunspell_dictionary_->AddObserver(this);
   hunspell_dictionary_->Load();
   std::string language_code;
   std::string country_code;
   chrome::spellcheck_common::GetISOLanguageCountryCodeFromLocale(
       dictionary, &language_code, &country_code);
   feedback_sender_->OnLanguageCountryChange(language_code, country_code);
 }
 
 void SpellcheckService::OnUseSpellingServiceChanged() {
   bool enabled = pref_change_registrar_.prefs()->GetBoolean(
       prefs::kSpellCheckUseSpellingService);
   if (metrics_)
     metrics_->RecordSpellingServiceStats(enabled);
 }