Change single-interface mojo bindings to use SequencedTaskRunner.

mojo/public/cpp/bindings/tests/thread_per_task_sequenced_task_runner.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 "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