OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "components/test_runner/mock_web_speech_recognizer.h" | 5 #include "components/test_runner/mock_web_speech_recognizer.h" |
6 | 6 |
7 #include <stddef.h> | 7 #include <stddef.h> |
8 | 8 |
9 #include "base/bind.h" | 9 #include "base/bind.h" |
10 #include "base/bind_helpers.h" | 10 #include "base/bind_helpers.h" |
(...skipping 102 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
113 // Task for tidying up after recognition task has ended. | 113 // Task for tidying up after recognition task has ended. |
114 class EndedTask : public MockWebSpeechRecognizer::Task { | 114 class EndedTask : public MockWebSpeechRecognizer::Task { |
115 public: | 115 public: |
116 EndedTask(MockWebSpeechRecognizer* mock) | 116 EndedTask(MockWebSpeechRecognizer* mock) |
117 : MockWebSpeechRecognizer::Task(mock) {} | 117 : MockWebSpeechRecognizer::Task(mock) {} |
118 | 118 |
119 ~EndedTask() override {} | 119 ~EndedTask() override {} |
120 | 120 |
121 void run() override { | 121 void run() override { |
122 blink::WebSpeechRecognitionHandle handle = recognizer_->Handle(); | 122 blink::WebSpeechRecognitionHandle handle = recognizer_->Handle(); |
123 recognizer_->Handle().reset(); | 123 blink::WebSpeechRecognizerClient* client = recognizer_->Client(); |
124 recognizer_->Client()->didEnd(handle); | 124 recognizer_->SetClientContext(blink::WebSpeechRecognitionHandle(), nullptr); |
| 125 client->didEnd(handle); |
125 } | 126 } |
126 | 127 |
127 private: | 128 private: |
128 DISALLOW_COPY_AND_ASSIGN(EndedTask); | 129 DISALLOW_COPY_AND_ASSIGN(EndedTask); |
129 }; | 130 }; |
130 | 131 |
| 132 // Task for switching processing to the next (handle, client) pairing. |
| 133 class SwitchClientHandleTask : public MockWebSpeechRecognizer::Task { |
| 134 public: |
| 135 SwitchClientHandleTask(MockWebSpeechRecognizer* mock, |
| 136 const blink::WebSpeechRecognitionHandle& handle, |
| 137 blink::WebSpeechRecognizerClient* client) |
| 138 : MockWebSpeechRecognizer::Task(mock), handle_(handle), client_(client) {} |
| 139 |
| 140 ~SwitchClientHandleTask() override {} |
| 141 |
| 142 bool isNewContextTask() const override { return true; } |
| 143 |
| 144 void run() override { recognizer_->SetClientContext(handle_, client_); } |
| 145 |
| 146 private: |
| 147 const blink::WebSpeechRecognitionHandle handle_; |
| 148 blink::WebSpeechRecognizerClient* client_; |
| 149 |
| 150 DISALLOW_COPY_AND_ASSIGN(SwitchClientHandleTask); |
| 151 }; |
| 152 |
131 } // namespace | 153 } // namespace |
132 | 154 |
133 MockWebSpeechRecognizer::MockWebSpeechRecognizer() | 155 MockWebSpeechRecognizer::MockWebSpeechRecognizer() |
134 : was_aborted_(false), | 156 : client_(nullptr), |
| 157 was_aborted_(false), |
135 task_queue_running_(false), | 158 task_queue_running_(false), |
136 delegate_(0), | 159 delegate_(0), |
137 weak_factory_(this) {} | 160 weak_factory_(this) {} |
138 | 161 |
139 MockWebSpeechRecognizer::~MockWebSpeechRecognizer() { | 162 MockWebSpeechRecognizer::~MockWebSpeechRecognizer() { |
140 ClearTaskQueue(); | 163 ClearTaskQueue(); |
141 } | 164 } |
142 | 165 |
| 166 bool MockWebSpeechRecognizer::Task::isNewContextTask() const { |
| 167 return false; |
| 168 } |
| 169 |
143 void MockWebSpeechRecognizer::SetDelegate(WebTestDelegate* delegate) { | 170 void MockWebSpeechRecognizer::SetDelegate(WebTestDelegate* delegate) { |
144 delegate_ = delegate; | 171 delegate_ = delegate; |
145 } | 172 } |
146 | 173 |
| 174 void MockWebSpeechRecognizer::SetClientContext( |
| 175 const blink::WebSpeechRecognitionHandle& handle, |
| 176 blink::WebSpeechRecognizerClient* client) { |
| 177 handle_ = handle; |
| 178 client_ = client; |
| 179 } |
| 180 |
147 void MockWebSpeechRecognizer::start( | 181 void MockWebSpeechRecognizer::start( |
148 const blink::WebSpeechRecognitionHandle& handle, | 182 const blink::WebSpeechRecognitionHandle& handle, |
149 const blink::WebSpeechRecognitionParams& params, | 183 const blink::WebSpeechRecognitionParams& params, |
150 blink::WebSpeechRecognizerClient* client) { | 184 blink::WebSpeechRecognizerClient* client) { |
151 was_aborted_ = false; | 185 was_aborted_ = false; |
152 handle_ = handle; | 186 if (!client_) { |
153 client_ = client; | 187 handle_ = handle; |
| 188 client_ = client; |
| 189 } else { |
| 190 task_queue_.push_back(new SwitchClientHandleTask(this, handle, client)); |
| 191 } |
154 | 192 |
155 task_queue_.push_back( | 193 task_queue_.push_back( |
156 new ClientCallTask(this, &blink::WebSpeechRecognizerClient::didStart)); | 194 new ClientCallTask(this, &blink::WebSpeechRecognizerClient::didStart)); |
157 task_queue_.push_back(new ClientCallTask( | 195 task_queue_.push_back(new ClientCallTask( |
158 this, &blink::WebSpeechRecognizerClient::didStartAudio)); | 196 this, &blink::WebSpeechRecognizerClient::didStartAudio)); |
159 task_queue_.push_back(new ClientCallTask( | 197 task_queue_.push_back(new ClientCallTask( |
160 this, &blink::WebSpeechRecognizerClient::didStartSound)); | 198 this, &blink::WebSpeechRecognizerClient::didStartSound)); |
161 | 199 |
162 if (!mock_transcripts_.empty()) { | 200 if (!mock_transcripts_.empty()) { |
163 DCHECK_EQ(mock_transcripts_.size(), mock_confidences_.size()); | 201 DCHECK_EQ(mock_transcripts_.size(), mock_confidences_.size()); |
(...skipping 12 matching lines...) Expand all Loading... |
176 task_queue_.push_back( | 214 task_queue_.push_back( |
177 new ClientCallTask(this, &blink::WebSpeechRecognizerClient::didEndAudio)); | 215 new ClientCallTask(this, &blink::WebSpeechRecognizerClient::didEndAudio)); |
178 task_queue_.push_back(new EndedTask(this)); | 216 task_queue_.push_back(new EndedTask(this)); |
179 | 217 |
180 StartTaskQueue(); | 218 StartTaskQueue(); |
181 } | 219 } |
182 | 220 |
183 void MockWebSpeechRecognizer::stop( | 221 void MockWebSpeechRecognizer::stop( |
184 const blink::WebSpeechRecognitionHandle& handle, | 222 const blink::WebSpeechRecognitionHandle& handle, |
185 blink::WebSpeechRecognizerClient* client) { | 223 blink::WebSpeechRecognizerClient* client) { |
186 handle_ = handle; | 224 SetClientContext(handle, client); |
187 client_ = client; | |
188 | 225 |
189 // FIXME: Implement. | 226 // FIXME: Implement. |
190 NOTREACHED(); | 227 NOTREACHED(); |
191 } | 228 } |
192 | 229 |
193 void MockWebSpeechRecognizer::abort( | 230 void MockWebSpeechRecognizer::abort( |
194 const blink::WebSpeechRecognitionHandle& handle, | 231 const blink::WebSpeechRecognitionHandle& handle, |
195 blink::WebSpeechRecognizerClient* client) { | 232 blink::WebSpeechRecognizerClient* client) { |
196 handle_ = handle; | 233 was_aborted_ = true; |
197 client_ = client; | |
198 | |
199 ClearTaskQueue(); | 234 ClearTaskQueue(); |
200 was_aborted_ = true; | 235 task_queue_.push_back(new SwitchClientHandleTask(this, handle, client)); |
201 task_queue_.push_back(new EndedTask(this)); | 236 task_queue_.push_back(new EndedTask(this)); |
202 | 237 |
203 StartTaskQueue(); | 238 StartTaskQueue(); |
204 } | 239 } |
205 | 240 |
206 void MockWebSpeechRecognizer::AddMockResult(const blink::WebString& transcript, | 241 void MockWebSpeechRecognizer::AddMockResult(const blink::WebString& transcript, |
207 float confidence) { | 242 float confidence) { |
208 mock_transcripts_.push_back(transcript); | 243 mock_transcripts_.push_back(transcript); |
209 mock_confidences_.push_back(confidence); | 244 mock_confidences_.push_back(confidence); |
210 } | 245 } |
(...skipping 30 matching lines...) Expand all Loading... |
241 } | 276 } |
242 | 277 |
243 void MockWebSpeechRecognizer::StartTaskQueue() { | 278 void MockWebSpeechRecognizer::StartTaskQueue() { |
244 if (task_queue_running_) | 279 if (task_queue_running_) |
245 return; | 280 return; |
246 PostRunTaskFromQueue(); | 281 PostRunTaskFromQueue(); |
247 } | 282 } |
248 | 283 |
249 void MockWebSpeechRecognizer::ClearTaskQueue() { | 284 void MockWebSpeechRecognizer::ClearTaskQueue() { |
250 while (!task_queue_.empty()) { | 285 while (!task_queue_.empty()) { |
| 286 Task* task = task_queue_.front(); |
| 287 if (task->isNewContextTask()) |
| 288 break; |
251 delete task_queue_.front(); | 289 delete task_queue_.front(); |
252 task_queue_.pop_front(); | 290 task_queue_.pop_front(); |
253 } | 291 } |
254 task_queue_running_ = false; | 292 if (task_queue_.empty()) |
| 293 task_queue_running_ = false; |
255 } | 294 } |
256 | 295 |
257 void MockWebSpeechRecognizer::PostRunTaskFromQueue() { | 296 void MockWebSpeechRecognizer::PostRunTaskFromQueue() { |
258 task_queue_running_ = true; | 297 task_queue_running_ = true; |
259 delegate_->PostTask(base::Bind(&MockWebSpeechRecognizer::RunTaskFromQueue, | 298 delegate_->PostTask(base::Bind(&MockWebSpeechRecognizer::RunTaskFromQueue, |
260 weak_factory_.GetWeakPtr())); | 299 weak_factory_.GetWeakPtr())); |
261 } | 300 } |
262 | 301 |
263 void MockWebSpeechRecognizer::RunTaskFromQueue() { | 302 void MockWebSpeechRecognizer::RunTaskFromQueue() { |
264 if (task_queue_.empty()) { | 303 if (task_queue_.empty()) { |
265 task_queue_running_ = false; | 304 task_queue_running_ = false; |
266 return; | 305 return; |
267 } | 306 } |
268 | 307 |
269 MockWebSpeechRecognizer::Task* task = task_queue_.front(); | 308 MockWebSpeechRecognizer::Task* task = task_queue_.front(); |
270 task_queue_.pop_front(); | 309 task_queue_.pop_front(); |
271 task->run(); | 310 task->run(); |
272 delete task; | 311 delete task; |
273 | 312 |
274 if (task_queue_.empty()) { | 313 if (task_queue_.empty()) { |
275 task_queue_running_ = false; | 314 task_queue_running_ = false; |
276 return; | 315 return; |
277 } | 316 } |
278 | 317 |
279 PostRunTaskFromQueue(); | 318 PostRunTaskFromQueue(); |
280 } | 319 } |
281 | 320 |
282 } // namespace test_runner | 321 } // namespace test_runner |
OLD | NEW |