Web MIDI: implement TaskService

media/midi/task_service.cc

Index: media/midi/task_service.cc
diff --git a/media/midi/task_service.cc b/media/midi/task_service.cc
new file mode 100644
index 0000000000000000000000000000000000000000..bbc7f6966327ef8dfc64ca16c88b75e05fe24e1c
--- /dev/null
+++ b/media/midi/task_service.cc
@@ -0,0 +1,151 @@
+// Copyright 2017 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 "media/midi/task_service.h"
+
+#include "base/strings/stringprintf.h"
+#include "base/threading/thread_task_runner_handle.h"
+
+namespace midi {
+
+namespace {
+
+constexpr TaskService::InstanceId kInvalidInstanceId = -1;
+
+}  // namespace
+
+TaskService::TaskService()
+    : next_instance_id_(0), bound_instance_id_(kInvalidInstanceId) {
+  thread_task_locks_.resize(1);
+  thread_task_locks_[0] = base::MakeUnique<base::Lock>();
+}
+
+TaskService::~TaskService() {
+  base::AutoLock lock(lock_);
+  threads_.clear();
+}
+
+bool TaskService::BindInstance() {
+  {
+    base::AutoLock instance_lock(instance_lock_);
+    if (bound_instance_id_ != kInvalidInstanceId)
+      return false;
+    bound_instance_id_ = next_instance_id_++;
+  }
+  base::AutoLock lock(lock_);
+  DCHECK(!reply_task_runner_);
+  reply_task_runner_ = base::ThreadTaskRunnerHandle::Get();
+  return true;
+}
+
+bool TaskService::UnbindInstance() {
+  {
+    base::AutoLock instance_lock(instance_lock_);
+    if (bound_instance_id_ == kInvalidInstanceId)
+      return false;
+    bound_instance_id_ = kInvalidInstanceId;
+  }
+  base::AutoLock lock(lock_);
+  DCHECK(reply_task_runner_);
+  reply_task_runner_ = nullptr;
+  // From now on RunTask will never run any task bound to the instance id.
+  // But invoked tasks might be still running here. To ensure no task run before
+  // quitting this method, take all |thread_task_locks_| once.
+  for (auto& task_lock : thread_task_locks_)
+    base::AutoLock auto_task_lock(*task_lock);
+  return true;
+}
+
+void TaskService::PostStaticTask(RunnerId runner_id, base::OnceClosure task) {
+  scoped_refptr<base::SingleThreadTaskRunner> runner;
+  {
+    base::AutoLock lock(lock_);
+    runner = GetTaskRunner(runner_id);
+  }
+  runner->PostTask(FROM_HERE, std::move(task));
+}
+
+void TaskService::PostBoundTask(RunnerId runner_id, base::OnceClosure task) {
+  base::AutoLock instance_lock(instance_lock_);
+  if (bound_instance_id_ == kInvalidInstanceId)
+    return;
+  scoped_refptr<base::SingleThreadTaskRunner> runner;
+  InstanceId instance_id;
+  {
+    base::AutoLock lock(lock_);
+    runner = GetTaskRunner(runner_id);
+    instance_id = bound_instance_id_;
+  }
+  runner->PostTask(FROM_HERE,
+                   base::BindOnce(&TaskService::RunTask, base::Unretained(this),
+                                  instance_id, runner_id, std::move(task)));
+}
+
+void TaskService::PostBoundDelayedTask(RunnerId runner_id,
+                                       base::OnceClosure task,
+                                       base::TimeDelta delay) {
+  base::AutoLock instance_lock(instance_lock_);
+  if (bound_instance_id_ == kInvalidInstanceId)
+    return;
+  scoped_refptr<base::SingleThreadTaskRunner> runner;
+  InstanceId instance_id;
+  {
+    base::AutoLock lock(lock_);
+    runner = GetTaskRunner(runner_id);
+    instance_id = bound_instance_id_;
+  }
+  runner->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(&TaskService::RunTask, base::Unretained(this), instance_id,
+                     runner_id, std::move(task)),
+      delay);
+}
+
+scoped_refptr<base::SingleThreadTaskRunner> TaskService::GetTaskRunner(
+    RunnerId runner_id) {
+  lock_.AssertAcquired();
+  if (runner_id == kDefaultRunnerId)
+    return reply_task_runner_;
+
+  DCHECK_EQ(threads_.size() + 1u, thread_task_locks_.size());

[yhirano, 2017/06/12 07:54:44]

You don't need this "+1". Just leaving threads_[0] as nullptr is enough.

[Takashi Toyoshima, 2017/06/13 06:29:41]

sounds a nice idea to keep the code simple.
Done.

+  size_t thread_index = runner_id - 1;
+
+  if (threads_.size() <= thread_index) {
+    threads_.resize(thread_index + 1);
+    thread_task_locks_.resize(runner_id + 1);
+  }
+  if (!threads_[thread_index]) {
+    threads_[thread_index] = base::MakeUnique<base::Thread>(base::StringPrintf(
+        "MidiService_TaskService_Thread(%zu)", thread_index));
+#if defined(OS_WIN)
+    threads_[thread_index]->init_com_with_mta(true);
+#endif
+    threads_[thread_index]->Start();
+
+    DCHECK(!thread_task_locks_[runner_id]);
+    thread_task_locks_[runner_id] = base::MakeUnique<base::Lock>();
+  }
+  return threads_[thread_index]->task_runner();
+}
+
+void TaskService::RunTask(InstanceId instance_id,
+                          RunnerId runner_id,
+                          base::OnceClosure task) {
+  std::unique_ptr<base::AutoLock> task_lock;
+  {
+    base::AutoLock instance_lock(instance_lock_);
+    // If UnbindInstance() is already called, do nothing.
+    if (instance_id != bound_instance_id_)
+      return;
+
+    // Obtains task lock to ensure that the instance should not complete
+    // UnbindInstance() while running the |task|.
+    base::AutoLock lock(lock_);
+    task_lock =
+        base::MakeUnique<base::AutoLock>(*thread_task_locks_[runner_id]);
+  }
+  std::move(task).Run();
+}
+
+}  // namespace midi