Separate out the TtsController interface from it's impl

chrome/browser/speech/tts_controller_impl.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/speech/tts_controller.h"
+#include "chrome/browser/speech/tts_controller_impl.h"
 
 #include <string>
 #include <vector>
 
 #include "base/float_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/speech/tts_platform.h"
 
 namespace {
@@ skipping 79 matching lines @@
 }
 
 void Utterance::Finish() {
   finished_ = true;
 }
 
 void Utterance::set_options(const base::Value* options) {
   options_.reset(options->DeepCopy());
 }
 
+TtsController* TtsController::GetInstance() {
+  return TtsControllerImpl::GetInstance();
+}
+
 //
-// TtsController
+// TtsControllerImpl
 //
 
 // static
-TtsController* TtsController::GetInstance() {
-  return Singleton<TtsController>::get();
+TtsControllerImpl* TtsControllerImpl::GetInstance() {
+  return Singleton<TtsControllerImpl>::get();
 }
 
-TtsController::TtsController()
+TtsControllerImpl::TtsControllerImpl()
     : current_utterance_(NULL),
       paused_(false),
       platform_impl_(NULL),
       tts_engine_delegate_(NULL) {
 }
 
-TtsController::~TtsController() {
+TtsControllerImpl::~TtsControllerImpl() {
   if (current_utterance_) {
     current_utterance_->Finish();
     delete current_utterance_;
   }
 
   // Clear any queued utterances too.
   ClearUtteranceQueue(false);  // Don't sent events.
 }
 
-void TtsController::SpeakOrEnqueue(Utterance* utterance) {
+void TtsControllerImpl::SpeakOrEnqueue(Utterance* utterance) {
   // If we're paused and we get an utterance that can't be queued,
   // flush the queue but stay in the paused state.
   if (paused_ && !utterance->can_enqueue()) {
     Stop();
     paused_ = true;
     return;
   }
 
   if (paused_ || (IsSpeaking() && utterance->can_enqueue())) {
     utterance_queue_.push(utterance);
   } else {
     Stop();
     SpeakNow(utterance);
   }
 }
 
-void TtsController::SpeakNow(Utterance* 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());
 
   // Get all available voices and try to find a matching voice.
   std::vector<VoiceData> voices;
   GetVoices(utterance->profile(), &voices);
   int index = GetMatchingVoice(utterance, voices);
 
@@ skipping 70 matching lines @@
 
     if (!success) {
       utterance->OnTtsEvent(TTS_EVENT_ERROR, kInvalidCharIndex,
                             GetPlatformImpl()->error());
       delete utterance;
       return;
     }
   }
 }
 
-void TtsController::Stop() {
+void TtsControllerImpl::Stop() {
   paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
 #if !defined(OS_ANDROID)
     if (tts_engine_delegate_)
       tts_engine_delegate_->Stop(current_utterance_);
 #endif
   } else {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->StopSpeaking();
   }
 
   if (current_utterance_)
     current_utterance_->OnTtsEvent(TTS_EVENT_INTERRUPTED, kInvalidCharIndex,
                                    std::string());
   FinishCurrentUtterance();
   ClearUtteranceQueue(true);  // Send events.
 }
 
-void TtsController::Pause() {
+void TtsControllerImpl::Pause() {
   paused_ = true;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
 #if !defined(OS_ANDROID)
     if (tts_engine_delegate_)
       tts_engine_delegate_->Pause(current_utterance_);
 #endif
   } else if (current_utterance_) {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->Pause();
   }
 }
 
-void TtsController::Resume() {
+void TtsControllerImpl::Resume() {
   paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
 #if !defined(OS_ANDROID)
     if (tts_engine_delegate_)
       tts_engine_delegate_->Resume(current_utterance_);
 #endif
   } else if (current_utterance_) {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->Resume();
   } else {
     SpeakNextUtterance();
   }
 }
 
-void TtsController::OnTtsEvent(int utterance_id,
+void TtsControllerImpl::OnTtsEvent(int utterance_id,
                                         TtsEventType event_type,
                                         int char_index,
                                         const std::string& error_message) {
   // We may sometimes receive completion callbacks "late", after we've
   // already finished the utterance (for example because another utterance
   // interrupted or we got a call to Stop). This is normal and we can
   // safely just ignore these events.
   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 TtsController::GetVoices(Profile* profile,
+void TtsControllerImpl::GetVoices(Profile* profile,
                               std::vector<VoiceData>* out_voices) {
 #if !defined(OS_ANDROID)
   if (profile && tts_engine_delegate_)
     tts_engine_delegate_->GetVoices(profile, 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);
     if (platform_impl->PlatformImplAvailable())
       platform_impl->GetVoices(out_voices);
   }
 }
 
-bool TtsController::IsSpeaking() {
+bool TtsControllerImpl::IsSpeaking() {
   return current_utterance_ != NULL || GetPlatformImpl()->IsSpeaking();
 }
 
-void TtsController::FinishCurrentUtterance() {
+void TtsControllerImpl::FinishCurrentUtterance() {
   if (current_utterance_) {
     if (!current_utterance_->finished())
       current_utterance_->OnTtsEvent(TTS_EVENT_INTERRUPTED, kInvalidCharIndex,
                                      std::string());
     delete current_utterance_;
     current_utterance_ = NULL;
   }
 }
 
-void TtsController::SpeakNextUtterance() {
+void TtsControllerImpl::SpeakNextUtterance() {
   if (paused_)
     return;
 
   // Start speaking the next utterance in the queue.  Keep trying in case
   // one fails but there are still more in the queue to try.
   while (!utterance_queue_.empty() && !current_utterance_) {
     Utterance* utterance = utterance_queue_.front();
     utterance_queue_.pop();
     SpeakNow(utterance);
   }
 }
 
-void TtsController::RetrySpeakingQueuedUtterances() {
+void TtsControllerImpl::RetrySpeakingQueuedUtterances() {
   if (current_utterance_ == NULL && !utterance_queue_.empty())
     SpeakNextUtterance();
 }
 
-void TtsController::ClearUtteranceQueue(bool send_events) {
+void TtsControllerImpl::ClearUtteranceQueue(bool send_events) {
   while (!utterance_queue_.empty()) {
     Utterance* utterance = utterance_queue_.front();
     utterance_queue_.pop();
     if (send_events)
       utterance->OnTtsEvent(TTS_EVENT_CANCELLED, kInvalidCharIndex,
                             std::string());
     else
       utterance->Finish();
     delete utterance;
   }
 }
 
-void TtsController::SetPlatformImpl(
+void TtsControllerImpl::SetPlatformImpl(
     TtsPlatformImpl* platform_impl) {
   platform_impl_ = platform_impl;
 }
 
-int TtsController::QueueSize() {
+int TtsControllerImpl::QueueSize() {
   return static_cast<int>(utterance_queue_.size());
 }
 
-TtsPlatformImpl* TtsController::GetPlatformImpl() {
+TtsPlatformImpl* TtsControllerImpl::GetPlatformImpl() {
   if (!platform_impl_)
     platform_impl_ = TtsPlatformImpl::GetInstance();
   return platform_impl_;
 }
 
-int TtsController::GetMatchingVoice(
+int TtsControllerImpl::GetMatchingVoice(
     const Utterance* utterance, std::vector<VoiceData>& voices) {
   // Make two passes: the first time, do strict language matching
   // ('fr-FR' does not match 'fr-CA'). The second time, do prefix
   // language matching ('fr-FR' matches 'fr' and 'fr-CA')
   for (int pass = 0; pass < 2; ++pass) {
     for (size_t i = 0; i < voices.size(); ++i) {
       const VoiceData& voice = voices[i];
 
       if (!utterance->extension_id().empty() &&
           utterance->extension_id() != voice.extension_id) {
@@ skipping 37 matching lines @@
           continue;
       }
 
       return static_cast<int>(i);
     }
   }
 
   return -1;
 }
 
-void TtsController::VoicesChanged() {
+void TtsControllerImpl::VoicesChanged() {
   for (std::set<VoicesChangedDelegate*>::iterator iter =
            voices_changed_delegates_.begin();
        iter != voices_changed_delegates_.end(); ++iter) {
     (*iter)->OnVoicesChanged();
   }
 }
 
-void TtsController::AddVoicesChangedDelegate(VoicesChangedDelegate* delegate) {
+void TtsControllerImpl::AddVoicesChangedDelegate(
+    VoicesChangedDelegate* delegate) {
   voices_changed_delegates_.insert(delegate);
 }
 
-void TtsController::RemoveVoicesChangedDelegate(
+void TtsControllerImpl::RemoveVoicesChangedDelegate(
     VoicesChangedDelegate* delegate) {
   voices_changed_delegates_.erase(delegate);
 }
 
-void TtsController::SetTtsEngineDelegate(
+void TtsControllerImpl::SetTtsEngineDelegate(
     TtsEngineDelegate* delegate) {
   tts_engine_delegate_ = delegate;
 }