3c360e0ce29669b3e07816dbf79d7d767e9efdc6
[WebKit-https.git] / Tools / DumpRenderTree / chromium / MockWebSpeechRecognizer.cpp
1 /*
2  * Copyright (C) 2012 Google Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  *
8  * 1.  Redistributions of source code must retain the above copyright
9  *     notice, this list of conditions and the following disclaimer.
10  * 2.  Redistributions in binary form must reproduce the above copyright
11  *     notice, this list of conditions and the following disclaimer in the
12  *     documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
16  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
17  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
18  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
19  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
21  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "MockWebSpeechRecognizer.h"
28
29 #if ENABLE(SCRIPTED_SPEECH)
30
31 #include "Task.h"
32 #include "WebSpeechRecognitionResult.h"
33 #include "WebSpeechRecognizerClient.h"
34
35 using namespace WebKit;
36 using namespace WebTestRunner;
37
38 namespace {
39
40 // Task class for calling a client function that does not take any parameters.
41 typedef void (WebSpeechRecognizerClient::*ClientFunctionPointer)(const WebSpeechRecognitionHandle&);
42 class ClientCallTask : public MockWebSpeechRecognizer::Task {
43 public:
44     ClientCallTask(MockWebSpeechRecognizer* mock, ClientFunctionPointer function)
45         : MockWebSpeechRecognizer::Task(mock)
46         , m_function(function)
47     {
48     }
49
50     virtual void run() OVERRIDE { (m_recognizer->client()->*m_function)(m_recognizer->handle()); }
51
52 private:
53     ClientFunctionPointer m_function;
54 };
55
56 // Task for delivering a result event.
57 class ResultTask : public MockWebSpeechRecognizer::Task {
58 public:
59     ResultTask(MockWebSpeechRecognizer* mock, const WebString transcript, float confidence)
60         : MockWebSpeechRecognizer::Task(mock)
61         , m_transcript(transcript)
62         , m_confidence(confidence)
63     {
64     }
65
66     virtual void run() OVERRIDE
67     {
68         WebVector<WebString> transcripts(static_cast<size_t>(1));
69         WebVector<float> confidences(static_cast<size_t>(1));
70         transcripts[0] = m_transcript;
71         confidences[0] = m_confidence;
72         WebVector<WebSpeechRecognitionResult> finalResults(static_cast<size_t>(1));
73         WebVector<WebSpeechRecognitionResult> interimResults;
74         finalResults[0].assign(transcripts, confidences, true);
75
76         m_recognizer->client()->didReceiveResults(m_recognizer->handle(), finalResults, interimResults);
77     }
78
79 private:
80     WebString m_transcript;
81     float m_confidence;
82 };
83
84 // Task for delivering a nomatch event.
85 class NoMatchTask : public MockWebSpeechRecognizer::Task {
86 public:
87     NoMatchTask(MockWebSpeechRecognizer* mock) : MockWebSpeechRecognizer::Task(mock) { }
88     virtual void run() OVERRIDE { m_recognizer->client()->didReceiveNoMatch(m_recognizer->handle(), WebSpeechRecognitionResult()); }
89 };
90
91 // Task for delivering an error event.
92 class ErrorTask : public MockWebSpeechRecognizer::Task {
93 public:
94     ErrorTask(MockWebSpeechRecognizer* mock, WebSpeechRecognizerClient::ErrorCode code, const WebString& message)
95         : MockWebSpeechRecognizer::Task(mock)
96         , m_code(code)
97         , m_message(message)
98     {
99     }
100
101     virtual void run() OVERRIDE { m_recognizer->client()->didReceiveError(m_recognizer->handle(), m_message, m_code); }
102
103 private:
104     WebSpeechRecognizerClient::ErrorCode m_code;
105     WebString m_message;
106 };
107
108 } // namespace
109
110 PassOwnPtr<MockWebSpeechRecognizer> MockWebSpeechRecognizer::create()
111 {
112     return adoptPtr(new MockWebSpeechRecognizer());
113 }
114
115 void MockWebSpeechRecognizer::start(const WebSpeechRecognitionHandle& handle, const WebSpeechRecognitionParams& params, WebSpeechRecognizerClient* client)
116 {
117     m_wasAborted = false;
118     m_handle = handle;
119     m_client = client;
120
121     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didStart)));
122     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didStartAudio)));
123     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didStartSound)));
124
125     if (!m_mockTranscripts.isEmpty()) {
126         ASSERT(m_mockTranscripts.size() == m_mockConfidences.size());
127
128         for (size_t i = 0; i < m_mockTranscripts.size(); ++i)
129             m_taskQueue.append(adoptPtr(new ResultTask(this, m_mockTranscripts[i], m_mockConfidences[i])));
130
131         m_mockTranscripts.clear();
132         m_mockConfidences.clear();
133     } else
134         m_taskQueue.append(adoptPtr(new NoMatchTask(this)));
135
136     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didEndSound)));
137     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didEndAudio)));
138     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didEnd)));
139
140     startTaskQueue();
141 }
142
143 void MockWebSpeechRecognizer::stop(const WebSpeechRecognitionHandle& handle, WebSpeechRecognizerClient* client)
144 {
145     m_handle = handle;
146     m_client = client;
147
148     // FIXME: Implement.
149     ASSERT_NOT_REACHED();
150 }
151
152 void MockWebSpeechRecognizer::abort(const WebSpeechRecognitionHandle& handle, WebSpeechRecognizerClient* client)
153 {
154     m_handle = handle;
155     m_client = client;
156
157     clearTaskQueue();
158     m_wasAborted = true;
159     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didEnd)));
160     startTaskQueue();
161 }
162
163 void MockWebSpeechRecognizer::addMockResult(const WebString& transcript, float confidence)
164 {
165     m_mockTranscripts.append(transcript);
166     m_mockConfidences.append(confidence);
167 }
168
169 void MockWebSpeechRecognizer::setError(const WebString& error, const WebString& message)
170 {
171     WebSpeechRecognizerClient::ErrorCode code;
172     if (error == "OtherError")
173         code = WebSpeechRecognizerClient::OtherError;
174     else if (error == "NoSpeechError")
175         code = WebSpeechRecognizerClient::NoSpeechError;
176     else if (error == "AbortedError")
177         code = WebSpeechRecognizerClient::AbortedError;
178     else if (error == "AudioCaptureError")
179         code = WebSpeechRecognizerClient::AudioCaptureError;
180     else if (error == "NetworkError")
181         code = WebSpeechRecognizerClient::NetworkError;
182     else if (error == "NotAllowedError")
183         code = WebSpeechRecognizerClient::NotAllowedError;
184     else if (error == "ServiceNotAllowedError")
185         code = WebSpeechRecognizerClient::ServiceNotAllowedError;
186     else if (error == "BadGrammarError")
187         code = WebSpeechRecognizerClient::BadGrammarError;
188     else if (error == "LanguageNotSupportedError")
189         code = WebSpeechRecognizerClient::LanguageNotSupportedError;
190     else
191         return;
192
193     clearTaskQueue();
194     m_taskQueue.append(adoptPtr(new ErrorTask(this, code, message)));
195     m_taskQueue.append(adoptPtr(new ClientCallTask(this, &WebSpeechRecognizerClient::didEnd)));
196     startTaskQueue();
197 }
198
199 MockWebSpeechRecognizer::MockWebSpeechRecognizer()
200     : m_wasAborted(false)
201     , m_taskQueueRunning(false)
202 {
203 }
204
205 MockWebSpeechRecognizer::~MockWebSpeechRecognizer()
206 {
207 }
208
209 void MockWebSpeechRecognizer::startTaskQueue()
210 {
211     if (m_taskQueueRunning)
212         return;
213     postTask(new StepTask(this));
214     m_taskQueueRunning = true;
215 }
216
217 void MockWebSpeechRecognizer::clearTaskQueue()
218 {
219     m_taskQueue.clear();
220     m_taskQueueRunning = false;
221 }
222
223 void MockWebSpeechRecognizer::StepTask::runIfValid()
224 {
225     if (m_object->m_taskQueue.isEmpty()) {
226         m_object->m_taskQueueRunning = false;
227         return;
228     }
229
230     OwnPtr<Task> task = m_object->m_taskQueue[0].release();
231     m_object->m_taskQueue.remove(0);
232     task->run();
233
234     if (m_object->m_taskQueue.isEmpty()) {
235         m_object->m_taskQueueRunning = false;
236         return;
237     }
238
239     postTask(new StepTask(m_object));
240 }
241
242 #endif // ENABLE(SCRIPTED_SPEECH)