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/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
-#include "chrome/browser/chromeos/cros/cros_library.h"
-#include "chrome/browser/chromeos/cros/speech_synthesis_library.h"
+#include "base/task.h"

[satorux1, 2011/10/19 05:15:47]

I think base/task.h is unnecessary.

[hashimoto, 2011/10/19 06:02:14]

Removed.

It seems that this include and |method_factory_| are mistakenly revived while
merging.
Thank you for pointing it out.

+#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(ptr_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);

[dmazzoni, 2011/10/19 05:01:15]

By the way, it would be fantastic if we could implement this with a callback
when speech completes rather than polling. There's already
http://crbug.com/67713 filed for this - could you take a look?

[satorux1, 2011/10/19 05:15:47]

Agreed. Polling is uncool. :)

One way to do it is to send a signal from the speech synthesis server once the
speech is done. Chrome can monitor the signal and get notified. This should be
reasonably easy, but not so clean.

Another way, which is cleaner but tricker to implement, is to to change Speak
method implementation in the server to defer returning the response until the
speech is done. This can be tricky to implement. Most D-Bus methods process
requests and return responses as soon as requests are delivered. Returning
responses at a later time would require asynchronous operation, which can be
tricky to implement.

[hashimoto, 2011/10/19 05:18:25]

OK, I will.
It looks that currently no signal is sent from speech synthesizer when a speech
is finished.
What is needed is modifying speech synthesizer to send a signal when a speech is
finished, and modifying Chromium to receive the signal and invoke TTS_EVENT_END.
 Is this right?

 
   void AppendSpeakOption(std::string key,
                          std::string value,
                          std::string* options);
 
   int utterance_id_;
   int utterance_length_;
-  base::WeakPtrFactory<ExtensionTtsPlatformImplChromeOs> ptr_factory_;
+  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);
+  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));
+}
 
-  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;
   }
-
+  // Continue polling.
   MessageLoop::current()->PostDelayedTask(
       FROM_HERE, base::Bind(
           &ExtensionTtsPlatformImplChromeOs::PollUntilSpeechFinishes,
-          ptr_factory_.GetWeakPtr(),
+          weak_ptr_factory_.GetWeakPtr(),
           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();
 }