Web MIDI: implement TaskService

media/midi/task_service.cc

+// 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>();
+
+  // We do not need a dedicated thread for the default runner since it uses
+  // the thread that calls BindInstance(), but we allocates threads_ and keeps
+  // threads_[0] empty to use the same index between |thread_task_locks_| and
+  // |threads_| for readability.
+  threads_.resize(1);
+}
+
+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(!default_task_runner_);
+  default_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(default_task_runner_);
+  default_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 default_task_runner_;
+
+  DCHECK_EQ(threads_.size(), thread_task_locks_.size());
+
+  if (threads_.size() <= 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(%zu)", 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>(*thread_task_locks_[runner_id]);
+  }
+  std::move(task).Run();
+}
+
+}  // namespace midi