AK: Allow deferring clear() for the Function class

Ideally a Function should not be clear()ed while it's running.
Unfortunately a number of callers do just that and identifying all of
them would require inspecting all call sites for operator() and clear().

Instead this adds support for deferring clear() until after the
function has finished executing.

1 files changed, 12 insertions, 3 deletions

diff --git a/AK/Function.h b/AK/Function.h
index 5e4f639966..85ee9de9b1 100644
--- a/AK/Function.h
+++ b/AK/Function.h
@@ -48,7 +48,7 @@ public:
 
     ~Function()
     {
-        clear();
+        clear(false);
     }
 
     template<typename CallableType, class = typename EnableIf<!(IsPointer<CallableType> && IsFunction<RemovePointer<CallableType>>)&&IsRvalueReference<CallableType&&>>::Type>
@@ -74,7 +74,8 @@ public:
         VERIFY(wrapper);
         ++m_call_nesting_level;
         ScopeGuard guard([this] {
-            --m_call_nesting_level;
+            if (--m_call_nesting_level == 0 && m_deferred_clear)
+                const_cast<Function*>(this)->clear(false);
         });
         return wrapper->call(forward<In>(in)...);
     }
@@ -181,8 +182,15 @@ private:
         }
     }
 
-    void clear()
+    void clear(bool may_defer = true)
     {
+        bool called_from_inside_function = m_call_nesting_level > 0;
+        VERIFY(may_defer || !called_from_inside_function);
+        if (called_from_inside_function && may_defer) {
+            m_deferred_clear = true;
+            return;
+        }
+        m_deferred_clear = false;
         auto* wrapper = callable_wrapper();
         if (m_kind == FunctionKind::Inline) {
             VERIFY(wrapper);
@@ -229,6 +237,7 @@ private:
     }
 
     FunctionKind m_kind { FunctionKind::NullPointer };
+    bool m_deferred_clear { false };
     mutable Atomic<u16> m_call_nesting_level { 0 };
     // Empirically determined to fit most lambdas and functions.
     static constexpr size_t inline_capacity = 4 * sizeof(void*);