Move the code in libcros' chromeos_speech_synthesis.cc into Chrome

chrome/browser/extensions/extension_tts_api_chromeos.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/task.h"
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/speech_synthesis_library.h"
+#include "chrome/browser/chromeos/dbus/dbus_thread_manager.h"
+#include "chrome/browser/chromeos/dbus/speech_synthesizer_client.h"
 #include "chrome/browser/extensions/extension_tts_api_controller.h"
 #include "chrome/browser/extensions/extension_tts_api_platform.h"
 
 using base::DoubleToString;
 
 namespace {
-const char kCrosLibraryNotLoadedError[] = "Cros shared library not loaded.";
 const int kSpeechCheckDelayIntervalMs = 100;
 };
 
 class ExtensionTtsPlatformImplChromeOs : public ExtensionTtsPlatformImpl {
  public:
   virtual bool PlatformImplAvailable() {
     return true;
   }
 
   virtual bool Speak(
       int utterance_id,
       const std::string& utterance,
       const std::string& lang,
       const UtteranceContinuousParameters& params);
 
   virtual bool StopSpeaking();
 
   virtual bool SendsEvent(TtsEventType event_type);
 
   // Get the single instance of this class.
   static ExtensionTtsPlatformImplChromeOs* GetInstance();
 
  private:
   ExtensionTtsPlatformImplChromeOs()
-      : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
+      : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+        ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {}
   virtual ~ExtensionTtsPlatformImplChromeOs() {}
 
   void PollUntilSpeechFinishes(int utterance_id);
+  void ContinuePollingIfSpeechIsNotFinished(int utterance_id, bool result);
 
   void AppendSpeakOption(std::string key,
                          std::string value,
                          std::string* options);
 
   int utterance_id_;
   int utterance_length_;
   ScopedRunnableMethodFactory<ExtensionTtsPlatformImplChromeOs> method_factory_;
+  base::WeakPtrFactory<ExtensionTtsPlatformImplChromeOs> weak_ptr_factory_;
 
   friend struct DefaultSingletonTraits<ExtensionTtsPlatformImplChromeOs>;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionTtsPlatformImplChromeOs);
 };
 
 // static
 ExtensionTtsPlatformImpl* ExtensionTtsPlatformImpl::GetInstance() {
   return ExtensionTtsPlatformImplChromeOs::GetInstance();
 }
 
 bool ExtensionTtsPlatformImplChromeOs::Speak(
     int utterance_id,
     const std::string& utterance,
     const std::string& lang,
     const UtteranceContinuousParameters& params) {
-  chromeos::CrosLibrary* cros_library = chromeos::CrosLibrary::Get();
-  if (!cros_library->EnsureLoaded()) {
-    set_error(kCrosLibraryNotLoadedError);
-    return false;
-  }
-
   utterance_id_ = utterance_id;
   utterance_length_ = utterance.size();
 
   std::string options;
 
   if (!lang.empty()) {
     AppendSpeakOption(
-        chromeos::SpeechSynthesisLibrary::kSpeechPropertyLocale,
+        chromeos::SpeechSynthesizerClient::kSpeechPropertyLocale,
         lang,
         &options);
   }
 
   if (params.rate >= 0.0) {
     AppendSpeakOption(
-        chromeos::SpeechSynthesisLibrary::kSpeechPropertyRate,
+        chromeos::SpeechSynthesizerClient::kSpeechPropertyRate,
         DoubleToString(params.rate),
         &options);
   }
 
   if (params.pitch >= 0.0) {
     // The TTS service allows a range of 0 to 2 for speech pitch.
     AppendSpeakOption(
-        chromeos::SpeechSynthesisLibrary::kSpeechPropertyPitch,
+        chromeos::SpeechSynthesizerClient::kSpeechPropertyPitch,
         DoubleToString(params.pitch),
         &options);
   }
 
   if (params.volume >= 0.0) {
     // The Chrome OS TTS service allows a range of 0 to 5 for speech volume,
     // but 5 clips, so map to a range of 0...4.
     AppendSpeakOption(
-        chromeos::SpeechSynthesisLibrary::kSpeechPropertyVolume,
+        chromeos::SpeechSynthesizerClient::kSpeechPropertyVolume,
         DoubleToString(params.volume * 4),
         &options);
   }
 
-  if (!options.empty()) {
-    cros_library->GetSpeechSynthesisLibrary()->SetSpeakProperties(
-        options.c_str());
-  }
+  chromeos::SpeechSynthesizerClient* speech_synthesizer_client =
+      chromeos::DBusThreadManager::Get()->speech_synthesizer_client();
 
-  bool result =
-      cros_library->GetSpeechSynthesisLibrary()->Speak(utterance.c_str());
+  if (!options.empty())
+    speech_synthesizer_client->SetSpeakProperties(options);
 
-  if (result) {
-    ExtensionTtsController* controller = ExtensionTtsController::GetInstance();
-    controller->OnTtsEvent(utterance_id_, TTS_EVENT_START, 0, std::string());
-    PollUntilSpeechFinishes(utterance_id_);
-  }
+  speech_synthesizer_client->Speak(utterance);

[satorux1, 2011/10/18 20:49:25]

I was a bit worried about the change here as Speak() no longer returns
true/false. However, looking at the code,  ChromeOSSpeak() always returns true,
so this doesn't change the semantics here. :)

[hashimoto, 2011/10/19 00:08:47]

Yes, this change keeps the semantics, nothing is changed.
If we are going to care about the result, we can add a callback parameter for
Speak later.

+  ExtensionTtsController* controller = ExtensionTtsController::GetInstance();
+  controller->OnTtsEvent(utterance_id_, TTS_EVENT_START, 0, std::string());
+  PollUntilSpeechFinishes(utterance_id_);
 
-  return result;
+  return true;
 }
 
 bool ExtensionTtsPlatformImplChromeOs::StopSpeaking() {
-  if (chromeos::CrosLibrary::Get()->EnsureLoaded()) {
-    return chromeos::CrosLibrary::Get()->GetSpeechSynthesisLibrary()->
-        StopSpeaking();
-  }
-
-  set_error(kCrosLibraryNotLoadedError);
-  return false;
+  chromeos::DBusThreadManager::Get()->speech_synthesizer_client()->
+      StopSpeaking();
+  return true;
 }
 
 bool ExtensionTtsPlatformImplChromeOs::SendsEvent(TtsEventType event_type) {
   return (event_type == TTS_EVENT_START ||
           event_type == TTS_EVENT_END ||
           event_type == TTS_EVENT_ERROR);
 }
 
 void ExtensionTtsPlatformImplChromeOs::PollUntilSpeechFinishes(
     int utterance_id) {
   if (utterance_id != utterance_id_) {
     // This utterance must have been interrupted or cancelled.
     return;
   }
+  chromeos::SpeechSynthesizerClient* speech_synthesizer_client =
+      chromeos::DBusThreadManager::Get()->speech_synthesizer_client();
+  speech_synthesizer_client->IsSpeaking(base::Bind(
+      &ExtensionTtsPlatformImplChromeOs::ContinuePollingIfSpeechIsNotFinished,
+      weak_ptr_factory_.GetWeakPtr(), utterance_id));

[satorux1, 2011/10/18 20:49:25]

Nice! It's now asynchronous thus not blocking UI. :)

[hashimoto, 2011/10/19 00:08:47]

I tried to make IsSpeaking synchronous, but gave up because
dbus::ObjectProxy::CallMethodAndBlock must be called from DBus thread, not from
UI thread.
By changing it to asynchronous, however, it becomes not blocking UI thread as
you say.

+}
 
