#pragma once
#include "ContextDestructionObserver.h"
#include "TaskSource.h"
#include <wtf/Assertions.h>
#include <wtf/Forward.h>
#include <wtf/Function.h>
#include <wtf/RefCounted.h>
#include <wtf/Threading.h>
namespace WebCore {
class Document;
class Event;
class EventLoopTaskGroup;
class EventTarget;
enum class ReasonForSuspension {
JavaScriptDebuggerPaused,
WillDeferLoading,
BackForwardCache,
PageWillBeSuspended,
};
class WEBCORE_EXPORT ActiveDOMObject : public ContextDestructionObserver {
public:
void suspendIfNeeded();
void assertSuspendIfNeededWasCalled() const;
bool hasPendingActivity() const { return m_pendingActivityInstanceCount || virtualHasPendingActivity(); }
virtual const char* activeDOMObjectName() const = 0;
virtual void suspend(ReasonForSuspension);
virtual void resume();
virtual void stop();
template<typename T> void setPendingActivity(T& thisObject)
{
ASSERT(&thisObject == this);
thisObject.ref();
++m_pendingActivityInstanceCount;
}
template<typename T> void unsetPendingActivity(T& thisObject)
{
ASSERT(m_pendingActivityInstanceCount > 0);
--m_pendingActivityInstanceCount;
thisObject.deref();
}
template<class T>
class PendingActivity : public RefCounted<PendingActivity<T>> {
public:
explicit PendingActivity(T& thisObject)
: m_thisObject(thisObject)
{
++(m_thisObject->m_pendingActivityInstanceCount);
}
~PendingActivity()
{
ASSERT(m_thisObject->m_pendingActivityInstanceCount > 0);
--(m_thisObject->m_pendingActivityInstanceCount);
}
private:
Ref<T> m_thisObject;
};
template<class T> Ref<PendingActivity<T>> makePendingActivity(T& thisObject)
{
ASSERT(&thisObject == this);
return adoptRef(*new PendingActivity<T>(thisObject));
}
bool isContextStopped() const;
bool isAllowedToRunScript() const;
template<typename T>
static void queueTaskKeepingObjectAlive(T& object, TaskSource source, Function<void ()>&& task)
{
object.queueTaskInEventLoop(source, [protectedObject = makeRef(object), activity = object.ActiveDOMObject::makePendingActivity(object), task = WTFMove(task)] () {
task();
});
}
template<typename EventTargetType, typename EventType>
static void queueTaskToDispatchEvent(EventTargetType& target, TaskSource source, Ref<EventType>&& event)
{
target.queueTaskToDispatchEventInternal(target, source, WTFMove(event));
}
protected:
explicit ActiveDOMObject(ScriptExecutionContext*);
explicit ActiveDOMObject(Document*);
explicit ActiveDOMObject(Document&);
virtual ~ActiveDOMObject();
private:
enum CheckedScriptExecutionContextType { CheckedScriptExecutionContext };
ActiveDOMObject(ScriptExecutionContext*, CheckedScriptExecutionContextType);
virtual bool virtualHasPendingActivity() const { return false; }
void queueTaskInEventLoop(TaskSource, Function<void ()>&&);
void queueTaskToDispatchEventInternal(EventTarget&, TaskSource, Ref<Event>&&);
unsigned m_pendingActivityInstanceCount { 0 };
#if ASSERT_ENABLED
bool m_suspendIfNeededWasCalled { false };
Ref<Thread> m_creationThread { Thread::current() };
#endif
friend class ActiveDOMObjectEventDispatchTask;
};
#if !ASSERT_ENABLED
inline void ActiveDOMObject::assertSuspendIfNeededWasCalled() const
{
}
#endif
}