add drainMicrotasks impl for draining from specific context

Source/JavaScriptCore/runtime/MicrotaskQueue.cpp

@@ -77,6 +77,20 @@ void MicrotaskQueue::enqueue(QueuedTask&& task)
     }
 }
 
+bool MarkedMicrotaskDeque::hasTasks(JSGlobalObject* globalObject) const
+{
+    for (const auto& task : m_queue) {
+        if (task.globalObject() == globalObject)
+            return true;
+    }
+    return false;
+}
+
+bool MicrotaskQueue::isEmpty(JSGlobalObject* globalObject) const
+{
+    return !m_queue.hasTasks(globalObject);
+}
+
 bool MarkedMicrotaskDeque::hasMicrotasksForFullyActiveDocument() const
 {
     for (auto& task : m_queue) {

Source/JavaScriptCore/runtime/MicrotaskQueue.h

@@ -154,6 +154,7 @@ class MarkedMicrotaskDeque {
         std::swap(m_markedBefore, other.m_markedBefore);
     }
 
+    JS_EXPORT_PRIVATE bool hasTasks(JSGlobalObject*) const;
     JS_EXPORT_PRIVATE bool hasMicrotasksForFullyActiveDocument() const;
 
     DECLARE_VISIT_AGGREGATE;
@@ -177,6 +178,8 @@ class MicrotaskQueue final : public BasicRawSentinelNode<MicrotaskQueue> {
         return m_queue.isEmpty();
     }
 
+    JS_EXPORT_PRIVATE bool isEmpty(JSGlobalObject*) const;
+
     size_t size() const { return m_queue.size(); }
 
     void clear()

Source/JavaScriptCore/runtime/VM.cpp

@@ -1373,6 +1373,35 @@ void VM::drainMicrotasks()
     finalizeSynchronousJSExecution();
 }
 
+void VM::drainMicrotasks(JSGlobalObject* globalObject)
+{
+    if (m_drainMicrotaskDelayScopeCount) [[unlikely]]
+        return;
+
+    if (executionForbidden()) [[unlikely]]
+        m_defaultMicrotaskQueue.clear();
+    else {
+        do {
+            m_defaultMicrotaskQueue.performMicrotaskCheckpoint(*this,
+                [&](QueuedTask& task) ALWAYS_INLINE_LAMBDA {
+                    if (task.globalObject() != globalObject)
+                        return QueuedTask::Result::Suspended;
+                    if (RefPtr dispatcher = task.dispatcher())
+                        return dispatcher->run(task);
+
+                    runJSMicrotask(task.globalObject(), task.identifier(), task.job(), task.arguments());
+                    return QueuedTask::Result::Executed;
+                });
+            if (hasPendingTerminationException()) [[unlikely]]
+                return;
+            didExhaustMicrotaskQueue();
+            if (hasPendingTerminationException()) [[unlikely]]
+                return;
+        } while (!m_defaultMicrotaskQueue.isEmpty(globalObject));
+    }
+    finalizeSynchronousJSExecution();
+}
+
 void sanitizeStackForVM(VM& vm)
 {
     auto& thread = Thread::currentSingleton();

Source/JavaScriptCore/runtime/VM.h

@@ -886,6 +886,7 @@ class VM : public ThreadSafeRefCountedWithSuppressingSaferCPPChecking<VM>, publi
 
     DrainMicrotaskDelayScope drainMicrotaskDelayScope() { return DrainMicrotaskDelayScope { *this }; }
     JS_EXPORT_PRIVATE void drainMicrotasks();
+    JS_EXPORT_PRIVATE void drainMicrotasks(JSGlobalObject*);
     void setOnEachMicrotaskTick(WTF::Function<void(VM&)>&& func) { m_onEachMicrotaskTick = WTFMove(func); }
     void callOnEachMicrotaskTick()
     {