(WIP) Worker: Merge ParentFrameTaskRunners into TaskRunnerHelper

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

 // 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.
 
 #ifndef TaskRunnerHelper_h
 #define TaskRunnerHelper_h
 
+#include <memory>
 #include "core/CoreExport.h"
+#include "core/dom/ContextLifecycleObserver.h"
+#include "platform/WebTaskRunner.h"
+#include "platform/heap/Handle.h"
 #include "wtf/Allocator.h"
 #include "wtf/HashTraits.h"
+#include "wtf/PtrUtil.h"
 
 namespace blink {
 
 class Document;
 class ExecutionContext;
 class LocalFrame;
 class ScriptState;
-class WebTaskRunner;
+class WorkerOrWorkletGlobalScope;
+class WorkerThread;
 
 enum class TaskType : unsigned {
   // Speced tasks and related internal tasks should be posted to one of
   // the following task runners. These task runners may be throttled.
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#generic-task-sources
   //
   // This task source is used for features that react to DOM manipulations, such
   // as things that happen in a non-blocking fashion when an element is inserted
   // into the document.
@@ skipping 85 matching lines @@
   // may be throttled.
   //
   // UnspecedLoading type should be used for all tasks associated with
   // loading page content, UnspecedTimer should be used for all other purposes.
   UnspecedTimer,
   UnspecedLoading,
 
   // Tasks that must not be throttled should be posted here, but the usage
   // should be very limited.
   Unthrottled,
+
+  // Add a new type before this.
+  NumberOfTaskTypes,
 };
 
 // HashTraits for TaskType.
 struct TaskTypeTraits : WTF::GenericHashTraits<TaskType> {
   static const bool emptyValueIsZero = false;
   static TaskType emptyValue() { return static_cast<TaskType>(-1); }
   static void constructDeletedValue(TaskType& slot, bool) {
     slot = static_cast<TaskType>(-2);
   }
   static bool isDeletedValue(TaskType value) {
     return value == static_cast<TaskType>(-2);
   }
 };
 
+class CORE_EXPORT FrameTaskRunnersHolder final
+    : public GarbageCollectedFinalized<FrameTaskRunnersHolder>,
+      public ContextLifecycleObserver {
+  USING_GARBAGE_COLLECTED_MIXIN(FrameTaskRunnersHolder);
+  WTF_MAKE_NONCOPYABLE(FrameTaskRunnersHolder);
+
+ public:
+  static FrameTaskRunnersHolder* create(LocalFrame* frame) {
+    return new FrameTaskRunnersHolder(frame);
+  }
+
+  // Might return nullptr for unsupported task types.
+  RefPtr<WebTaskRunner> get(TaskType);
+
+  DECLARE_VIRTUAL_TRACE();
+
+ private:
+  using TaskRunnerHashMap = HashMap<TaskType,
+                                    RefPtr<WebTaskRunner>,
+                                    WTF::IntHash<TaskType>,
+                                    TaskTypeTraits>;
+
+  // LocalFrame could be nullptr if the worker is not associated with a
+  // particular local frame.
+  explicit FrameTaskRunnersHolder(LocalFrame*);
+
+  void contextDestroyed(ExecutionContext*) override;
+
+  Mutex m_taskRunnersMutex;
+  TaskRunnerHashMap m_taskRunners;
+};
+
 // A set of helper functions to get a WebTaskRunner for TaskType and a context
 // object. The posted tasks are guaranteed to run in a sequence if they have the
 // same TaskType and the context objects belong to the same frame.
-class CORE_EXPORT TaskRunnerHelper final {
-  STATIC_ONLY(TaskRunnerHelper);
+class CORE_EXPORT FrameTaskRunnerHelper {
+  STATIC_ONLY(FrameTaskRunnerHelper);
 
  public:
+  static void setTaskRunners(ExecutionContext*, FrameTaskRunnersHolder*);
+
+  // Used for posting a task from the main thread.
   static RefPtr<WebTaskRunner> get(TaskType, LocalFrame*);
   static RefPtr<WebTaskRunner> get(TaskType, Document*);
   static RefPtr<WebTaskRunner> get(TaskType, ExecutionContext*);
   static RefPtr<WebTaskRunner> get(TaskType, ScriptState*);
+
+  // Used for posting a task from a worker thread.
+  static RefPtr<WebTaskRunner> get(TaskType, WorkerThread*);
+  static RefPtr<WebTaskRunner> get(TaskType, WorkerOrWorkletGlobalScope*);
 };
 
+// TODO(nhiroki): Remove this workaround.
+using TaskRunnerHelper = FrameTaskRunnerHelper;
+
 }  // namespace blink
 
 #endif