Eliminate the dependency of Profile from TtsMessageFilter.

chrome/browser/speech/tts_controller.h

 // 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.
 
 #ifndef CHROME_BROWSER_SPEECH_TTS_CONTROLLER_H_
 #define CHROME_BROWSER_SPEECH_TTS_CONTROLLER_H_
 
 #include <queue>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "url/gurl.h"
 
 class Utterance;
 class TtsPlatformImpl;
-class Profile;
 
 namespace base {
 class Value;
 }
 
+namespace content {
+class BrowserContext;
+}
+
 // Events sent back from the TTS engine indicating the progress.
 enum TtsEventType {
   TTS_EVENT_START,
   TTS_EVENT_END,
   TTS_EVENT_WORD,
   TTS_EVENT_SENTENCE,
   TTS_EVENT_MARKER,
   TTS_EVENT_INTERRUPTED,
   TTS_EVENT_CANCELLED,
   TTS_EVENT_ERROR,
@@ skipping 40 matching lines @@
   bool native;
   std::string native_voice_identifier;
 };
 
 // Interface that delegates TTS requests to user-installed extensions.
 class TtsEngineDelegate {
  public:
   virtual ~TtsEngineDelegate() {}
 
   // Return a list of all available voices registered.
-  virtual void GetVoices(Profile* profile,
+  virtual void GetVoices(content::BrowserContext* browser_context,
                          std::vector<VoiceData>* out_voices) = 0;
 
   // Speak the given utterance by sending an event to the given TTS engine.
   virtual void Speak(Utterance* utterance, const VoiceData& voice) = 0;
 
   // Stop speaking the given utterance by sending an event to the target
   // associated with this utterance.
   virtual void Stop(Utterance* utterance) = 0;
 
   // Pause in the middle of speaking this utterance.
   virtual void Pause(Utterance* utterance) = 0;
 
   // Resume speaking this utterance.
   virtual void Resume(Utterance* utterance) = 0;
 
   // Load the built-in component extension for ChromeOS.
-  virtual bool LoadBuiltInTtsExtension(Profile* profile) = 0;
+  virtual bool LoadBuiltInTtsExtension(
+                 content::BrowserContext* browser_context) = 0;

[dmazzoni, 2014/08/12 06:21:08]

nit: indentation

 };
 
 // Class that wants to receive events on utterances.
 class UtteranceEventDelegate {
  public:
   virtual ~UtteranceEventDelegate() {}
   virtual void OnTtsEvent(Utterance* utterance,
                           TtsEventType event_type,
                           int char_index,
                           const std::string& error_message) = 0;
 };
 
 // Class that wants to be notified when the set of
 // voices has changed.
 class VoicesChangedDelegate {
  public:
   virtual ~VoicesChangedDelegate() {}
   virtual void OnVoicesChanged() = 0;
 };
 
 // One speech utterance.
 class Utterance {
  public:
   // Construct an utterance given a profile and a completion task to call
   // when the utterance is done speaking. Before speaking this utterance,
   // its other parameters like text, rate, pitch, etc. should all be set.
-  explicit Utterance(Profile* profile);
+  explicit Utterance(content::BrowserContext* browser_context);
   ~Utterance();
 
   // Sends an event to the delegate. If the event type is TTS_EVENT_END
   // or TTS_EVENT_ERROR, deletes the utterance. If |char_index| is -1,
   // uses the last good value.
   void OnTtsEvent(TtsEventType event_type,
                   int char_index,
                   const std::string& error_message);
 
   // Finish an utterance without sending an event to the delegate.
@@ skipping 63 matching lines @@
 
   UtteranceEventDelegate* event_delegate() const {
     return event_delegate_.get();
   }
   void set_event_delegate(
       base::WeakPtr<UtteranceEventDelegate> event_delegate) {
     event_delegate_ = event_delegate;
   }
 
   // Getters and setters for internal state.
-  Profile* profile() const { return profile_; }
+  content::BrowserContext* browser_context() const { return browser_context_; }
   int id() const { return id_; }
   bool finished() const { return finished_; }
 
  private:
   // The profile that initiated this utterance.

[dmazzoni, 2014/08/12 06:21:08]

Update the comment.

-  Profile* profile_;
+  content::BrowserContext* browser_context_;
 
   // The extension ID of the extension providing TTS for this utterance, or
   // empty if native TTS is being used.
   std::string extension_id_;
 
   // The unique ID of this utterance, used to associate callback functions
   // with utterances.
   int id_;
 
   // The id of the next utterance, so we can associate requests with
@@ skipping 69 matching lines @@
   // the callback function, and in addition, completion and error events
   // trigger finishing the current utterance and starting the next one, if
   // any.
   virtual void OnTtsEvent(int utterance_id,
                   TtsEventType event_type,
                   int char_index,
                   const std::string& error_message) = 0;
 
   // Return a list of all available voices, including the native voice,
   // if supported, and all voices registered by extensions.
-  virtual void GetVoices(Profile* profile,
+  virtual void GetVoices(content::BrowserContext* browser_context,
                          std::vector<VoiceData>* out_voices) = 0;
 
   // Called by the extension system or platform implementation when the
   // list of voices may have changed and should be re-queried.
   virtual void VoicesChanged() = 0;
 
   // Add a delegate that wants to be notified when the set of voices changes.
   virtual void AddVoicesChangedDelegate(VoicesChangedDelegate* delegate) = 0;
 
   // Remove delegate that wants to be notified when the set of voices changes.
   virtual void RemoveVoicesChangedDelegate(VoicesChangedDelegate* delegate) = 0;
 
   // Set the delegate that processes TTS requests with user-installed
   // extensions.
   virtual void SetTtsEngineDelegate(TtsEngineDelegate* delegate) = 0;
 
   // Get the delegate that processes TTS requests with user-installed
   // extensions.
   virtual TtsEngineDelegate* GetTtsEngineDelegate() = 0;
 
   // For unit testing.
   virtual void SetPlatformImpl(TtsPlatformImpl* platform_impl) = 0;
   virtual int QueueSize() = 0;
 
  protected:
   virtual ~TtsController() {}
 };
 
 #endif  // CHROME_BROWSER_SPEECH_TTS_CONTROLLER_H_