Handle overlapping uses of MockWebSpeechRecognizer

components/test_runner/mock_web_speech_recognizer.cc

 // Copyright 2014 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 "components/test_runner/mock_web_speech_recognizer.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 102 matching lines @@
 // Task for tidying up after recognition task has ended.
 class EndedTask : public MockWebSpeechRecognizer::Task {
  public:
   EndedTask(MockWebSpeechRecognizer* mock)
       : MockWebSpeechRecognizer::Task(mock) {}
 
   ~EndedTask() override {}
 
   void run() override {
     blink::WebSpeechRecognitionHandle handle = recognizer_->Handle();
-    recognizer_->Handle().reset();
-    recognizer_->Client()->didEnd(handle);
+    blink::WebSpeechRecognizerClient* client = recognizer_->Client();
+    recognizer_->SetClientContext(blink::WebSpeechRecognitionHandle(), nullptr);
+    client->didEnd(handle);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(EndedTask);
 };
 
+// Task for switching processing to the next (handle, client) pairing.
+class SwitchClientHandleTask : public MockWebSpeechRecognizer::Task {
+ public:
+  SwitchClientHandleTask(
+      MockWebSpeechRecognizer* mock,
+      const blink::WebSpeechRecognitionHandle& handle,
+      blink::WebSpeechRecognizerClient* client)
+      : MockWebSpeechRecognizer::Task(mock)
+      , handle_(handle)

[dmazzoni, 2016/11/28 16:58:02]

nit: in Chromium code the comma goes at the end of the previous line, unlike
Blink. Indentation is fine.

[sof, 2016/11/28 21:40:04]

Fixed, ran git-cl-format (no PRESUBMIT.py in this directory.)

+      , client_(client) {}
+
+  ~SwitchClientHandleTask() override {}
+
+  bool isNewContextTask() const override { return true; }
+
+  void run() override {
+    recognizer_->SetClientContext(handle_, client_);
+  }
+
+ private:
+  const blink::WebSpeechRecognitionHandle handle_;
+  blink::WebSpeechRecognizerClient* client_;
+
+  DISALLOW_COPY_AND_ASSIGN(SwitchClientHandleTask);
+};
+
 }  // namespace
 
 MockWebSpeechRecognizer::MockWebSpeechRecognizer()
-    : was_aborted_(false),
+    : client_(nullptr),
+      was_aborted_(false),
       task_queue_running_(false),
       delegate_(0),
       weak_factory_(this) {}
 
 MockWebSpeechRecognizer::~MockWebSpeechRecognizer() {
   ClearTaskQueue();
 }
 
+bool MockWebSpeechRecognizer::Task::isNewContextTask() const {
+  return false;
+}
+
 void MockWebSpeechRecognizer::SetDelegate(WebTestDelegate* delegate) {
   delegate_ = delegate;
 }
 
+void MockWebSpeechRecognizer::SetClientContext(
+    const blink::WebSpeechRecognitionHandle& handle,
+    blink::WebSpeechRecognizerClient* client) {
+   handle_ = handle;

[dmazzoni, 2016/11/28 16:58:02]

nit: should be 2 spaces indent

[sof, 2016/11/28 21:40:04]

Done.

+   client_ = client;

[dmazzoni, 2016/11/28 16:58:02]

Can you DCHECK(client_) or is it okay for it to be nullptr?

[sof, 2016/11/28 21:40:04]

There's no separate method provided for clearing, so EndedTask will use
SetClientContext(.., nullptr) to clear client_ when it runs. Hence asserting for
!nullptr wouldn't be on.

+}
+
 void MockWebSpeechRecognizer::start(
     const blink::WebSpeechRecognitionHandle& handle,
     const blink::WebSpeechRecognitionParams& params,
     blink::WebSpeechRecognizerClient* client) {
   was_aborted_ = false;
-  handle_ = handle;
-  client_ = client;
+  if (!client_) {
+    handle_ = handle;
+    client_ = client;
+  } else {
+    task_queue_.push_back(
+        new SwitchClientHandleTask(this, handle, client));
+  }
 
   task_queue_.push_back(
       new ClientCallTask(this, &blink::WebSpeechRecognizerClient::didStart));
   task_queue_.push_back(new ClientCallTask(
       this, &blink::WebSpeechRecognizerClient::didStartAudio));
   task_queue_.push_back(new ClientCallTask(
       this, &blink::WebSpeechRecognizerClient::didStartSound));
 
   if (!mock_transcripts_.empty()) {
     DCHECK_EQ(mock_transcripts_.size(), mock_confidences_.size());
@@ skipping 12 matching lines @@
   task_queue_.push_back(
       new ClientCallTask(this, &blink::WebSpeechRecognizerClient::didEndAudio));
   task_queue_.push_back(new EndedTask(this));
 
   StartTaskQueue();
 }
 
 void MockWebSpeechRecognizer::stop(
     const blink::WebSpeechRecognitionHandle& handle,
     blink::WebSpeechRecognizerClient* client) {
-  handle_ = handle;
-  client_ = client;
+  SetClientContext(handle, client);
 
   // FIXME: Implement.
   NOTREACHED();
 }
 
 void MockWebSpeechRecognizer::abort(
     const blink::WebSpeechRecognitionHandle& handle,
     blink::WebSpeechRecognizerClient* client) {
-  handle_ = handle;
-  client_ = client;
-
+  was_aborted_ = true;
   ClearTaskQueue();
-  was_aborted_ = true;
+  task_queue_.push_back(
+      new SwitchClientHandleTask(this, handle, client));
   task_queue_.push_back(new EndedTask(this));
 
   StartTaskQueue();
 }
 
 void MockWebSpeechRecognizer::AddMockResult(const blink::WebString& transcript,
                                             float confidence) {
   mock_transcripts_.push_back(transcript);
   mock_confidences_.push_back(confidence);
 }
@@ skipping 30 matching lines @@
 }
 
 void MockWebSpeechRecognizer::StartTaskQueue() {
   if (task_queue_running_)
     return;
   PostRunTaskFromQueue();
 }
 
 void MockWebSpeechRecognizer::ClearTaskQueue() {
   while (!task_queue_.empty()) {
+    Task* task = task_queue_.front();
+    if (task->isNewContextTask())
+      break;
     delete task_queue_.front();
     task_queue_.pop_front();
   }
-  task_queue_running_ = false;
+  if (task_queue_.empty())
+    task_queue_running_ = false;
 }
 
 void MockWebSpeechRecognizer::PostRunTaskFromQueue() {
   task_queue_running_ = true;
   delegate_->PostTask(base::Bind(&MockWebSpeechRecognizer::RunTaskFromQueue,
                                  weak_factory_.GetWeakPtr()));
 }
 
 void MockWebSpeechRecognizer::RunTaskFromQueue() {
   if (task_queue_.empty()) {
     task_queue_running_ = false;
     return;
   }
 
   MockWebSpeechRecognizer::Task* task = task_queue_.front();
   task_queue_.pop_front();
   task->run();
   delete task;
 
   if (task_queue_.empty()) {
     task_queue_running_ = false;
     return;
   }
 
   PostRunTaskFromQueue();
 }
 
 }  // namespace test_runner