Issue #4692, #3595 - Stop sleeping in the implementation of `SetTimeout`

src/JsEngineInternal.h

 
 #if !defined(ADBLOCK_PLUS_JS_ENGINE_INTERNAL_H)
 #define ADBLOCK_PLUS_JS_ENGINE_INTERNAL_H
 
 #include <AdblockPlus/JsEngine.h>
 #include <v8.h>
 #include <array>
 #include "AllocatedArray.h"
 #include "Scheduler.h"
 #include "V8Upgrade.h"
@@ skipping 58 matching lines @@
  */
 class JsEngineInternal
   : public AdblockPlus::JsEngine
 {
   /**
    * Unique context associated with this isolate.
    */
   v8::Persistent<v8::Context> context;
 
   /**
-   * A task within our scheduler.
-   *
-   * TODO: Move this class into the scheduler proper.
-   */
-  class Task
-  {
-    /**
-     * Shared pointer to our engine keeps it in existence
-     *   for the duration of the execution of this task.
-     */
-    AdblockPlus::JsEnginePtr engine;
-    /**
-     * The body of the task, containing its main function.
-     * This is the class where tasks are heap-allocated for polymorphism.
-     */
-    std::shared_ptr<TaskFunctionInterface> body;
-
-  public:
-    /**
-     * Constructor makes a new shared pointer to the engine
-     *   but copies the task body.
-     */
-    Task(JsEngineInternal* engine, std::shared_ptr<TaskFunctionInterface>&& body)
-      : engine(engine->shared_from_this()), body(body)
-    {}
-
-    /*
-     * Call operator allows conversion to std::function<void()> so that
-     *   we don't have to change the scheduler just yet.
-     */
-    void operator()()
-    {
-      if (body)
-      {
-        body->operator()();
-      }
-    }
-  };
-
-  /**
    * Scheduler for tasks executed under the current engine.
    */
-  SchedulerT<SingleUseWorker> scheduler;
+  SchedulerT<SingleUseWorker, JsEngine> scheduler;
 
   /**
    * Schedule a task, internal version.
    *
    * This version relies upon the external version of this function
    *   to allocate a shared pointer to the task.
    *
    * @param task
    *   Task to execute. All v8 handles must refer to the present engine.
    * @param ImmediateSingleUseThreadType
@@ skipping 20 matching lines @@
    * - threading policy: run the task in a single-use thread.
    *
    * @param task
    *   Task to execute. All v8 handles must refer to the present engine.
    * @param ImmediateSingleUseThreadType
    *   The schedule policy--create a new thread and discard it afterwards.
    */
   template<class T>
   void ScheduleTask(T&& task, ImmediateSingleUseThreadType)
   {
-    ScheduleTaskInternal(std::static_pointer_cast<TaskFunctionInterface>(std::make_shared<T>(task)));
+    ScheduleTaskInternal(std::static_pointer_cast<TaskFunctionInterface>(std::make_shared<T>(std::forward<T>(task))));
+  }
+
+  /*
+   * Note: This version shouldn't be necessary; it's a workaround for a defect in Visual Studio.
+   * The problem is that make_shared insists on using a copy constructor even when a move constructor is available.
+   * Tested in both toolset 12.0 (VS 2012) and 14.1 (VS 2017).
+   * The workaround, used here, is to call make_shared in the caller.
+   */
+  /**
+   * Schedule a task with these policies:
+   * - timing policy: start execution immediately.
+   * - threading policy: run the task in a single-use thread.
+   *
+   * @param task
+   *   Task to execute. All v8 handles must refer to the present engine.
+   * @param ImmediateSingleUseThreadType
+   *   The schedule policy--create a new thread and discard it afterwards.
+   */
+  template<class T>
+  void ScheduleTask(std::shared_ptr<T>&& task, ImmediateSingleUseThreadType)
+  {
+    ScheduleTaskInternal(std::static_pointer_cast<TaskFunctionInterface>(std::forward<std::shared_ptr<T>>(task)));
   }
 
   /**
    * Block until there are no more tasks running in the scheduler.
    *
    * Note: this function does not prevent new tasks from being scheduled.
    */
   void WaitForQuietScheduler();
 
   /**
@@ skipping 79 matching lines @@
    */
   const v8::HandleScope handleScope;
   const v8::Context::Scope contextScope;
 public:
   V8ExecutionScope(JsEngineInternal* engine);
 };
 
 
 
 #endif