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

src/Scheduler.h

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 #if !defined(ADBLOCKPLUS_SCHEDULER_H)
 #define ADBLOCKPLUS_SCHEDULER_H
 
 #include <condition_variable>
 #include <list>
 #include <memory>
 #include <mutex>
 #include <functional>
 #include <queue>
 #include <thread>
 
-namespace AdblockPlus
-{
-  /*
-   * Adapter class for heap allocated function objects
-   *
-   * The legacy behavior of the original threading regime combined task life
-   * cycle and execution. Previously, tasks were allocated by the user and 
-   * deleted at the end of execution internally. This adapter class allows
-   * separation of these concerns. It allows the legacy allocation behavior 
-   * without burdening the new scheduler with any concern over task life cycle.
-   */
-  template<class T>
-  class HeapFunction
-  {
-    std::shared_ptr<T> body;
-
-  public:
-    HeapFunction(std::shared_ptr<T> body)
-      :body(body)
-    {}
-
-    void operator()()
-    {
-      if (body)
-      {
-        body->operator()();
-      }
-    }
-  };
-
-  /*
-   * Utility function uses type inference to simplify expressions at point of use.
-   */
-  template<class T>
-  HeapFunction<T> MakeHeapFunction(std::shared_ptr<T> body)
-  {
-    return HeapFunction<T>(body);
-  }
-}
-
 /**
  * Interface class for scheduled tasks.
  */
 struct TaskFunctionInterface
 {
   /** 
    * The main function of the task,
    *   the moral equivalent to the main function of the thread.
    */
   virtual void operator()() = 0;
   /**
    * Request that the task end itself early, without needing to complete.
    * Reserved for future use.
    */
   virtual void Interrupt() {};
 };
 
 /**
- * Execute a task immediately in detached thread that's used only for this task.
- *
- * The present version is nothing more than a rewrite of the legacy behavior,
- *   which was to create a new thread for each task.
- */
-void StartImmediatelyInSingleUseDetachedThread(std::function<void()> task);
-
-/**
  * Active object to run arbitrary function objects.
  *
  * Operations execute in a thread owned by this instance.
  * If a user wants to execute an operation in a different thread,
  *   they have the responsibility to set up whatever additional
  *   facilities may be required.
  */
 class OperationRunner
 {
   /**
@@ skipping 84 matching lines @@
  *
  * The present version has some limitations and inefficiencies,
  *   trading them off for ease of incremental implementation.
  *   - Separate schedulers for each `JsEngine` without any shared facilities.
  *   - Working threads are single-use. No provision for a thread pool.
  *   - Tasks are simple function objects. Its possible to hasten termination
  *       in v8 by calling `TerminateExecution()`, for example,
  *       but there's no interface for this.
  *   - No support for delayed execution to support JavaScript `SetTimeout`.
  */
-template<class Worker>
+template<class Worker, class UserData>
 class SchedulerT
 {
   /**
+   * A task as scheduled for execution.
+   *
+   * This class is a combination of two kinds of data:
+   * 1. An external object containing the body of the task.
+   * 2. All the internal elements required to run the task.
+   */
+  template<class UserData>
+  struct ScheduledTask
+  {
+    /**
+     * The external task.
+     * This member comes to us from our Run() method.
+     */
+    std::shared_ptr<TaskFunctionInterface> body;
+    /**
+     * The only internal data at present is the worker thread.
+     */
+    Worker worker;
+    /**
+     * Data associated with this task by the user of the scheduler
+     */
+    std::shared_ptr<UserData> userData;
+    /**
+     * Member worker is default-constructed
+     *   because VS2012 insists on copy constructors when it doesn't need them.
+     */
+    ScheduledTask(std::shared_ptr<TaskFunctionInterface>&& body, std::shared_ptr<UserData>&& ud)
+      : body(std::forward<std::shared_ptr<TaskFunctionInterface>>(body)),
+      userData(std::forward<std::shared_ptr<UserData>>(ud))
+    {}
+  };
+
+  /**
    * Shared mutex for all synchronization
    */
   std::mutex m;
   typedef std::unique_lock<std::mutex> UniqueLockType;
 
+  typedef std::list<ScheduledTask<UserData>> TaskListType;
   /**
    * A list containing an entry for each running task.
    */
-  std::list<Worker> taskList;
+  TaskListType taskList;
 
   /**
    * Condition variable notified when a running task is removed from its list
    */
   std::condition_variable taskRemoveCv;
 
   /**
    * Maintains a separate thread that is able to join completed worker threads.
    */
   OperationRunner monitor;
 
   /**
+   * State flag.
+   *
+   * We only have two states: normal and terminating.
+   */
+  bool isNormal;
+
+  /**
    * Execution wrapper for a task.
    * @param task
    *   An iterator to the task within the task list.
    */
-  void WorkerMain(std::function<void()> body, typename std::list<Worker>::iterator task)
+  void WorkerMain(typename TaskListType::iterator task)
   {
-    body();
+    (*task->body)();
     monitor.Run([this, task]() { JoinAndRemove(task); });
   }
 
   /**
    * Joins a task and then removes it from the task list.
    * @param task
    *   An iterator to the task within the task list.
    *
    * This is the only function that may remove tasks from the running task list.
    */
-  void JoinAndRemove(typename std::list<Worker>::iterator task)
+  void JoinAndRemove(typename TaskListType::iterator task)
   {
-    task->Join();
+    task->worker.Join();
     {
       UniqueLockType ul(m);
       taskList.erase(task);
     }
     taskRemoveCv.notify_all();
   }
 
 public:
   SchedulerT()
+    : isNormal(true)
   {}
 
   ~SchedulerT()
   {
     // `JoinAll()` may be called prior to destruction but, however,
     //   there is no requirement that it be called beforehand.
     // We call it in the destructor to ensure all tasks have completed.
     // If we do not, we risk destruction of a joinable thread,
     //   which would generate a call to `std::terminate()`.
+    ShutDown();
     JoinAll();
   }
 
   /**
+   * Interrupt all pending tasks so that they'll terminate soon.
+   * Execution may proceed after a call to Interrupt(),
+   *   but it does indicate that a task should terminate as soon as it can.
+   */
+  void ShutDown()
+  {
+    UniqueLockType ul(m);
+    // Ensure the task list does not grow during shutdown.
+    isNormal = false;
+
+    for (auto& it : taskList)
+    {
+      it.body->Interrupt();
+    }
+  }
+
+  /**
    * Construct a `Worker` and run a task in it immediately.
    *
    * This is the only function that may add tasks to the running task list.
    */
-  void Run(std::function<void()> body)
+  void Run(std::shared_ptr<TaskFunctionInterface>&& body, std::shared_ptr<UserData>&& ud)
   {
     UniqueLockType ul(m);
+    if (!isNormal)
+    {
+      // We don't run new tasks if we're in a terminating state
+      return;
+    }
     // Note that the interface to `Worker` uses a constructor and not a factory
     // Here we construct in place, avoiding both move and copy.
-    auto tt = taskList.emplace(taskList.begin());
-    tt->Run([this, body, tt]() { WorkerMain(body, tt); });
+    auto tt = taskList.emplace(taskList.begin(),
+      std::forward<std::shared_ptr<TaskFunctionInterface>>(body),
+      std::forward<std::shared_ptr<UserData>>(ud));
+    tt->worker.Run([this, tt]() { WorkerMain(tt); });
   }
 
   /**
    * Block until all running threads have been joined and the task list is empty.
    *
    * This class does not take on any responsibility to keep the task list
    *   from growing while this function executes.
    * Improper use can result in this function blocking forever; don't do that.
    */
   void JoinAll()
   {
     // The call to `Worker::Join()` is in another function,
     //   namely `JoinAndRemove()`, which also removes items from the task list.
     // Thus all we do here is to wait for the task list to empty.
     UniqueLockType ul(m);
     taskRemoveCv.wait(ul, [this]() -> bool { return taskList.empty(); });
   }
 };
 
 #endif