Issue #4692 - Move responsibility for engine reference from tasks to scheduler

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"
 
 class PersistentValueArray
   : public AllocatedArray<V8PersistentNG<v8::Value>>
 {
   typedef AllocatedArray<V8PersistentNG<v8::Value>> Base;
   /**
    * Copy constructor deleted. Allocation is unique to single object.
    */
   PersistentValueArray(const PersistentValueArray&); // = delete;
@@ skipping 34 matching lines @@
     const auto length = Base::Size();
     AllocatedArray<v8::Local<v8::Value>> locals(length);
     for (size_t i = 0; i < length; ++i)
     {
       locals[i] = (*this)[i].Get(isolate);
     }
     return std::move(locals);
   }
 };
 
+struct ImmediateSingleUseThreadType {}; ///< Marker class for scheduling policy
+extern const ImmediateSingleUseThreadType ImmediateSingleUseThread; ///< Dummy constant for scheduling policy
+
 /**
  * \par Implementation Notes
  */
 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;
+
+  /**
+   * 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
+   *   The schedule policy--create a new thread and discard it afterwards.
+   */
+  void ScheduleTaskInternal(std::shared_ptr<TaskFunctionInterface>&& body);
+
 public:
   JsEngineInternal(const AdblockPlus::ScopedV8IsolatePtr& isolate);
 
   /**
    * Retrieve our persistent v8 context as a local handle.
    */
   v8::Local<v8::Context> GetContextAsLocal() const;
 
   /**
    * Retrieve the global object of our context.
    */
   v8::Local<v8::Object> GetGlobalObject();
 
   /**
+   * 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(T&& task, ImmediateSingleUseThreadType)
+  {
+    ScheduleTaskInternal(std::static_pointer_cast<TaskFunctionInterface>(std::make_shared<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();
+
+  /**
    * Create a JavaScript function that binds to a C++ callback.
    *
    * We save a copy of a pointer to the present instance when we
    *   create the JS function inside the v8 isolate.
    * This pointer is accessible through the `v8::Arguments` class,
    *   which is the argument of the callback function.
    * The isolate pointer is already available;
    *   the engine pointer is available if its services are needed.
    *
    * @param callback C++ callback to invoke.
@@ skipping 69 matching lines @@
    */
   const v8::HandleScope handleScope;
   const v8::Context::Scope contextScope;
 public:
   V8ExecutionScope(JsEngineInternal* engine);
 };
 
 
 
 #endif