Index: mojo/public/cpp/bindings/tests/thread_per_task_sequenced_task_runner.cc |
diff --git a/mojo/public/cpp/bindings/tests/thread_per_task_sequenced_task_runner.cc b/mojo/public/cpp/bindings/tests/thread_per_task_sequenced_task_runner.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..abc6452cbc98d5c149f258a4c4866344b4620164 |
--- /dev/null |
+++ b/mojo/public/cpp/bindings/tests/thread_per_task_sequenced_task_runner.cc |
@@ -0,0 +1,136 @@ |
+// 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 "mojo/public/cpp/bindings/tests/thread_per_task_sequenced_task_runner.h" |
+ |
+#include "base/bind.h" |
+#include "base/memory/ptr_util.h" |
+#include "base/run_loop.h" |
+#include "base/threading/sequenced_task_runner_handle.h" |
+#include "base/threading/simple_thread.h" |
+#include "testing/gtest/include/gtest/gtest.h" |
+ |
+namespace mojo { |
+namespace test { |
+ |
+class ThreadPerTaskSequencedTaskRunnerOwner::TaskRunnerImpl |
+ : public base::SequencedTaskRunner { |
+ public: |
+ TaskRunnerImpl() |
+ : main_runner_(base::SequencedTaskRunnerHandle::Get()), |
+ token_(base::SequenceToken::Create()) {} |
+ |
+ void ShutDown() { |
+ DCHECK(sequence_checker_.CalledOnValidSequence()); |
+ shut_down_ = true; |
+ task_queue_.clear(); |
+ if (worker_thread_) { |
+ worker_thread_->Join(); |
+ worker_thread_.reset(); |
+ base::RunLoop().RunUntilIdle(); |
+ } |
+ } |
+ |
+ bool PostDelayedTask(const tracked_objects::Location& from_here, |
+ const base::Closure& task, |
+ base::TimeDelta delay) override { |
+ return main_runner_->PostTask( |
+ FROM_HERE, |
+ base::Bind(&TaskRunnerImpl::PostTaskOnMainRunner, this, task)); |
+ } |
+ |
+ bool RunsTasksOnCurrentThread() const override { |
+ return base::SequenceToken::GetForCurrentThread() == token_; |
+ } |
+ |
+ bool PostNonNestableDelayedTask(const tracked_objects::Location& from_here, |
+ const base::Closure& task, |
+ base::TimeDelta delay) override { |
+ return PostDelayedTask(from_here, task, delay); |
+ } |
+ |
+ private: |
+ class WorkerThread : public base::SimpleThread { |
+ public: |
+ WorkerThread(const base::Closure& task, scoped_refptr<TaskRunnerImpl> owner) |
+ : base::SimpleThread("TaskRunnerImpl"), task_(task), owner_(owner) {} |
+ |
+ private: |
+ // base::SimpleThread override. |
+ void Run() override { |
+ base::ScopedSetSequenceTokenForCurrentThread scoped_token(owner_->token_); |
+ base::SequencedTaskRunnerHandle handle(owner_); |
+ task_.Run(); |
+ owner_->main_runner_->PostTask( |
+ FROM_HERE, base::Bind(&TaskRunnerImpl::TaskDone, owner_)); |
+ } |
+ |
+ base::Closure task_; |
+ scoped_refptr<TaskRunnerImpl> owner_; |
+ }; |
+ |
+ ~TaskRunnerImpl() override { |
+ DCHECK(sequence_checker_.CalledOnValidSequence()); |
+ DCHECK(shut_down_); |
+ DCHECK(!worker_thread_); |
+ } |
+ |
+ void PostTaskOnMainRunner(const base::Closure& task) { |
+ DCHECK(sequence_checker_.CalledOnValidSequence()); |
+ if (shut_down_) |
+ return; |
+ |
+ task_queue_.push_back(task); |
+ |
+ if (!worker_thread_) |
+ StartWorker(); |
+ } |
+ |
+ void TaskDone() { |
+ DCHECK(sequence_checker_.CalledOnValidSequence()); |
+ if (shut_down_) |
+ return; |
+ |
+ worker_thread_->Join(); |
+ worker_thread_.reset(); |
+ if (task_queue_.empty()) |
+ return; |
+ |
+ StartWorker(); |
+ } |
+ |
+ void StartWorker() { |
+ DCHECK(sequence_checker_.CalledOnValidSequence()); |
+ DCHECK(!worker_thread_); |
+ |
+ worker_thread_ = base::MakeUnique<WorkerThread>(task_queue_.front(), this); |
+ task_queue_.pop_front(); |
+ worker_thread_->Start(); |
+ } |
+ |
+ std::deque<base::Closure> task_queue_; |
+ |
+ base::SequenceChecker sequence_checker_; |
+ const scoped_refptr<base::SequencedTaskRunner> main_runner_; |
+ const base::SequenceToken token_; |
+ std::unique_ptr<base::SimpleThread> worker_thread_; |
+ bool shut_down_ = false; |
+}; |
+ |
+ThreadPerTaskSequencedTaskRunnerOwner::ThreadPerTaskSequencedTaskRunnerOwner() |
+ : task_runner_(new TaskRunnerImpl) {} |
+ |
+ThreadPerTaskSequencedTaskRunnerOwner:: |
+ ~ThreadPerTaskSequencedTaskRunnerOwner() { |
+ task_runner_->ShutDown(); |
+ EXPECT_TRUE(task_runner_->HasOneRef()); |
+} |
+ |
+scoped_refptr<base::SequencedTaskRunner> |
+ThreadPerTaskSequencedTaskRunnerOwner::GetSequencedTaskRunner() { |
+ return task_runner_; |
+} |
+ |
+} // namespace test |
+} // namespace mojo |