Eliminate the dependence of tts extension API for tts_controller.cc

chrome/browser/speech/tts_controller.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 <string>
 #include <vector>
 
 #include "base/float_util.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/speech/extension_api/tts_engine_extension_api.h"
-#include "chrome/browser/speech/extension_api/tts_extension_api.h"
 #include "chrome/browser/speech/tts_platform.h"
-#include "chrome/common/extensions/api/speech/tts_engine_manifest_handler.h"
-#include "extensions/browser/extension_system.h"
-#include "extensions/common/extension.h"
 
 namespace {
 // A value to be used to indicate that there is no char index available.
 const int kInvalidCharIndex = -1;
 
 // Given a language/region code of the form 'fr-FR', returns just the basic
 // language portion, e.g. 'fr'.
 std::string TrimLanguageCode(std::string lang) {
   if (lang.size() >= 5 && lang[2] == '-')
     return lang.substr(0, 2);
@@ skipping 83 matching lines @@
 //
 
 // static
 TtsController* TtsController::GetInstance() {
   return Singleton<TtsController>::get();
 }
 
 TtsController::TtsController()
     : current_utterance_(NULL),
       paused_(false),
-      platform_impl_(NULL) {
+      platform_impl_(NULL),
+      tts_engine_delegate_(NULL) {
 }
 
 TtsController::~TtsController() {
   if (current_utterance_) {
     current_utterance_->Finish();
     delete current_utterance_;
   }
 
   // Clear any queued utterances too.
   ClearUtteranceQueue(false);  // Don't sent events.
@@ skipping 31 matching lines @@
     // attempt to get a voice based only on the current locale without respect
     // to any supplied voice names.
     std::vector<VoiceData> native_voices;
 
     if (GetPlatformImpl()->PlatformImplAvailable())
       GetPlatformImpl()->GetVoices(&native_voices);
 
     if (native_voices.empty() && !voices.empty()) {
       // TODO(dtseng): Notify extension caller of an error.
       utterance->set_voice_name("");
+      // TODO(gaochun): Replace the global variable g_browser_process with
+      // GetContentClient()->browser() to eliminate the dependency of browser
+      // once TTS implementation was moved to content.
       utterance->set_lang(g_browser_process->GetApplicationLocale());
       index = GetMatchingVoice(utterance, voices);
 
       // If even that fails, just take the first available voice.
       if (index == -1)
         index = 0;
       voice = voices[index];
     } else {
       // Otherwise, simply give native voices a chance to handle this utterance.
       voice.native = true;
     }
   }
 
   GetPlatformImpl()->WillSpeakUtteranceWithVoice(utterance, voice);
 
   if (!voice.native) {
 #if !defined(OS_ANDROID)
     DCHECK(!voice.extension_id.empty());
     current_utterance_ = utterance;
     utterance->set_extension_id(voice.extension_id);
-    ExtensionTtsEngineSpeak(utterance, voice);
+    if (tts_engine_delegate_)
+      tts_engine_delegate_->Speak(utterance, voice);
     bool sends_end_event =
         voice.events.find(TTS_EVENT_END) != voice.events.end();
     if (!sends_end_event) {
       utterance->Finish();
       delete utterance;
       current_utterance_ = NULL;
       SpeakNextUtterance();
     }
 #endif
   } else {
@@ skipping 24 matching lines @@
       delete utterance;
       return;
     }
   }
 }
 
 void TtsController::Stop() {
   paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
 #if !defined(OS_ANDROID)
-    ExtensionTtsEngineStop(current_utterance_);
+    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() {
   paused_ = true;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
 #if !defined(OS_ANDROID)
-    ExtensionTtsEnginePause(current_utterance_);
+    if (tts_engine_delegate_)
+      tts_engine_delegate_->Pause(current_utterance_);
 #endif
   } else if (current_utterance_) {
     GetPlatformImpl()->clear_error();
     GetPlatformImpl()->Pause();
   }
 }
 
 void TtsController::Resume() {
   paused_ = false;
   if (current_utterance_ && !current_utterance_->extension_id().empty()) {
 #if !defined(OS_ANDROID)
-    ExtensionTtsEngineResume(current_utterance_);
+    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,
@@ skipping 10 matching lines @@
   current_utterance_->OnTtsEvent(event_type, char_index, error_message);
   if (current_utterance_->finished()) {
     FinishCurrentUtterance();
     SpeakNextUtterance();
   }
 }
 
 void TtsController::GetVoices(Profile* profile,
                               std::vector<VoiceData>* out_voices) {
 #if !defined(OS_ANDROID)
-  if (profile)
-    GetExtensionVoices(profile, out_voices);
+  if (profile && tts_engine_delegate_)
+    tts_engine_delegate_->GetVoices(profile, out_voices);
 #endif
 
   TtsPlatformImpl* platform_impl = GetPlatformImpl();
   if (platform_impl && platform_impl->PlatformImplAvailable())
     platform_impl->GetVoices(out_voices);
 }
 
 bool TtsController::IsSpeaking() {
   return current_utterance_ != NULL || GetPlatformImpl()->IsSpeaking();
 }
@@ skipping 121 matching lines @@
 }
 
 void TtsController::AddVoicesChangedDelegate(VoicesChangedDelegate* delegate) {
   voices_changed_delegates_.insert(delegate);
 }
 
 void TtsController::RemoveVoicesChangedDelegate(
     VoicesChangedDelegate* delegate) {
   voices_changed_delegates_.erase(delegate);
 }
+
+void TtsController::SetTtsEngineDelegate(
+    TtsEngineDelegate* delegate) {
+  tts_engine_delegate_ = delegate;
+}