v8: add a way for a thread to call a callback

The callback will be called as soon as possible from the main thread.

Author: ogoffart

src/3rdparty/v8/include/v8.h

@@ -2484,6 +2484,8 @@ typedef void* (*CreateHistogramCallback)(const char* name,
 
 typedef void (*AddHistogramSampleCallback)(void* histogram, int sample);
 
+typedef void (*UserCallback)(void *data);
+
 // --- M e m o r y  A l l o c a t i o n   C a l l b a c k ---
   enum ObjectSpace {
     kObjectSpaceNewSpace = 1 << 0,
@@ -3059,6 +3061,15 @@ class V8EXPORT V8 {
    */
   static int ContextDisposedNotification();
 
+#ifdef QT_BUILD_SCRIPT_LIB
+  /**
+   * Will call the callback with the data as parameter as soon as possible
+   * from the thread running the script
+   * This method can be used by any thread even if that thread has not
+   * acquired the V8 lock with a Locker object.
+   */
+  static void ExecuteUserCallback(UserCallback Callback, void *data);
+#endif
  private:
   V8();
 

src/3rdparty/v8/src/api.cc

@@ -4877,6 +4877,13 @@ void V8::TerminateExecution(int thread_id) {
   }
 }
 
+#ifdef QT_BUILD_SCRIPT_LIB
+void V8::ExecuteUserCallback(UserCallback callback, void *data) {
+    i::Isolate* isolate = i::Isolate::Current();
+    if (IsDeadCheck(isolate, "v8::ExecuteUserCallback()")) return;
+    isolate->stack_guard()->ExecuteUserCallback(callback, data);
+}
+#endif
 
 void V8::TerminateExecution(Isolate* isolate) {
   // If no isolate is supplied, use the default isolate.

src/3rdparty/v8/src/execution.cc

@@ -321,13 +321,45 @@ bool StackGuard::IsTerminateExecution() {
   return thread_local_.interrupt_flags_ & TERMINATE;
 }
 
+#ifdef QT_BUILD_SCRIPT_LIB
+bool StackGuard::IsUserCallback()
+{
+    ExecutionAccess access(isolate_);
+    return thread_local_.interrupt_flags_ & USERCALLBACK;
+}
+
+void StackGuard::RunUserCallbackNow()
+{
+    UserCallback cb;
+    void *data;
+    {
+        ExecutionAccess access(isolate_);
+        cb = thread_local_.user_callback_;
+        data = thread_local_.user_data_;
+    }
+    if (cb)
+        cb(data);
+}
+#endif
 
 void StackGuard::TerminateExecution() {
   ExecutionAccess access(isolate_);
   thread_local_.interrupt_flags_ |= TERMINATE;
   set_interrupt_limits(access);
 }
 
+#ifdef QT_BUILD_SCRIPT_LIB
+void StackGuard::ExecuteUserCallback(UserCallback callback, void *data)
+{
+    ExecutionAccess access(isolate_);
+    thread_local_.user_callback_ = callback;
+    thread_local_.user_data_ = data;
+    thread_local_.interrupt_flags_ |= USERCALLBACK;
+    set_interrupt_limits(access);
+}
+#endif
+
+
 
 bool StackGuard::IsRuntimeProfilerTick() {
   ExecutionAccess access(isolate_);
@@ -425,6 +457,10 @@ void StackGuard::ThreadLocal::Clear() {
   nesting_ = 0;
   postpone_interrupts_nesting_ = 0;
   interrupt_flags_ = 0;
+#ifdef QT_BUILD_SCRIPT_LIB
+  user_callback_ = 0;
+  user_data_ = 0;
+#endif
 }
 
 
@@ -775,6 +811,14 @@ MaybeObject* Execution::HandleStackGuardInterrupt() {
   if (stack_guard->IsDebugBreak() || stack_guard->IsDebugCommand()) {
     DebugBreakHelper();
   }
+#endif
+#ifdef QT_BUILD_SCRIPT_LIB
+  if (stack_guard->IsUserCallback()) {
+    stack_guard->Continue(USERCALLBACK);
+    stack_guard->RunUserCallbackNow();
+    if (isolate->has_scheduled_exception() && !stack_guard->IsTerminateExecution())
+        return isolate->PromoteScheduledException();
+  }
 #endif
   if (stack_guard->IsPreempted()) RuntimePreempt();
   if (stack_guard->IsTerminateExecution()) {

src/3rdparty/v8/src/execution.h

@@ -40,6 +40,9 @@ enum InterruptFlag {
   PREEMPT = 1 << 3,
   TERMINATE = 1 << 4,
   RUNTIME_PROFILER_TICK = 1 << 5
+#ifdef QT_BUILD_SCRIPT_LIB
+  , USERCALLBACK = 1 << 6
+#endif
 };
 
 class Execution : public AllStatic {
@@ -179,6 +182,11 @@ class StackGuard {
   void TerminateExecution();
   bool IsRuntimeProfilerTick();
   void RequestRuntimeProfilerTick();
+#ifdef QT_BUILD_SCRIPT_LIB
+  bool IsUserCallback();
+  void ExecuteUserCallback(UserCallback callback, void *data);
+  void RunUserCallbackNow();
+#endif
 #ifdef ENABLE_DEBUGGER_SUPPORT
   bool IsDebugBreak();
   void DebugBreak();
@@ -271,6 +279,10 @@ class StackGuard {
     int nesting_;
     int postpone_interrupts_nesting_;
     int interrupt_flags_;
+#ifdef QT_BUILD_SCRIPT_LIB
+    UserCallback user_callback_;
+    void *user_data_;
+#endif
   };
 
   // TODO(isolates): Technically this could be calculated directly from a