-  chromeos::CrosLibrary* cros_library = chromeos::CrosLibrary::Get();
-  ExtensionTtsController* controller = ExtensionTtsController::GetInstance();
-
-  if (!cros_library->EnsureLoaded()) {
-    controller->OnTtsEvent(
-        utterance_id_, TTS_EVENT_ERROR, 0, kCrosLibraryNotLoadedError);
+void ExtensionTtsPlatformImplChromeOs::ContinuePollingIfSpeechIsNotFinished(
+    int utterance_id, bool is_speaking) {
+  if (utterance_id != utterance_id_) {
+    // This utterance must have been interrupted or cancelled.
     return;
   }
-
-  if (!cros_library->GetSpeechSynthesisLibrary()->IsSpeaking()) {
+  if (!is_speaking) {
+    ExtensionTtsController* controller = ExtensionTtsController::GetInstance();
     controller->OnTtsEvent(
         utterance_id_, TTS_EVENT_END, utterance_length_, std::string());
     return;
   }
-
+  // Contniue polling.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, method_factory_.NewRunnableMethod(
           &ExtensionTtsPlatformImplChromeOs::PollUntilSpeechFinishes,
           utterance_id),
       kSpeechCheckDelayIntervalMs);
 }
 
 void ExtensionTtsPlatformImplChromeOs::AppendSpeakOption(
     std::string key,
     std::string value,
     std::string* options) {
   *options +=
       key +
-      chromeos::SpeechSynthesisLibrary::kSpeechPropertyEquals +
+      chromeos::SpeechSynthesizerClient::kSpeechPropertyEquals +
       value +
-      chromeos::SpeechSynthesisLibrary::kSpeechPropertyDelimiter;
+      chromeos::SpeechSynthesizerClient::kSpeechPropertyDelimiter;
 }
 
 // static
 ExtensionTtsPlatformImplChromeOs*
 ExtensionTtsPlatformImplChromeOs::GetInstance() {
   return Singleton<ExtensionTtsPlatformImplChromeOs>::get();
 }