Worker: Introduce per-global-scope task scheduler

third_party/WebKit/Source/core/dom/TaskRunnerHelper.cpp

 // Copyright 2016 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 "core/dom/TaskRunnerHelper.h"
 
 #include "core/dom/Document.h"
 #include "core/frame/LocalFrame.h"
+#include "core/workers/WorkerOrWorkletGlobalScope.h"
+#include "core/workers/WorkerThread.h"
 #include "platform/WebFrameScheduler.h"
 #include "platform/WebTaskRunner.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebThread.h"
 
 namespace blink {
 
 RefPtr<WebTaskRunner> TaskRunnerHelper::get(TaskType type, LocalFrame* frame) {
   // TODO(haraken): Optimize the mapping from TaskTypes to task runners.
   switch (type) {
@@ skipping 36 matching lines @@
   return nullptr;
 }
 
 RefPtr<WebTaskRunner> TaskRunnerHelper::get(TaskType type, Document* document) {
   return get(type, document ? document->frame() : nullptr);
 }
 
 RefPtr<WebTaskRunner> TaskRunnerHelper::get(
     TaskType type,
     ExecutionContext* executionContext) {
-  return get(type, executionContext && executionContext->isDocument()
-                       ? static_cast<Document*>(executionContext)
-                       : nullptr);
+  if (!executionContext)
+    return get(type, static_cast<Document*>(nullptr));

[kinuko, 2017/04/10 06:30:06]

You can/should use ToDocument instead.

[nhiroki, 2017/04/11 10:47:54]

Done.

+  if (executionContext->isDocument())
+    return get(type, static_cast<Document*>(executionContext));
+  if (executionContext->isWorkerOrWorkletGlobalScope()) {
+    return get(
+        type,
+        static_cast<WorkerOrWorkletGlobalScope*>(executionContext)->thread());
+  }
+  return get(type, static_cast<Document*>(nullptr));
 }
 
 RefPtr<WebTaskRunner> TaskRunnerHelper::get(TaskType type,
                                             ScriptState* scriptState) {
   return get(type, scriptState ? scriptState->getExecutionContext() : nullptr);
 }
 
+RefPtr<WebTaskRunner> TaskRunnerHelper::get(TaskType type,
+                                            WorkerThread* workerThread) {

[kinuko, 2017/04/10 06:30:06]

Could this just take WorkerOrWorkletGlobalScope instead (and hide the naming
gotcha around WorkerThread, which feels really non-intuitive here)?

Hm, but you probably want to limit access to GlobalScope / ExecutionContext from
other threads too.

[nhiroki, 2017/04/11 10:47:54]

We could do the same thing as ParentFrameTaskRunners, that is, capture a set of
task runners in WorkerThread::initializeSchedulerOnWorkerThread and make foreign
threads use the set instead of TaskRunnerHelper.

The patchset-3 introduces WorkerTaskRunners for that. What do you think about
this?

[kinuko, 2017/04/12 09:47:44]

Sorry my comment was probably unclear, what I felt weird was the fact that we're
retrieving per-global-scope thing from something that is named WorkerThread, so
introducing WorkerTaskRunners doesn't seem very helpful here / given that you
have future plan having some TODO comment might be enough.

(I think commonly using TaskRunnerHelper itself makes sense, though cross-thread
usage might need some extra care)

+  switch (type) {
+    case TaskType::Timer:
+    case TaskType::UnspecedLoading:
+    case TaskType::Networking:
+    case TaskType::DatabaseAccess:
+    case TaskType::DOMManipulation:
+    case TaskType::UserInteraction:
+    case TaskType::HistoryTraversal:
+    case TaskType::Embed:
+    case TaskType::MediaElementEvent:
+    case TaskType::CanvasBlobSerialization:
+    case TaskType::RemoteEvent:
+    case TaskType::WebSocket:
+    case TaskType::Microtask:
+    case TaskType::PostedMessage:
+    case TaskType::UnshippedPortMessage:
+    case TaskType::FileReading:
+    case TaskType::Presentation:
+    case TaskType::Sensor:
+    case TaskType::PerformanceTimeline:
+    case TaskType::WebGL:
+    case TaskType::UnspecedTimer:
+    case TaskType::MiscPlatformAPI:
+    case TaskType::Unthrottled:
+      return workerThread->globalScopeScheduler()->unthrottledTaskRunner();

[kinuko, 2017/04/10 06:30:06]

Would be nice to have some comments as 'unthrottled' thing should be generally
discouraged in future?

[Sami, 2017/04/10 16:58:10]

+1

+  }
+  NOTREACHED();
+  return nullptr;
+}
+
 }  // namespace blink