Add Pause and Resume to Web TTS & Extension TTS APIs

chrome/browser/speech/extension_api/tts_engine_extension_api.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/extension_api/tts_engine_extension_api.h"
 
 #include <string>
 
 #include "base/json/json_writer.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/event_router.h"
+#include "chrome/browser/extensions/extension_host.h"
+#include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/speech/extension_api/tts_extension_api.h"
 #include "chrome/browser/speech/extension_api/tts_extension_api_constants.h"
 #include "chrome/browser/speech/tts_controller.h"
 #include "chrome/common/extensions/api/speech/tts_engine_manifest_handler.h"
 #include "chrome/common/extensions/extension.h"
+#include "chrome/common/extensions/extension_messages.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/common/console_message_level.h"
 
+using extensions::EventRouter;
 using extensions::Extension;
+using extensions::ExtensionSystem;
 
 namespace constants = tts_extension_api_constants;
 
 namespace tts_engine_events {
 const char kOnSpeak[] = "ttsEngine.onSpeak";
 const char kOnStop[] = "ttsEngine.onStop";
+const char kOnPause[] = "ttsEngine.onPause";
+const char kOnResume[] = "ttsEngine.onResume";
 };  // namespace tts_engine_events
 
+namespace {
+void WarnIfMissingPauseOrResumeListener(
+    Profile* profile, EventRouter* event_router, std::string extension_id) {

[not at google - send to devlin, 2013/05/20 17:29:53]

passing in the profile and event router would be unnecessary if this were a
method.

[dmazzoni, 2013/05/21 04:56:28]

Method of what class? This isn't being called from a class, it's being called
from a global "event dispatcher" of sorts.

[not at google - send to devlin, 2013/05/21 17:22:55]

ah sorry, misread and assumed this was on an extension function not global.
never mind.

+  bool has_onpause = event_router->ExtensionHasEventListener(
+      extension_id, tts_engine_events::kOnPause);
+  bool has_onresume = event_router->ExtensionHasEventListener(
+      extension_id, tts_engine_events::kOnResume);
+  if (has_onpause == has_onresume)
+    return;
+
+  ExtensionProcessManager* process_manager =
+      ExtensionSystem::Get(profile)->process_manager();
+  extensions::ExtensionHost* host =
+      process_manager->GetBackgroundHostForExtension(extension_id);
+  host->render_process_host()->Send(new ExtensionMsg_AddMessageToConsole(
+      host->render_view_host()->GetRoutingID(),
+      content::CONSOLE_MESSAGE_LEVEL_WARNING,
+      constants::kErrorMissingPauseOrResume));

[not at google - send to devlin, 2013/05/20 17:29:53]

this is pretty handy, I think there are lots of places where API implementations
could write warnings to the console... we just don't, and at least one reason is
because it's a bit of a pain.

So maybe you should add a version of UIThreadExtensionFunction::WriteToConsole
which takes a custom RVH to write to? I'd just overload WriteToConsole...

[dmazzoni, 2013/05/21 04:56:28]

A method in UIThreadExtensionFunction wouldn't help here - this is being called
from code that dispatches an event to an extension, not from an extension
function
handler.

I could implement a global function like this:

    WriteToExtensionConsole(Profile* profile, const string& extension_id);

That seems a little more useful than the RVH.

+};
+}  // anonymous namespace
+
 void GetExtensionVoices(Profile* profile, std::vector<VoiceData>* out_voices) {
   ExtensionService* service = profile->GetExtensionService();
   DCHECK(service);
-  extensions::EventRouter* event_router =
-      extensions::ExtensionSystem::Get(profile)->event_router();
+  EventRouter* event_router =
+      ExtensionSystem::Get(profile)->event_router();
   DCHECK(event_router);
 
   const ExtensionSet* extensions = service->extensions();
   ExtensionSet::const_iterator iter;
   for (iter = extensions->begin(); iter != extensions->end(); ++iter) {
     const Extension* extension = *iter;
 
     if (!event_router->ExtensionHasEventListener(
             extension->id(), tts_engine_events::kOnSpeak) ||
         !event_router->ExtensionHasEventListener(
@@ skipping 66 matching lines @@
     options->Remove(constants::kIsFinalEventKey, NULL);
   if (options->HasKey(constants::kOnEventKey))
     options->Remove(constants::kOnEventKey, NULL);
 
   args->Set(1, options.release());
   args->Set(2, Value::CreateIntegerValue(utterance->id()));
 
   scoped_ptr<extensions::Event> event(new extensions::Event(
       tts_engine_events::kOnSpeak, args.Pass()));
   event->restrict_to_profile = utterance->profile();
-  extensions::ExtensionSystem::Get(utterance->profile())->event_router()->
+  ExtensionSystem::Get(utterance->profile())->event_router()->
       DispatchEventToExtension(utterance->extension_id(), event.Pass());
 }
 
 void ExtensionTtsEngineStop(Utterance* utterance) {
   scoped_ptr<ListValue> args(new ListValue());
   scoped_ptr<extensions::Event> event(new extensions::Event(
       tts_engine_events::kOnStop, args.Pass()));
   event->restrict_to_profile = utterance->profile();
-  extensions::ExtensionSystem::Get(utterance->profile())->event_router()->
+  ExtensionSystem::Get(utterance->profile())->event_router()->
       DispatchEventToExtension(utterance->extension_id(), event.Pass());
 }
 
+void ExtensionTtsEnginePause(Utterance* utterance) {
+  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<extensions::Event> event(new extensions::Event(
+      tts_engine_events::kOnPause, args.Pass()));
+  Profile* profile = utterance->profile();
+  event->restrict_to_profile = profile;
+  EventRouter* event_router = ExtensionSystem::Get(profile)->event_router();
+  std::string id = utterance->extension_id();
+  event_router->DispatchEventToExtension(id, event.Pass());
+  WarnIfMissingPauseOrResumeListener(profile, event_router, id);
+}
+
+void ExtensionTtsEngineResume(Utterance* utterance) {
+  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<extensions::Event> event(new extensions::Event(
+      tts_engine_events::kOnResume, args.Pass()));
+  Profile* profile = utterance->profile();
+  event->restrict_to_profile = profile;
+  EventRouter* event_router = ExtensionSystem::Get(profile)->event_router();
+  std::string id = utterance->extension_id();
+  event_router->DispatchEventToExtension(id, event.Pass());
+  WarnIfMissingPauseOrResumeListener(profile, event_router, id);
+}
+
 bool ExtensionTtsEngineSendTtsEventFunction::RunImpl() {
   int utterance_id;
   std::string error_message;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &utterance_id));
 
   DictionaryValue* event;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &event));
 
   std::string event_type;
   EXTENSION_FUNCTION_VALIDATE(
@@ skipping 41 matching lines @@
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_SENTENCE, char_index, std::string());
   } else if (event_type == constants::kEventTypeMarker) {
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_MARKER, char_index, std::string());
   } else if (event_type == constants::kEventTypeError) {
     std::string error_message;
     event->GetString(constants::kErrorMessageKey, &error_message);
     controller->OnTtsEvent(
         utterance_id, TTS_EVENT_ERROR, char_index, error_message);
+  } else if (event_type == constants::kEventTypePause) {
+    controller->OnTtsEvent(
+        utterance_id, TTS_EVENT_PAUSE, char_index, std::string());
+  } else if (event_type == constants::kEventTypeResume) {
+    controller->OnTtsEvent(
+        utterance_id, TTS_EVENT_RESUME, char_index, std::string());
   } else {
     EXTENSION_FUNCTION_VALIDATE(false);
   }
 
   return true;
 }