DOMTimer::DOMTimer(ScriptExecutionContext* context, ScheduledAction* action, int timeout, bool singleShot)
: ActiveDOMObject(context, this)
, m_action(action)
, m_nextFireInterval(0)
, m_repeatInterval(0)
#if !ASSERT_DISABLED
, m_suspended(false)
#endif
{
static int lastUsedTimeoutId = 0;
++lastUsedTimeoutId;
// Avoid wraparound going negative on us.
if (lastUsedTimeoutId <= 0)
lastUsedTimeoutId = 1;
m_timeoutId = lastUsedTimeoutId;
m_nestingLevel = timerNestingLevel + 1;
scriptExecutionContext()->addTimeout(m_timeoutId, this);
double intervalMilliseconds = max(oneMillisecond, timeout * oneMillisecond);
// Use a minimum interval of 10 ms to match other browsers, but only once we've
// nested enough to notice that we're repeating.
// Faster timers might be "better", but they're incompatible.
if (intervalMilliseconds < s_minTimerInterval && m_nestingLevel >= maxTimerNestingLevel)
intervalMilliseconds = s_minTimerInterval;
if (singleShot)
startOneShot(intervalMilliseconds);
else
startRepeating(intervalMilliseconds);
}
void SVGTimer::start()
{
if (m_singleShot)
startOneShot(m_interval);
else
startRepeating(m_interval);
}
void XMLHttpRequestProgressEventThrottle::resume()
{
if (!m_deferred.isSet())
return;
// Do not dispatch events inline here, since ExecutionContext is iterating
// over the list of active DOM objects to resume them, and any activated JS
// event-handler could insert new active DOM objects to the list.
startOneShot(0, BLINK_FROM_HERE);
}
void SuspendableScriptExecutor::run()
{
ExecutionContext* context = getExecutionContext();
DCHECK(context);
if (!context->activeDOMObjectsAreSuspended()) {
suspendIfNeeded();
executeAndDestroySelf();
return;
}
startOneShot(0, BLINK_FROM_HERE);
suspendIfNeeded();
}
void XMLHttpRequestProgressEventThrottle::fired()
{
if (!m_deferred.isSet()) {
// No "progress" event was queued since the previous dispatch, we can
// safely stop the timer.
return;
}
dispatchProgressProgressEvent(m_deferred.take());
// Watch if another "progress" ProgressEvent arrives in the next 50ms.
startOneShot(kMinimumProgressEventDispatchingIntervalInSeconds, BLINK_FROM_HERE);
}
void DNSResolveQueue::fired()
{
int requestsAllowed = maxSimultaneousRequests - m_requestsInFlight;
for (; !m_names.isEmpty() && requestsAllowed > 0; --requestsAllowed) {
atomicIncrement(&m_requestsInFlight);
HashSet<String>::iterator currentName = m_names.begin();
resolve(*currentName);
m_names.remove(currentName);
}
if (!m_names.isEmpty())
startOneShot(retryResolvingInSeconds);
}
void XMLHttpRequestProgressEventThrottle::dispatchProgressEvent(const AtomicString& type, bool lengthComputable, unsigned long long loaded, unsigned long long total)
{
// Given that ResourceDispatcher doesn't deliver an event when suspended,
// we don't have to worry about event dispatching while suspended.
if (type != EventTypeNames::progress) {
m_target->dispatchEvent(ProgressEvent::create(type, lengthComputable, loaded, total));
return;
}
if (isActive()) {
m_deferred.set(lengthComputable, loaded, total);
} else {
dispatchProgressProgressEvent(ProgressEvent::create(EventTypeNames::progress, lengthComputable, loaded, total));
startOneShot(kMinimumProgressEventDispatchingIntervalInSeconds, BLINK_FROM_HERE);
}
}
DOMTimer::DOMTimer(ScriptExecutionContext* context, PassOwnPtr<ScheduledAction> action, int interval, bool singleShot)
: SuspendableTimer(context)
, m_timeoutId(timeoutId())
, m_nestingLevel(timerNestingLevel + 1)
, m_action(action)
, m_originalInterval(interval)
, m_shouldForwardUserGesture(shouldForwardUserGesture(interval, m_nestingLevel))
{
scriptExecutionContext()->addTimeout(m_timeoutId, this);
double intervalMilliseconds = intervalClampedToMinimum(interval, context->minimumTimerInterval());
if (singleShot)
startOneShot(intervalMilliseconds);
else
startRepeating(intervalMilliseconds);
}
DOMTimer::DOMTimer(ScriptExecutionContext* context, PassOwnPtr<ScheduledAction> action, int interval, bool singleShot)
: SuspendableTimer(context)
, m_nestingLevel(timerNestingLevel + 1)
, m_action(action)
, m_originalInterval(interval)
, m_shouldForwardUserGesture(shouldForwardUserGesture(interval, m_nestingLevel))
{
// Keep asking for the next id until we're given one that we don't already have.
do {
m_timeoutId = context->circularSequentialID();
} while (!context->addTimeout(m_timeoutId, this));
double intervalMilliseconds = intervalClampedToMinimum(interval, context->minimumTimerInterval());
if (singleShot)
startOneShot(intervalMilliseconds);
else
startRepeating(intervalMilliseconds);
}
DOMTimer::DOMTimer(ExecutionContext* context, PassOwnPtr<ScheduledAction> action, int interval, bool singleShot, int timeoutID)
: SuspendableTimer(context)
, m_timeoutID(timeoutID)
, m_nestingLevel(timerNestingLevel + 1)
, m_action(action)
{
ASSERT(timeoutID > 0);
if (shouldForwardUserGesture(interval, m_nestingLevel))
m_userGestureToken = UserGestureIndicator::currentToken();
double intervalMilliseconds = std::max(oneMillisecond, interval * oneMillisecond);
if (intervalMilliseconds < minimumInterval && m_nestingLevel >= maxTimerNestingLevel)
intervalMilliseconds = minimumInterval;
if (singleShot)
startOneShot(intervalMilliseconds, FROM_HERE);
else
startRepeating(intervalMilliseconds, FROM_HERE);
}
DOMTimer::DOMTimer(ExecutionContext* context, ScheduledAction* action, int interval, bool singleShot, int timeoutID)
: SuspendableTimer(context)
, m_timeoutID(timeoutID)
, m_nestingLevel(context->timers()->timerNestingLevel() + 1)
, m_action(action)
{
ASSERT(timeoutID > 0);
if (shouldForwardUserGesture(interval, m_nestingLevel))
m_userGestureToken = UserGestureIndicator::currentToken();
InspectorInstrumentation::asyncTaskScheduled(context, singleShot ? "setTimeout" : "setInterval", this, !singleShot);
double intervalMilliseconds = std::max(oneMillisecond, interval * oneMillisecond);
if (intervalMilliseconds < minimumInterval && m_nestingLevel >= maxTimerNestingLevel)
intervalMilliseconds = minimumInterval;
if (singleShot)
startOneShot(intervalMilliseconds, BLINK_FROM_HERE);
else
startRepeating(intervalMilliseconds, BLINK_FROM_HERE);
}
DOMTimer::DOMTimer(ScriptExecutionContext* context, std::unique_ptr<ScheduledAction> action, int interval, bool singleShot)
: SuspendableTimer(context)
, m_nestingLevel(context->timerNestingLevel())
, m_action(WTF::move(action))
, m_originalInterval(interval)
, m_currentTimerInterval(intervalClampedToMinimum())
, m_shouldForwardUserGesture(shouldForwardUserGesture(interval, m_nestingLevel))
{
RefPtr<DOMTimer> reference = adoptRef(this);
// Keep asking for the next id until we're given one that we don't already have.
do {
m_timeoutId = context->circularSequentialID();
} while (!context->addTimeout(m_timeoutId, reference));
if (singleShot)
startOneShot(m_currentTimerInterval);
else
startRepeating(m_currentTimerInterval);
}
DOMTimer::DOMTimer(ScriptExecutionContext* context, PassOwnPtr<ScheduledAction> action, int timeout, bool singleShot)
: SuspendableTimer(context)
, m_action(action)
{
static int lastUsedTimeoutId = 0;
++lastUsedTimeoutId;
// Avoid wraparound going negative on us.
if (lastUsedTimeoutId <= 0)
lastUsedTimeoutId = 1;
m_timeoutId = lastUsedTimeoutId;
m_nestingLevel = timerNestingLevel + 1;
scriptExecutionContext()->addTimeout(m_timeoutId, this);
double intervalMilliseconds = max(oneMillisecond, timeout * oneMillisecond);
if (intervalMilliseconds < s_minTimerInterval && m_nestingLevel >= maxTimerNestingLevel)
intervalMilliseconds = s_minTimerInterval;
if (singleShot)
startOneShot(intervalMilliseconds);
else
startRepeating(intervalMilliseconds);
}
