[scheduler] Register WorkerSchedulers with thread scheduler.

Register WorkerSchedulers with NonMainThreadScheduler similar to how
PageSchedulers are registered with MainThreadScheduler.

R=alexclarke@chromium.org
BUG=776416

Change-Id: I824cccfaafb4cea701807f60e3f0b70014e1b423
Reviewed-on: https://chromium-review.googlesource.com/1061461Reviewed-by: Alex Clarke <alexclarke@chromium.org>
Commit-Queue: Alexander Timin <altimin@chromium.org>
Cr-Commit-Position: refs/heads/master@{#559121}

third_party/blink/renderer/platform/scheduler/child/worker_scheduler.cc

@@ -11,7 +11,9 @@ namespace blink {
 namespace scheduler {
 
 WorkerScheduler::WorkerScheduler(
-    NonMainThreadScheduler* non_main_thread_scheduler) {
+    NonMainThreadScheduler* non_main_thread_scheduler)
+    : thread_scheduler_(non_main_thread_scheduler) {
+  non_main_thread_scheduler->RegisterWorkerScheduler(this);
   task_queue_ = non_main_thread_scheduler->CreateTaskRunner();
 }
 
@@ -27,6 +29,7 @@ WorkerScheduler::OnActiveConnectionCreated() {
 }
 
 void WorkerScheduler::Dispose() {
+  thread_scheduler_->UnregisterWorkerScheduler(this);
   task_queue_->ShutdownTaskQueue();
 #if DCHECK_IS_ON()
   is_disposed_ = true;

third_party/blink/renderer/platform/scheduler/child/worker_scheduler.h

@@ -42,6 +42,8 @@ class PLATFORM_EXPORT WorkerScheduler : public FrameOrWorkerScheduler {
  private:
   scoped_refptr<base::sequence_manager::TaskQueue> task_queue_;
 
+  NonMainThreadScheduler* thread_scheduler_;  // NOT OWNED
+
 #if DCHECK_IS_ON()
   bool is_disposed_ = false;
 #endif

third_party/blink/renderer/platform/scheduler/child/worker_scheduler_unittest.cc

@@ -26,11 +26,24 @@ void AppendToVectorTestTask(std::vector<std::string>* vector,
   vector->push_back(value);
 }
 
+class WorkerThreadSchedulerForTest : public WorkerThreadScheduler {
+ public:
+  WorkerThreadSchedulerForTest(
+      WebThreadType thread_type,
+      std::unique_ptr<base::sequence_manager::TaskQueueManager> manager,
+      WorkerSchedulerProxy* proxy)
+      : WorkerThreadScheduler(thread_type, std::move(manager), proxy) {}
+
+  const std::unordered_set<WorkerScheduler*>& worker_schedulers() {
+    return worker_schedulers_;
+  }
+};
+
 class WorkerSchedulerTest : public testing::Test {
  public:
   WorkerSchedulerTest()
       : mock_task_runner_(new base::TestSimpleTaskRunner()),
-        scheduler_(new WorkerThreadScheduler(
+        scheduler_(new WorkerThreadSchedulerForTest(
             WebThreadType::kTestThread,
             base::sequence_manager::TaskQueueManagerForTest::Create(
                 nullptr,
@@ -62,7 +75,7 @@ class WorkerSchedulerTest : public testing::Test {
   base::SimpleTestTickClock clock_;
   scoped_refptr<base::TestSimpleTaskRunner> mock_task_runner_;
 
-  std::unique_ptr<WorkerThreadScheduler> scheduler_;
+  std::unique_ptr<WorkerThreadSchedulerForTest> scheduler_;
   std::unique_ptr<WorkerScheduler> worker_scheduler_;
 
   DISALLOW_COPY_AND_ASSIGN(WorkerSchedulerTest);
@@ -86,6 +99,27 @@ TEST_F(WorkerSchedulerTest, TestPostTasks) {
   EXPECT_TRUE(run_order.empty());
 }
 
+TEST_F(WorkerSchedulerTest, RegisterWorkerSchedulers) {
+  EXPECT_THAT(scheduler_->worker_schedulers(),
+              testing::ElementsAre(worker_scheduler_.get()));
+
+  std::unique_ptr<WorkerScheduler> worker_scheduler2 =
+      std::make_unique<WorkerScheduler>(scheduler_.get());
+
+  EXPECT_THAT(scheduler_->worker_schedulers(),
+              testing::UnorderedElementsAre(worker_scheduler_.get(),
+                                            worker_scheduler2.get()));
+
+  worker_scheduler_->Dispose();
+
+  EXPECT_THAT(scheduler_->worker_schedulers(),
+              testing::ElementsAre(worker_scheduler2.get()));
+
+  worker_scheduler2->Dispose();
+
+  EXPECT_THAT(scheduler_->worker_schedulers(), testing::ElementsAre());
+}
+
 }  // namespace worker_scheduler_unittest
 }  // namespace scheduler
 }  // namespace blink

third_party/blink/renderer/platform/scheduler/public/non_main_thread_scheduler.h

@@ -21,6 +21,7 @@ namespace blink {
 namespace scheduler {
 class TaskQueueWithTaskType;
 class WorkerSchedulerProxy;
+class WorkerScheduler;
 
 // TODO(yutak): Remove the dependency to WebThreadScheduler. We want to
 // separate interfaces to Chromium (in blink/public/platform/scheduler) from
@@ -89,7 +90,17 @@ class PLATFORM_EXPORT NonMainThreadScheduler : public WebThreadScheduler,
 
   std::unique_ptr<NonMainThreadSchedulerHelper> helper_;
 
+  // Worker schedulers associated with this thread.
+  std::unordered_set<WorkerScheduler*> worker_schedulers_;
+
  private:
+  friend class WorkerScheduler;
+
+  // Each WorkerScheduler should notify NonMainThreadScheduler when it is
+  // created or destroyed.
+  void RegisterWorkerScheduler(WorkerScheduler* worker_scheduler);
+  void UnregisterWorkerScheduler(WorkerScheduler* worker_scheduler);
+
   static void RunIdleTask(WebThread::IdleTask task, base::TimeTicks deadline);
   scoped_refptr<TaskQueueWithTaskType> v8_task_runner_;
 

third_party/blink/renderer/platform/scheduler/worker/non_main_thread_scheduler.cc

@@ -16,7 +16,9 @@ NonMainThreadScheduler::NonMainThreadScheduler(
     std::unique_ptr<NonMainThreadSchedulerHelper> helper)
     : helper_(std::move(helper)) {}
 
-NonMainThreadScheduler::~NonMainThreadScheduler() = default;
+NonMainThreadScheduler::~NonMainThreadScheduler() {
+  DCHECK(worker_schedulers_.empty());
+}
 
 // static
 std::unique_ptr<NonMainThreadScheduler> NonMainThreadScheduler::Create(
@@ -91,5 +93,16 @@ base::TimeTicks NonMainThreadScheduler::MonotonicallyIncreasingVirtualTime()
   return base::TimeTicks::Now();
 }
 
+void NonMainThreadScheduler::RegisterWorkerScheduler(
+    WorkerScheduler* worker_scheduler) {
+  worker_schedulers_.insert(worker_scheduler);
+}
+
+void NonMainThreadScheduler::UnregisterWorkerScheduler(
+    WorkerScheduler* worker_scheduler) {
+  DCHECK(worker_schedulers_.find(worker_scheduler) != worker_schedulers_.end());
+  worker_schedulers_.erase(worker_scheduler);
+}
+
 }  // namespace scheduler
 }  // namespace blink