Extend TTS extension API to support richer events returned from the engine

to the client. Previously we just had a completed event; this adds start,
word boundary, sentence boundary, and marker boundary. In addition,
interrupted and canceled, which were previously errors, now become events.
Mac and Windows implementations extended to support as many of these events
as possible.

BUG=67713
BUG=70198
BUG=75106
BUG=83404

TEST=Updates all TTS API tests to be event-based, and adds new tests.
Review URL: http://codereview.chromium.org/6792014

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@91665 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 167 insertions, 96 deletions

diff --git a/chrome/browser/extensions/extension_tts_apitest.cc b/chrome/browser/extensions/extension_tts_apitest.cc
index 560235d..e1e385f 100644
--- a/chrome/browser/extensions/extension_tts_apitest.cc
+++ b/chrome/browser/extensions/extension_tts_apitest.cc
@@ -1,9 +1,13 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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/command_line.h"
+#include "base/task.h"
 #include "chrome/browser/extensions/extension_apitest.h"
 #include "chrome/browser/extensions/extension_tts_api.h"
+#include "chrome/browser/extensions/extension_tts_api_controller.h"
+#include "chrome/browser/extensions/extension_tts_api_platform.h"
 #include "chrome/common/chrome_switches.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -27,19 +31,90 @@ using ::testing::_;
 
 class MockExtensionTtsPlatformImpl : public ExtensionTtsPlatformImpl {
  public:
-  MOCK_METHOD6(Speak,
-               bool(const std::string& utterance,
-                    const std::string& locale,
-                    const std::string& gender,
-                    double rate,
-                    double pitch,
-                    double volume));
+  MockExtensionTtsPlatformImpl()
+      : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
+
+  virtual bool PlatformImplAvailable() {
+    return true;
+  }
+
+  virtual bool SendsEvent(TtsEventType event_type) {
+    return (event_type == TTS_EVENT_END ||
+            event_type == TTS_EVENT_WORD);
+  }
+
+
+  MOCK_METHOD4(Speak,
+               bool(int utterance_id,
+                    const std::string& utterance,
+                    const std::string& lang,
+                    const UtteranceContinuousParameters& params));
   MOCK_METHOD0(StopSpeaking, bool(void));
-  MOCK_METHOD0(IsSpeaking, bool(void));
 
   void SetErrorToEpicFail() {
     set_error("epic fail");
   }
+
+  void SendEndEvent(int utterance_id,
+                    const std::string& utterance,
+                    const std::string& lang,
+                    const UtteranceContinuousParameters& params) {
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, method_factory_.NewRunnableMethod(
+            &MockExtensionTtsPlatformImpl::SendEvent,
+            false, utterance_id, TTS_EVENT_END, utterance.size(),
+            std::string()),
+        0);
+  }
+
+  void SendEndEventWhenQueueNotEmpty(
+      int utterance_id,
+      const std::string& utterance,
+      const std::string& lang,
+      const UtteranceContinuousParameters& params) {
+    MessageLoop::current()->PostDelayedTask(
+        FROM_HERE, method_factory_.NewRunnableMethod(
+            &MockExtensionTtsPlatformImpl::SendEvent,
+            true, utterance_id, TTS_EVENT_END, utterance.size(), std::string()),
+        0);
+  }
+
+  void SendWordEvents(int utterance_id,
+                      const std::string& utterance,
+                      const std::string& lang,
+                      const UtteranceContinuousParameters& params) {
+    for (int i = 0; i < static_cast<int>(utterance.size()); i++) {
+      if (i == 0 || utterance[i - 1] == ' ') {
+        MessageLoop::current()->PostDelayedTask(
+            FROM_HERE, method_factory_.NewRunnableMethod(
+                &MockExtensionTtsPlatformImpl::SendEvent,
+                false, utterance_id, TTS_EVENT_WORD, i,
+                std::string()),
+            0);
+      }
+    }
+  }
+
+  void SendEvent(bool wait_for_non_empty_queue,
+                 int utterance_id,
+                 TtsEventType event_type,
+                 int char_index,
+                 const std::string& message) {
+    ExtensionTtsController* controller = ExtensionTtsController::GetInstance();
+    if (wait_for_non_empty_queue && controller->QueueSize() == 0) {
+      MessageLoop::current()->PostDelayedTask(
+          FROM_HERE, method_factory_.NewRunnableMethod(
+              &MockExtensionTtsPlatformImpl::SendEvent,
+              true, utterance_id, event_type, char_index, message),
+          100);
+      return;
+    }
+
+    controller->OnTtsEvent(utterance_id, event_type, char_index, message);
+  }
+
+ private:
+  ScopedRunnableMethodFactory<MockExtensionTtsPlatformImpl> method_factory_;
 };
 
 class TtsApiTest : public ExtensionApiTest {
@@ -63,49 +138,29 @@ IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformSpeakFinishesImmediately) {
   InSequence s;
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak(_, _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(false));
-  ASSERT_TRUE(RunExtensionTest("tts/speak_once")) << message_;
-}
-
-IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformSpeakKeepsSpeakingTwice) {
-  InSequence s;
-  EXPECT_CALL(mock_platform_impl_, StopSpeaking())
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak(_, _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(true))
-      .WillOnce(Return(true))
-      .WillOnce(Return(false));
+  EXPECT_CALL(mock_platform_impl_, Speak(_, _, _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
   ASSERT_TRUE(RunExtensionTest("tts/speak_once")) << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformSpeakInterrupt) {
-  // One utterances starts speaking, and then a second interrupts.
+  // One utterance starts speaking, and then a second interrupts.
   InSequence s;
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak("text 1", _, _, _, _, _))
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "text 1", _, _))
       .WillOnce(Return(true));
