Add Pause and Resume to Web TTS & Extension TTS APIs

chrome/browser/speech/tts_mac.mm

 // 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 <string>
 
 #include "base/memory/scoped_nsobject.h"
 #include "base/memory/singleton.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/values.h"
@@ skipping 45 matching lines @@
 
   virtual bool Speak(
       int utterance_id,
       const std::string& utterance,
       const std::string& lang,
       const VoiceData& voice,
       const UtteranceContinuousParameters& params) OVERRIDE;
 
   virtual bool StopSpeaking() OVERRIDE;
 
+  virtual void Pause() OVERRIDE;
+
+  virtual void Resume() OVERRIDE;
+
   virtual bool IsSpeaking() OVERRIDE;
 
   virtual void GetVoices(std::vector<VoiceData>* out_voices) OVERRIDE;
 
   // Called by ChromeTtsDelegate when we get a callback from the
   // native speech engine.
   void OnSpeechEvent(NSSpeechSynthesizer* sender,
                      TtsEventType event_type,
                      int char_index,
                      const std::string& error_message);
 
   // Get the single instance of this class.
   static TtsPlatformImplMac* GetInstance();
 
  private:
   TtsPlatformImplMac();
   virtual ~TtsPlatformImplMac();
 
   scoped_nsobject<SingleUseSpeechSynthesizer> speech_synthesizer_;
   scoped_nsobject<ChromeTtsDelegate> delegate_;
   int utterance_id_;
   std::string utterance_;
   bool sent_start_event_;
+  int last_char_index_;
+  bool paused_;
 
   friend struct DefaultSingletonTraits<TtsPlatformImplMac>;
 
   DISALLOW_COPY_AND_ASSIGN(TtsPlatformImplMac);
 };
 
 // static
 TtsPlatformImpl* TtsPlatformImpl::GetInstance() {
   return TtsPlatformImplMac::GetInstance();
 }
 
 bool TtsPlatformImplMac::Speak(
     int utterance_id,
     const std::string& utterance,
     const std::string& lang,
     const VoiceData& voice,
     const UtteranceContinuousParameters& params) {
   // TODO: convert SSML to SAPI xml. http://crbug.com/88072
   utterance_ = utterance;
+  paused_ = false;
 
   NSString* utterance_nsstring =
       [NSString stringWithUTF8String:utterance_.c_str()];
 
   // Deliberately construct a new speech synthesizer every time Speak is
   // called, otherwise there's no way to know whether calls to the delegate
   // apply to the current utterance or a previous utterance. In
   // experimentation, the overhead of constructing and destructing a
   // NSSpeechSynthesizer is minimal.
   speech_synthesizer_.reset(
@@ skipping 40 matching lines @@
   }
 
   return [speech_synthesizer_ startSpeakingRetainedUtterance];
 }
 
 bool TtsPlatformImplMac::StopSpeaking() {
   if (speech_synthesizer_.get()) {
     [speech_synthesizer_ stopSpeaking];
     speech_synthesizer_.reset(nil);
   }
+  paused_ = false;
   return true;
 }
 
+void TtsPlatformImplMac::Pause() {
+  if (speech_synthesizer_.get() && utterance_id_ && !paused_) {
+    [speech_synthesizer_ pauseSpeakingAtBoundary:NSSpeechImmediateBoundary];
+    paused_ = true;
+    TtsController::GetInstance()->OnTtsEvent(
+        utterance_id_, TTS_EVENT_PAUSE, last_char_index_, "");
+  }
+}
+
+void TtsPlatformImplMac::Resume() {
+  if (speech_synthesizer_.get() && utterance_id_ && paused_) {
+    [speech_synthesizer_ continueSpeaking];
+    paused_ = false;
+    TtsController::GetInstance()->OnTtsEvent(
+        utterance_id_, TTS_EVENT_RESUME, last_char_index_, "");
+  }
+}
+
 bool TtsPlatformImplMac::IsSpeaking() {
   return [NSSpeechSynthesizer isAnyApplicationSpeaking];
 }
 
 void TtsPlatformImplMac::GetVoices(std::vector<VoiceData>* outVoices) {
   NSArray* voices = [NSSpeechSynthesizer availableVoices];
 
   // Create a new temporary array of the available voices with
   // the default voice first.
   NSMutableArray* orderedVoices =
@@ skipping 35 matching lines @@
     else if ([gender isEqualToString:NSVoiceGenderFemale])
       data.gender = TTS_GENDER_FEMALE;
     else
       data.gender = TTS_GENDER_NONE;
     data.events.insert(TTS_EVENT_START);
     data.events.insert(TTS_EVENT_END);
     data.events.insert(TTS_EVENT_WORD);
     data.events.insert(TTS_EVENT_ERROR);
     data.events.insert(TTS_EVENT_CANCELLED);
     data.events.insert(TTS_EVENT_INTERRUPTED);
+    data.events.insert(TTS_EVENT_PAUSE);
+    data.events.insert(TTS_EVENT_RESUME);
   }
 }
 
 void TtsPlatformImplMac::OnSpeechEvent(
     NSSpeechSynthesizer* sender,
     TtsEventType event_type,
     int char_index,
     const std::string& error_message) {
   // Don't send events from an utterance that's already completed.
   // This depends on the fact that we construct a new NSSpeechSynthesizer
   // each time we call Speak.
   if (sender != speech_synthesizer_.get())
     return;
 
   if (event_type == TTS_EVENT_END)
     char_index = utterance_.size();
   TtsController* controller = TtsController::GetInstance();
   if (event_type == TTS_EVENT_WORD && !sent_start_event_) {
     controller->OnTtsEvent(
         utterance_id_, TTS_EVENT_START, 0, "");
     sent_start_event_ = true;
   }
   controller->OnTtsEvent(
       utterance_id_, event_type, char_index, error_message);
+  last_char_index_ = char_index;
 }
 
 TtsPlatformImplMac::TtsPlatformImplMac() {
   utterance_id_ = -1;
   sent_start_event_ = true;
+  paused_ = false;
 
   delegate_.reset([[ChromeTtsDelegate alloc] initWithPlatformImplMac:this]);
 }
 
 TtsPlatformImplMac::~TtsPlatformImplMac() {
 }
 
 // static
 TtsPlatformImplMac* TtsPlatformImplMac::GetInstance() {
   return Singleton<TtsPlatformImplMac>::get();
@@ skipping 48 matching lines @@
   didSpeak_ = true;
   return [super startSpeakingString:utterance_];
 }
 
 - (bool)startSpeakingString:(NSString*)utterance {
   CHECK(false);
   return false;
 }
 
 @end