Adapt speech synthesis changes from 2.28

- Add missing functions
- Add proper error handling (similar to WebPlatformForEmbedded#823 with optional as in WebPlatformForEmbedded#875) for both UIProcess and WebProcess

Author: Scony

Source/WebCore/Headers.cmake

@@ -321,6 +321,15 @@ set(WebCore_PRIVATE_FRAMEWORK_HEADERS
     Modules/push-api/PushSubscriptionData.h
     Modules/push-api/PushSubscriptionIdentifier.h
 
+    Modules/speech/DOMWindowSpeechSynthesis.h
+    Modules/speech/SpeechSynthesisErrorCode.h
+    Modules/speech/SpeechSynthesisErrorEvent.h
+    Modules/speech/SpeechSynthesisErrorEventInit.h
+    Modules/speech/SpeechSynthesisEvent.h
+    Modules/speech/SpeechSynthesisEventInit.h
+    Modules/speech/SpeechSynthesis.h
+    Modules/speech/SpeechSynthesisUtterance.h
+    Modules/speech/SpeechSynthesisVoice.h
     Modules/speech/SpeechRecognitionCaptureSource.h
     Modules/speech/SpeechRecognitionCaptureSourceImpl.h
     Modules/speech/SpeechRecognitionConnection.h

Source/WebCore/Modules/speech/SpeechSynthesis.cpp

@@ -167,7 +167,7 @@ void SpeechSynthesis::cancel()
         m_speechSynthesisClient->cancel();
         // If we wait for cancel to callback speakingErrorOccurred, then m_currentSpeechUtterance will be null
         // and the event won't be processed. Instead we process the error immediately.
-        speakingErrorOccurred();
+        speakingErrorOccurred(SpeechSynthesisErrorCode::Canceled);
         m_currentSpeechUtterance = nullptr;
     } else if (m_platformSpeechSynthesizer) {
         m_platformSpeechSynthesizer->cancel();
@@ -207,17 +207,17 @@ void SpeechSynthesis::fireErrorEvent(const AtomString& type, SpeechSynthesisUtte
     utterance.dispatchEvent(SpeechSynthesisErrorEvent::create(type, { { &utterance, 0, 0, static_cast<float>((MonotonicTime::now() - utterance.startTime()).seconds()), { } }, errorCode }));
 }
 
-void SpeechSynthesis::handleSpeakingCompleted(SpeechSynthesisUtterance& utterance, bool errorOccurred)
+void SpeechSynthesis::handleSpeakingCompleted(SpeechSynthesisUtterance& utterance, std::optional<SpeechSynthesisErrorCode> error)
 {
     ASSERT(m_currentSpeechUtterance);
     Ref<SpeechSynthesisUtterance> protect(utterance);
 
     m_currentSpeechUtterance = nullptr;
 
-    if (errorOccurred)
-        fireErrorEvent(eventNames().errorEvent, utterance, SpeechSynthesisErrorCode::Canceled);
-    else
+    if (!error)
         fireEvent(eventNames().endEvent, utterance, 0, 0, String());
+    else
+        fireErrorEvent(eventNames().errorEvent, utterance, *error);
 
     if (m_utteranceQueue.size()) {
         Ref<SpeechSynthesisUtterance> firstUtterance = m_utteranceQueue.takeFirst();
@@ -276,11 +276,11 @@ void SpeechSynthesis::didResumeSpeaking()
     didResumeSpeaking(*m_currentSpeechUtterance->platformUtterance());
 }
 
-void SpeechSynthesis::speakingErrorOccurred()
+void SpeechSynthesis::speakingErrorOccurred(std::optional<SpeechSynthesisErrorCode> error)
 {
     if (!m_currentSpeechUtterance)
         return;
-    speakingErrorOccurred(*m_currentSpeechUtterance->platformUtterance());
+    speakingErrorOccurred(*m_currentSpeechUtterance->platformUtterance(), error);
 }
 
 void SpeechSynthesis::boundaryEventOccurred(bool wordBoundary, unsigned charIndex, unsigned charLength)
@@ -318,13 +318,13 @@ void SpeechSynthesis::didResumeSpeaking(PlatformSpeechSynthesisUtterance& uttera
 void SpeechSynthesis::didFinishSpeaking(PlatformSpeechSynthesisUtterance& utterance)
 {
     if (utterance.client())
-        handleSpeakingCompleted(static_cast<SpeechSynthesisUtterance&>(*utterance.client()), false);
+        handleSpeakingCompleted(static_cast<SpeechSynthesisUtterance&>(*utterance.client()), std::nullopt);
 }
 
-void SpeechSynthesis::speakingErrorOccurred(PlatformSpeechSynthesisUtterance& utterance)
+void SpeechSynthesis::speakingErrorOccurred(PlatformSpeechSynthesisUtterance& utterance, std::optional<SpeechSynthesisErrorCode> error)
 {
     if (utterance.client())
-        handleSpeakingCompleted(static_cast<SpeechSynthesisUtterance&>(*utterance.client()), true);
+        handleSpeakingCompleted(static_cast<SpeechSynthesisUtterance&>(*utterance.client()), error);
 }
 
 } // namespace WebCore

Source/WebCore/Modules/speech/SpeechSynthesis.h

@@ -74,20 +74,20 @@ class SpeechSynthesis : public PlatformSpeechSynthesizerClient, public SpeechSyn
     void didPauseSpeaking(PlatformSpeechSynthesisUtterance&) override;
     void didResumeSpeaking(PlatformSpeechSynthesisUtterance&) override;
     void didFinishSpeaking(PlatformSpeechSynthesisUtterance&) override;
-    void speakingErrorOccurred(PlatformSpeechSynthesisUtterance&) override;
+    void speakingErrorOccurred(PlatformSpeechSynthesisUtterance&, std::optional<SpeechSynthesisErrorCode>) override;
     void boundaryEventOccurred(PlatformSpeechSynthesisUtterance&, SpeechBoundary, unsigned charIndex, unsigned charLength) override;
 
     // SpeechSynthesisClient override methods
     void didStartSpeaking() override;
     void didFinishSpeaking() override;
     void didPauseSpeaking() override;
     void didResumeSpeaking() override;
-    void speakingErrorOccurred() override;
+    void speakingErrorOccurred(std::optional<SpeechSynthesisErrorCode>) override;
     void boundaryEventOccurred(bool wordBoundary, unsigned charIndex, unsigned charLength) override;
     void voicesChanged() override;
 
     void startSpeakingImmediately(SpeechSynthesisUtterance&);
-    void handleSpeakingCompleted(SpeechSynthesisUtterance&, bool errorOccurred);
+    void handleSpeakingCompleted(SpeechSynthesisUtterance&, std::optional<SpeechSynthesisErrorCode>);
     void fireEvent(const AtomString& type, SpeechSynthesisUtterance&, unsigned long charIndex, unsigned long charLength, const String& name) const;
     void fireErrorEvent(const AtomString& type, SpeechSynthesisUtterance&, SpeechSynthesisErrorCode) const;
 

Source/WebCore/Modules/speech/SpeechSynthesisErrorEventInit.h

@@ -28,6 +28,7 @@
 #if ENABLE(SPEECH_SYNTHESIS)
 
 #include "SpeechSynthesisEventInit.h"
+#include "SpeechSynthesisErrorCode.h"
 
 namespace WebCore {
 

Source/WebCore/page/SpeechSynthesisClient.h

@@ -34,6 +34,7 @@ namespace WebCore {
 class PlatformSpeechSynthesisUtterance;
 class SpeechSynthesisClientObserver;
 class PlatformSpeechSynthesisVoice;
+enum class SpeechSynthesisErrorCode;
 
 class SpeechSynthesisClient : public CanMakeWeakPtr<SpeechSynthesisClient> {
 public:
@@ -59,7 +60,7 @@ class SpeechSynthesisClientObserver : public CanMakeWeakPtr<SpeechSynthesisClien
     virtual void didFinishSpeaking() = 0;
     virtual void didPauseSpeaking() = 0;
     virtual void didResumeSpeaking() = 0;
-    virtual void speakingErrorOccurred() = 0;
+    virtual void speakingErrorOccurred(std::optional<SpeechSynthesisErrorCode>) = 0;
     virtual void boundaryEventOccurred(bool wordBoundary, unsigned charIndex, unsigned charLength) = 0;
     virtual void voicesChanged() = 0;
 };

Source/WebCore/platform/PlatformSpeechSynthesizer.h

@@ -29,6 +29,8 @@
 #if ENABLE(SPEECH_SYNTHESIS)
 
 #include "PlatformSpeechSynthesisVoice.h"
+#include "SpeechSynthesisErrorCode.h"
+#include <optional>
 #include <wtf/Vector.h>
 
 #if PLATFORM(COCOA)
@@ -51,7 +53,7 @@ class PlatformSpeechSynthesizerClient {
     virtual void didFinishSpeaking(PlatformSpeechSynthesisUtterance&) = 0;
     virtual void didPauseSpeaking(PlatformSpeechSynthesisUtterance&) = 0;
     virtual void didResumeSpeaking(PlatformSpeechSynthesisUtterance&) = 0;
-    virtual void speakingErrorOccurred(PlatformSpeechSynthesisUtterance&) = 0;
+    virtual void speakingErrorOccurred(PlatformSpeechSynthesisUtterance&, std::optional<SpeechSynthesisErrorCode>) = 0;
     virtual void boundaryEventOccurred(PlatformSpeechSynthesisUtterance&, SpeechBoundary, unsigned charIndex, unsigned charLength) = 0;
     virtual void voicesDidChange() = 0;
 protected:

Source/WebCore/platform/mock/PlatformSpeechSynthesizerMock.cpp

@@ -75,7 +75,7 @@ void PlatformSpeechSynthesizerMock::cancel()
         return;
 
     m_speakingFinishedTimer.stop();
-    client()->speakingErrorOccurred(*m_utterance);
+    client()->speakingErrorOccurred(*m_utterance, SpeechSynthesisErrorCode::Canceled);
     m_utterance = nullptr;
 }
 

Source/WebKit/UIProcess/WebPageProxy.cpp

@@ -11032,6 +11032,48 @@ void WebPageProxy::speechSynthesisResume(CompletionHandler<void()>&& completionH
     speechSynthesisData().speakingResumedCompletionHandler = WTFMove(completionHandler);
     speechSynthesisData().synthesizer->resume();
 }
+
+void WebPageProxy::didStartSpeaking(WebCore::PlatformSpeechSynthesisUtterance&)
+{
+    if (speechSynthesisData().speakingStartedCompletionHandler)
+        speechSynthesisData().speakingStartedCompletionHandler();
+}
+
+void WebPageProxy::didFinishSpeaking(WebCore::PlatformSpeechSynthesisUtterance&)
+{
+    if (speechSynthesisData().speakingFinishedCompletionHandler)
+        speechSynthesisData().speakingFinishedCompletionHandler();
+}
+
+void WebPageProxy::didPauseSpeaking(WebCore::PlatformSpeechSynthesisUtterance&)
+{
+    if (speechSynthesisData().speakingPausedCompletionHandler)
+        speechSynthesisData().speakingPausedCompletionHandler();
+}
+
+void WebPageProxy::didResumeSpeaking(WebCore::PlatformSpeechSynthesisUtterance&)
+{
+    if (speechSynthesisData().speakingResumedCompletionHandler)
+        speechSynthesisData().speakingResumedCompletionHandler();
+}
+
+void WebPageProxy::speakingErrorOccurred(WebCore::PlatformSpeechSynthesisUtterance&, std::optional<WebCore::SpeechSynthesisErrorCode> error)
+{
+    if (!error)
+        send(Messages::WebPage::SpeakingErrorOccurred(std::numeric_limits<uint8_t>::max()));
+    else
+        send(Messages::WebPage::SpeakingErrorOccurred(static_cast<uint8_t>(*error)));
+}
+
+void WebPageProxy::boundaryEventOccurred(WebCore::PlatformSpeechSynthesisUtterance&, WebCore::SpeechBoundary speechBoundary, unsigned charIndex, unsigned charLength)
+{
+    send(Messages::WebPage::BoundaryEventOccurred(speechBoundary == WebCore::SpeechBoundary::SpeechWordBoundary, charIndex, charLength));
+}
+
+void WebPageProxy::voicesDidChange()
+{
+    send(Messages::WebPage::VoicesDidChange());
+}
 #endif // ENABLE(SPEECH_SYNTHESIS)
 
 #if !PLATFORM(IOS_FAMILY)

Source/WebKit/UIProcess/WebPageProxy.h

@@ -2662,7 +2662,7 @@ class WebPageProxy final : public API::ObjectImpl<API::Object::Type::Page>
     void didFinishSpeaking(WebCore::PlatformSpeechSynthesisUtterance&) final;
     void didPauseSpeaking(WebCore::PlatformSpeechSynthesisUtterance&) final;
     void didResumeSpeaking(WebCore::PlatformSpeechSynthesisUtterance&) final;
-    void speakingErrorOccurred(WebCore::PlatformSpeechSynthesisUtterance&) final;
+    void speakingErrorOccurred(WebCore::PlatformSpeechSynthesisUtterance&, std::optional<WebCore::SpeechSynthesisErrorCode>) final;
     void boundaryEventOccurred(WebCore::PlatformSpeechSynthesisUtterance&, WebCore::SpeechBoundary, unsigned charIndex, unsigned charLength) final;
     void voicesDidChange() final;
 

Source/WebKit/WebProcess/WebPage/WebPage.cpp

@@ -221,6 +221,7 @@
 #include <WebCore/PingLoader.h>
 #include <WebCore/PlatformKeyboardEvent.h>
 #include <WebCore/PlatformMediaSessionManager.h>
+#include <WebCore/PlatformSpeechSynthesizer.h>
 #include <WebCore/PlatformStrategies.h>
 #include <WebCore/PluginDocument.h>
 #include <WebCore/PointerCaptureController.h>
@@ -7481,10 +7482,12 @@ void WebPage::systemPreviewActionTriggered(WebCore::SystemPreviewInfo previewInf
 #endif
 
 #if ENABLE(SPEECH_SYNTHESIS)
-void WebPage::speakingErrorOccurred()
+void WebPage::speakingErrorOccurred(uint8_t error)
 {
     if (auto observer = corePage()->speechSynthesisClient()->observer())
-        observer->speakingErrorOccurred();
+        observer->speakingErrorOccurred(error == std::numeric_limits<uint8_t>::max()
+                                        ? std::nullopt
+                                        : std::make_optional(static_cast<WebCore::SpeechSynthesisErrorCode>(error)));
 }
 
 void WebPage::boundaryEventOccurred(bool wordBoundary, unsigned charIndex, unsigned charLength)