-
-  // Ensure that the first utterance keeps going until it's interrupted.
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .Times(AnyNumber())
-      .WillRepeatedly(Return(true));
-
-  // Expect the second utterance and allow it to continue for two calls to
-  // IsSpeaking and then finish successfully.
+  // Expect the second utterance and allow it to finish.
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak("text 2", _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(true))
-      .WillOnce(Return(true))
-      .WillOnce(Return(false));
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "text 2", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
   ASSERT_TRUE(RunExtensionTest("tts/interrupt")) << message_;
 }
 
@@ -115,24 +170,18 @@ IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformSpeakQueueInterrupt) {
   InSequence s;
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak("text 1", _, _, _, _, _))
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "text 1", _, _))
       .WillOnce(Return(true));
-
-  // Ensure that the first utterance keeps going until it's interrupted.
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .Times(AnyNumber())
-      .WillRepeatedly(Return(true));
-
-  // Expect the third utterance and allow it to continue for two calls to
-  // IsSpeaking and then finish successfully.
+  // Don't expect the second utterance, because it's queued up and the
+  // first never finishes.
+  // Expect the third utterance and allow it to finish successfully.
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak("text 3", _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(true))
-      .WillOnce(Return(true))
-      .WillOnce(Return(false));
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "text 3", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
   ASSERT_TRUE(RunExtensionTest("tts/queue_interrupt")) << message_;
 }
 
@@ -140,18 +189,16 @@ IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformSpeakEnqueue) {
   InSequence s;
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak("text 1", _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(true))
-      .WillOnce(Return(true))
-      .WillOnce(Return(false));
-  EXPECT_CALL(mock_platform_impl_, Speak("text 2", _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(true))
-      .WillOnce(Return(true))
-      .WillOnce(Return(false));
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "text 1", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEventWhenQueueNotEmpty),
+          Return(true)));
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "text 2", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
   ASSERT_TRUE(RunExtensionTest("tts/enqueue")) << message_;
 }
 
@@ -159,13 +206,7 @@ IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformSpeakError) {
   InSequence s;
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak(_, _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(false));
-  EXPECT_CALL(mock_platform_impl_, StopSpeaking())
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak(_, _, _, _, _, _))
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "first try", _, _))
       .WillOnce(DoAll(
           InvokeWithoutArgs(
               CreateFunctor(&mock_platform_impl_,
@@ -173,36 +214,66 @@ IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformSpeakError) {
           Return(false)));
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, Speak(_, _, _, _, _, _))
-      .WillOnce(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillOnce(Return(false));
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "second try", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
   ASSERT_TRUE(RunExtensionTest("tts/speak_error")) << message_;
 }
 
-#if defined(OS_WIN)
-// Flakily fails on Windows: http://crbug.com/70198
-#define MAYBE_Provide FLAKY_Provide
-#else
-#define MAYBE_Provide Provide
-#endif
-IN_PROC_BROWSER_TEST_F(TtsApiTest, MAYBE_Provide) {
+IN_PROC_BROWSER_TEST_F(TtsApiTest, PlatformWordCallbacks) {
+  InSequence s;
+  EXPECT_CALL(mock_platform_impl_, StopSpeaking())
+      .WillOnce(Return(true));
+  EXPECT_CALL(mock_platform_impl_, Speak(_, "one two three", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendWordEvents),
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
+  ASSERT_TRUE(RunExtensionTest("tts/word_callbacks")) << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(TtsApiTest, RegisterEngine) {
   EXPECT_CALL(mock_platform_impl_, StopSpeaking())
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(mock_platform_impl_, IsSpeaking())
-      .WillRepeatedly(Return(false));
 
   {
     InSequence s;
-    EXPECT_CALL(mock_platform_impl_, Speak("native speech", _, _, _, _, _))
-        .WillOnce(Return(true));
-    EXPECT_CALL(mock_platform_impl_, Speak("native speech 2", _, _, _, _, _))
-        .WillOnce(Return(true));
-    EXPECT_CALL(mock_platform_impl_, Speak("native speech 3", _, _, _, _, _))
-        .WillOnce(Return(true));
+    EXPECT_CALL(mock_platform_impl_, Speak(_, "native speech", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
+    EXPECT_CALL(mock_platform_impl_, Speak(_, "native speech 2", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
+    EXPECT_CALL(mock_platform_impl_, Speak(_, "native speech 3", _, _))
+      .WillOnce(DoAll(
+          Invoke(&mock_platform_impl_,
+                 &MockExtensionTtsPlatformImpl::SendEndEvent),
+          Return(true)));
   }
 
-  ASSERT_TRUE(RunExtensionTest("tts/provide")) << message_;
+  ASSERT_TRUE(RunExtensionTest("tts_engine/register_engine")) << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(TtsApiTest, EngineError) {
+  EXPECT_CALL(mock_platform_impl_, StopSpeaking())
+      .WillRepeatedly(Return(true));
+
+  ASSERT_TRUE(RunExtensionTest("tts_engine/engine_error")) << message_;
+}
+
+IN_PROC_BROWSER_TEST_F(TtsApiTest, EngineWordCallbacks) {
+  EXPECT_CALL(mock_platform_impl_, StopSpeaking())
+      .WillRepeatedly(Return(true));
+
+  ASSERT_TRUE(RunExtensionTest("tts_engine/engine_word_callbacks")) << message_;
 }
 
 #if defined(OS_CHROMEOS)