deps: cherry-pick c690f54d95802 from V8 upstream

Original commit message:

    [platform] Add TaskRunner to the platform API

    With the existing platform API it is not possible to post foreground
    tasks from background tasks. This is, however, required to implement
    asynchronous compilation for WebAssembly. With this CL we add the
    concept of a TaskRunner to the platform API. The TaskRunner contains
    all data needed to post a foreground task and can be used both from a
    foreground task and a background task. Eventually the TaskRunner should
    replace the existing API.

    In addition, this CL contains a default implementation of the
    TaskRunner. This implementation has tempory workaround for platforms
    which do not provide a TaskRunner implementation yet. This default
    implementation should be deleted again when all platforms provide a
    TaskRunner implementation.

    R=rmcilroy@chromium.org

    Cq-Include-Trybots: master.tryserver.chromium.linux:linux_chromium_rel_ng
    Change-Id: I6ea4a1c9da1eb9a19e8ce8f2163000dbc2598802
    Reviewed-on: https://chromium-review.googlesource.com/741588
    Commit-Queue: Andreas Haas <ahaas@chromium.org>
    Reviewed-by: Ross McIlroy <rmcilroy@chromium.org>
    Cr-Commit-Position: refs/heads/master@{#49041}

Refs: v8/v8@c690f54

PR-URL: #17134
Fixes: nodejs/node-v8#24
Reviewed-By: Franziska Hinkelmann <franziska.hinkelmann@gmail.com>
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: James M Snell <jasnell@gmail.com>

deps/v8/include/v8-platform.h

@@ -36,6 +36,51 @@ class IdleTask {
   virtual void Run(double deadline_in_seconds) = 0;
 };
 
+/**
+ * A TaskRunner allows scheduling of tasks. The TaskRunner may still be used to
+ * post tasks after the isolate gets destructed, but these tasks may not get
+ * executed anymore. All tasks posted to a given TaskRunner will be invoked in
+ * sequence. Tasks can be posted from any thread.
+ */
+class TaskRunner {
+ public:
+  /**
+   * Schedules a task to be invoked by this TaskRunner. The TaskRunner
+   * implementation takes ownership of |task|.
+   */
+  virtual void PostTask(std::unique_ptr<Task> task) = 0;
+
+  /**
+   * Schedules a task to be invoked by this TaskRunner. The task is scheduled
+   * after the given number of seconds |delay_in_seconds|. The TaskRunner
+   * implementation takes ownership of |task|.
+   */
+  virtual void PostDelayedTask(std::unique_ptr<Task> task,
+                               double delay_in_seconds) = 0;
+
+  /**
+   * Schedules an idle task to be invoked by this TaskRunner. The task is
+   * scheduled when the embedder is idle. Requires that
+   * TaskRunner::SupportsIdleTasks(isolate) is true. Idle tasks may be reordered
+   * relative to other task types and may be starved for an arbitrarily long
+   * time if no idle time is available. The TaskRunner implementation takes
+   * ownership of |task|.
+   */
+  virtual void PostIdleTask(std::unique_ptr<IdleTask> task) = 0;
+
+  /**
+   * Returns true if idle tasks are enabled for this TaskRunner.
+   */
+  virtual bool IdleTasksEnabled() = 0;
+
+  TaskRunner() = default;
+  virtual ~TaskRunner() = default;
+
+ private:
+  TaskRunner(const TaskRunner&) = delete;
+  TaskRunner& operator=(const TaskRunner&) = delete;
+};
+
 /**
  * The interface represents complex arguments to trace events.
  */
@@ -150,6 +195,28 @@ class Platform {
    */
   virtual size_t NumberOfAvailableBackgroundThreads() { return 0; }
 
+  /**
+   * Returns a TaskRunner which can be used to post a task on the foreground.
+   * This function should only be called from a foreground thread.
+   */
+  virtual std::unique_ptr<v8::TaskRunner> GetForegroundTaskRunner(
+      Isolate* isolate) {
+    // TODO(ahaas): Make this function abstract after it got implemented on all
+    // platforms.
+    return {};
+  }
+
+  /**
+   * Returns a TaskRunner which can be used to post a task on a background.
+   * This function should only be called from a foreground thread.
+   */
+  virtual std::unique_ptr<v8::TaskRunner> GetBackgroundTaskRunner(
+      Isolate* isolate) {
+    // TODO(ahaas): Make this function abstract after it got implemented on all
+    // platforms.
+    return {};
+  }
+
   /**
    * Schedules a task to be invoked on a background thread. |expected_runtime|
    * indicates that the task will run a long time. The Platform implementation