void SVGTimer::start() { if (m_singleShot) startOneShot(m_interval); else startRepeating(m_interval); }
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 XMLHttpRequestProgressEventThrottle::dispatchThrottledProgressEvent(bool lengthComputable, unsigned long long loaded, unsigned long long total) { m_lengthComputable = lengthComputable; m_loaded = loaded; m_total = total; if (m_deferEvents) { // Only store the latest progress event while suspended. m_deferredProgressEvent = XMLHttpRequestProgressEvent::create(eventNames().progressEvent, lengthComputable, loaded, total); return; } if (!isActive()) { // The timer is not active so the least frequent event for now is every byte. // Just go ahead and dispatch the event. // We should not have any throttled progress event. ASSERT(!m_hasThrottledProgressEvent); dispatchEvent(XMLHttpRequestProgressEvent::create(eventNames().progressEvent, lengthComputable, loaded, total)); startRepeating(minimumProgressEventDispatchingIntervalInSeconds); m_hasThrottledProgressEvent = false; return; } // The timer is already active so minimumProgressEventDispatchingIntervalInSeconds is the least frequent event. m_hasThrottledProgressEvent = true; }
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); }
void XMLHttpRequestProgressEventThrottle::dispatchProgressEvent(bool lengthComputable, unsigned loaded, unsigned total) { ASSERT(!suspended()); if (!isActive()) { // The timer is not active so the least frequent event for now is every byte. // Just go ahead and dispatch the event. // We should not have any pending loaded & total information from a previous run. ASSERT(!m_loaded); ASSERT(!m_total); dispatchEvent(XMLHttpRequestProgressEvent::create(eventNames().progressEvent, lengthComputable, loaded, total)); startRepeating(minimumProgressEventDispatchingIntervalInSeconds); return; } // The timer is already active so minimumProgressEventDispatchingIntervalInSeconds is the least frequent event. m_lengthComputable = lengthComputable; m_loaded = loaded; m_total = total; }
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); }