Eliminate the dependency of Profile from TtsMessageFilter.

chrome/browser/speech/tts_controller_impl.cc

 // Copyright 2014 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/speech/tts_controller_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/float_util.h"
@@ skipping 47 matching lines @@
 VoiceData::~VoiceData() {}
 
 
 //
 // Utterance
 //
 
 // static
 int Utterance::next_utterance_id_ = 0;
 
-Utterance::Utterance(Profile* profile)
-    : profile_(profile),
+Utterance::Utterance(content::BrowserContext* browser_context)
+    : browser_context_(browser_context),
       id_(next_utterance_id_++),
       src_id_(-1),
       gender_(TTS_GENDER_NONE),
       can_enqueue_(false),
       char_index_(0),
       finished_(false) {
   options_.reset(new base::DictionaryValue());
 }
 
 Utterance::~Utterance() {
@@ skipping 66 matching lines @@
   } else {
     Stop();
     SpeakNow(utterance);
   }
 }
 
 void TtsControllerImpl::SpeakNow(Utterance* utterance) {
   // Ensure we have all built-in voices loaded. This is a no-op if already
   // loaded.
   bool loaded_built_in =
-      GetPlatformImpl()->LoadBuiltInTtsExtension(utterance->profile());
+      GetPlatformImpl()->LoadBuiltInTtsExtension(utterance->browser_context());
 
   // Get all available voices and try to find a matching voice.
   std::vector<VoiceData> voices;
-  GetVoices(utterance->profile(), &voices);
+  GetVoices(utterance->browser_context(), &voices);
   int index = GetMatchingVoice(utterance, voices);
 
   VoiceData voice;
   if (index != -1) {
     // Select the matching voice.
     voice = voices[index];
   } else {
     // However, if no match was found on a platform without native tts voices,
     // attempt to get a voice based only on the current locale without respect
     // to any supplied voice names.
@@ skipping 127 matching lines @@
   if (!current_utterance_ || utterance_id != current_utterance_->id()) {
     return;
   }
   current_utterance_->OnTtsEvent(event_type, char_index, error_message);
   if (current_utterance_->finished()) {
     FinishCurrentUtterance();
     SpeakNextUtterance();
   }
 }
 
-void TtsControllerImpl::GetVoices(Profile* profile,
+void TtsControllerImpl::GetVoices(content::BrowserContext* browser_context,
                               std::vector<VoiceData>* out_voices) {
 #if !defined(OS_ANDROID)
-  if (profile && tts_engine_delegate_)
-    tts_engine_delegate_->GetVoices(profile, out_voices);
+  if (browser_context && tts_engine_delegate_)
+    tts_engine_delegate_->GetVoices(browser_context, out_voices);
 #endif
 
   TtsPlatformImpl* platform_impl = GetPlatformImpl();
   if (platform_impl) {
     // Ensure we have all built-in voices loaded. This is a no-op if already
     // loaded.
-    platform_impl->LoadBuiltInTtsExtension(profile);
+    platform_impl->LoadBuiltInTtsExtension(browser_context);
     if (platform_impl->PlatformImplAvailable())
       platform_impl->GetVoices(out_voices);
   }
 }
 
 bool TtsControllerImpl::IsSpeaking() {
   return current_utterance_ != NULL || GetPlatformImpl()->IsSpeaking();
 }
 
 void TtsControllerImpl::FinishCurrentUtterance() {
@@ skipping 124 matching lines @@
 }
 
 void TtsControllerImpl::SetTtsEngineDelegate(
     TtsEngineDelegate* delegate) {
   tts_engine_delegate_ = delegate;
 }
 
 TtsEngineDelegate* TtsControllerImpl::GetTtsEngineDelegate() {
   return tts_engine_delegate_;
 }