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
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 |