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..7fcad076cc6118a1e40957f6b32c326034aa2c38
--- /dev/null
+++ b/media/midi/task_service.cc
@@ -0,0 +1,142 @@
+// 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;
+constexpr TaskService::RunnerId kReplyRunnerId = -1;
+
+}  // namespace
+
+TaskService::TaskService()
+    : next_instance_id_(0), bound_instance_id_(kInvalidInstanceId) {}
+
+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;
+  // Now RunTask never run any posted task. But invoked tasks might be still

[yhirano, 2017/06/08 09:03:38]

[optional] "From now on RunTask will never run any task bound to the instance
id..."

[Takashi Toyoshima, 2017/06/08 10:30:11]

Done.

+  // running here. To ensure no task run before quiting this method, take all
+  // |thread_task_locks_| once.
+  for (auto& task_lock : thread_task_locks_)
+    base::AutoLock auto_task_lock(*task_lock);
+  base::AutoLock reply_lock(reply_task_lock_);
+  return true;
+}
+
+void TaskService::PostStaticTask(RunnerId runner, base::OnceClosure task) {
+  base::AutoLock lock(lock_);
+  GetTaskRunner(runner)->PostTask(FROM_HERE, std::move(task));
+}
+
+void TaskService::PostBoundTask(RunnerId runner, base::OnceClosure task) {
+  base::AutoLock instance_lock(instance_lock_);
+  if (bound_instance_id_ == kInvalidInstanceId)
+    return;
+  base::AutoLock lock(lock_);
+  GetTaskRunner(runner)->PostTask(
+      FROM_HERE, base::BindOnce(&TaskService::RunTask, base::Unretained(this),
+                                bound_instance_id_, runner, std::move(task)));
+}
+
+void TaskService::PostBoundDelayedTask(RunnerId runner,
+                                       base::OnceClosure task,
+                                       base::TimeDelta delay) {
+  base::AutoLock instance_lock(instance_lock_);
+  if (bound_instance_id_ == kInvalidInstanceId)
+    return;
+  base::AutoLock lock(lock_);
+  GetTaskRunner(runner)->PostDelayedTask(
+      FROM_HERE,
+      base::BindOnce(&TaskService::RunTask, base::Unretained(this),
+                     bound_instance_id_, runner, std::move(task)),
+      delay);
+}
+
+void TaskService::PostBoundReplyTask(base::OnceClosure task) {
+  base::AutoLock instance_lock(instance_lock_);
+  if (bound_instance_id_ == kInvalidInstanceId)
+    return;
+  base::AutoLock lock(lock_);
+  DCHECK(reply_task_runner_);
+  reply_task_runner_->PostTask(
+      FROM_HERE,
+      base::BindOnce(&TaskService::RunTask, base::Unretained(this),
+                     bound_instance_id_, kReplyRunnerId, std::move(task)));
+}
+
+scoped_refptr<base::SingleThreadTaskRunner> TaskService::GetTaskRunner(
+    RunnerId runner_id) {
+  lock_.AssertAcquired();
+  DCHECK_NE(runner_id, kReplyRunnerId);
+  DCHECK_EQ(threads_.size(), thread_task_locks_.size());
+  if (threads_.size() <= static_cast<size_t>(runner_id)) {
+    threads_.resize(runner_id + 1);
+    thread_task_locks_.resize(runner_id + 1);
+  }
+  if (!threads_[runner_id]) {
+    threads_[runner_id] = base::MakeUnique<base::Thread>(
+        base::StringPrintf("MidiService_TaskService_Thread(%d)", runner_id));
+#if defined(OS_WIN)
+    threads_[runner_id]->init_com_with_mta(true);
+#endif
+    threads_[runner_id]->Start();
+    DCHECK(!thread_task_locks_[runner_id]);
+    thread_task_locks_[runner_id] = base::MakeUnique<base::Lock>();
+  }
+  return threads_[runner_id]->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>(
+        (runner_id == kReplyRunnerId) ? reply_task_lock_
+                                      : *thread_task_locks_[runner_id]);
+  }
+  std::move(task).Run();
+}
+
+}  // namespace midi