blob: 021ce79f083d7e23cc0a660e765c3b2f64689fe6 [file] [log] [blame]
/*
* Copyright (C) 2008, 2014 Apple Inc. All Rights Reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include "config.h"
#include "DOMTimer.h"
#include "HTMLPlugInElement.h"
#include "InspectorInstrumentation.h"
#include "Logging.h"
#include "Page.h"
#include "PluginViewBase.h"
#include "ScheduledAction.h"
#include "ScriptExecutionContext.h"
#include "Settings.h"
#include <wtf/HashMap.h>
#include <wtf/MathExtras.h>
#include <wtf/NeverDestroyed.h>
#include <wtf/RandomNumber.h>
#include <wtf/StdLibExtras.h>
#if PLATFORM(IOS)
#include "Chrome.h"
#include "ChromeClient.h"
#include "Frame.h"
#include "WKContentObservation.h"
#include "WKContentObservationInternal.h"
#endif
namespace WebCore {
static const Seconds maxIntervalForUserGestureForwarding { 1_s }; // One second matches Gecko.
static const Seconds minIntervalForNonUserObservableChangeTimers { 1_s }; // Empirically determined to maximize battery life.
static const int maxTimerNestingLevel = 5;
class DOMTimerFireState {
public:
DOMTimerFireState(ScriptExecutionContext& context, int nestingLevel, const Seconds& nestedTimerInterval)
: m_context(context)
, m_nestedTimerInterval(nestedTimerInterval)
, m_contextIsDocument(is<Document>(m_context))
{
// For worker threads, don't update the current DOMTimerFireState.
// Setting this from workers would not be thread-safe, and its not relevant to current uses.
if (m_contextIsDocument) {
m_initialDOMTreeVersion = downcast<Document>(context).domTreeVersion();
m_previous = current;
current = this;
}
m_context.setTimerNestingLevel(nestingLevel);
}
~DOMTimerFireState()
{
if (m_contextIsDocument)
current = m_previous;
m_context.setTimerNestingLevel(0);
}
Document* contextDocument() const { return m_contextIsDocument ? &downcast<Document>(m_context) : nullptr; }
const Seconds& nestedTimerInterval() const { return m_nestedTimerInterval; }
void setScriptMadeUserObservableChanges() { m_scriptMadeUserObservableChanges = true; }
void setScriptMadeNonUserObservableChanges() { m_scriptMadeNonUserObservableChanges = true; }
bool scriptMadeNonUserObservableChanges() const { return m_scriptMadeNonUserObservableChanges; }
bool scriptMadeUserObservableChanges() const
{
if (m_scriptMadeUserObservableChanges)
return true;
Document* document = contextDocument();
// To be conservative, we also consider any DOM Tree change to be user observable.
return document && document->domTreeVersion() != m_initialDOMTreeVersion;
}
static DOMTimerFireState* current;
private:
ScriptExecutionContext& m_context;
Seconds m_nestedTimerInterval;
uint64_t m_initialDOMTreeVersion;
DOMTimerFireState* m_previous;
bool m_contextIsDocument;
bool m_scriptMadeNonUserObservableChanges { false };
bool m_scriptMadeUserObservableChanges { false };
};
DOMTimerFireState* DOMTimerFireState::current = nullptr;
struct NestedTimersMap {
typedef HashMap<int, DOMTimer*>::const_iterator const_iterator;
static NestedTimersMap* instanceForContext(ScriptExecutionContext& context)
{
// For worker threads, we don't use NestedTimersMap as doing so would not
// be thread safe.
if (is<Document>(context))
return &instance();
return nullptr;
}
void startTracking()
{
// Make sure we start with an empty HashMap. In theory, it is possible the HashMap is not
// empty if a timer fires during the execution of another timer (may happen with the
// in-process Web Inspector).
nestedTimers.clear();
isTrackingNestedTimers = true;
}
void stopTracking()
{
isTrackingNestedTimers = false;
nestedTimers.clear();
}
void add(int timeoutId, DOMTimer* timer)
{
if (isTrackingNestedTimers)
nestedTimers.add(timeoutId, timer);
}
void remove(int timeoutId)
{
if (isTrackingNestedTimers)
nestedTimers.remove(timeoutId);
}
const_iterator begin() const { return nestedTimers.begin(); }
const_iterator end() const { return nestedTimers.end(); }
private:
static NestedTimersMap& instance()
{
static NeverDestroyed<NestedTimersMap> map;
return map;
}
static bool isTrackingNestedTimers;
HashMap<int /* timeoutId */, DOMTimer*> nestedTimers;
};
bool NestedTimersMap::isTrackingNestedTimers = false;
static inline bool shouldForwardUserGesture(Seconds interval)
{
return UserGestureIndicator::processingUserGesture()
&& interval <= maxIntervalForUserGestureForwarding;
}
static inline RefPtr<UserGestureToken> userGestureTokenToForward(Seconds interval)
{
if (!shouldForwardUserGesture(interval))
return nullptr;
return UserGestureIndicator::currentUserGesture();
}
static inline Seconds currentNestedTimerInterval()
{
if (DOMTimerFireState::current)
return DOMTimerFireState::current->nestedTimerInterval();
return { };
}
DOMTimer::DOMTimer(ScriptExecutionContext& context, std::unique_ptr<ScheduledAction> action, Seconds interval, bool singleShot)
: SuspendableTimer(context)
, m_nestingLevel(context.timerNestingLevel())
, m_action(WTFMove(action))
, m_originalInterval(interval)
, m_throttleState(Undetermined)
, m_currentTimerInterval(intervalClampedToMinimum())
, m_nestedTimerInterval(currentNestedTimerInterval())
, m_userGestureTokenToForward(userGestureTokenToForward(m_nestedTimerInterval + m_currentTimerInterval))
{
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, *this));
if (singleShot)
startOneShot(m_currentTimerInterval);
else
startRepeating(m_currentTimerInterval);
}
DOMTimer::~DOMTimer() = default;
int DOMTimer::install(ScriptExecutionContext& context, std::unique_ptr<ScheduledAction> action, Seconds timeout, bool singleShot)
{
// DOMTimer constructor passes ownership of the initial ref on the object to the constructor.
// This reference will be released automatically when a one-shot timer fires, when the context
// is destroyed, or if explicitly cancelled by removeById.
DOMTimer* timer = new DOMTimer(context, WTFMove(action), timeout, singleShot);
#if PLATFORM(IOS)
if (is<Document>(context)) {
bool didDeferTimeout = context.activeDOMObjectsAreSuspended();
if (!didDeferTimeout && timeout <= 100_ms && singleShot) {
WKSetObservedContentChange(WKContentIndeterminateChange);
WebThreadAddObservedContentModifier(timer); // Will only take affect if not already visibility change.
}
}
#endif
timer->suspendIfNeeded();
InspectorInstrumentation::didInstallTimer(context, timer->m_timeoutId, timeout, singleShot);
// Keep track of nested timer installs.
if (NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context))
nestedTimers->add(timer->m_timeoutId, timer);
return timer->m_timeoutId;
}
void DOMTimer::removeById(ScriptExecutionContext& context, int timeoutId)
{
// timeout IDs have to be positive, and 0 and -1 are unsafe to
// even look up since they are the empty and deleted value
// respectively
if (timeoutId <= 0)
return;
if (NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context))
nestedTimers->remove(timeoutId);
InspectorInstrumentation::didRemoveTimer(context, timeoutId);
context.removeTimeout(timeoutId);
}
inline bool DOMTimer::isDOMTimersThrottlingEnabled(Document& document) const
{
auto* page = document.page();
if (!page)
return true;
return page->settings().domTimersThrottlingEnabled();
}
void DOMTimer::updateThrottlingStateIfNecessary(const DOMTimerFireState& fireState)
{
Document* contextDocument = fireState.contextDocument();
// We don't throttle timers in worker threads.
if (!contextDocument)
return;
if (UNLIKELY(!isDOMTimersThrottlingEnabled(*contextDocument))) {
if (m_throttleState == ShouldThrottle) {
// Unthrottle the timer in case it was throttled before the setting was updated.
LOG(DOMTimers, "%p - Unthrottling DOM timer because throttling was disabled via settings.", this);
m_throttleState = ShouldNotThrottle;
updateTimerIntervalIfNecessary();
}
return;
}
if (fireState.scriptMadeUserObservableChanges()) {
if (m_throttleState != ShouldNotThrottle) {
m_throttleState = ShouldNotThrottle;
updateTimerIntervalIfNecessary();
}
} else if (fireState.scriptMadeNonUserObservableChanges()) {
if (m_throttleState != ShouldThrottle) {
m_throttleState = ShouldThrottle;
updateTimerIntervalIfNecessary();
}
}
}
void DOMTimer::scriptDidInteractWithPlugin(HTMLPlugInElement& pluginElement)
{
if (!DOMTimerFireState::current)
return;
if (pluginElement.isUserObservable())
DOMTimerFireState::current->setScriptMadeUserObservableChanges();
else
DOMTimerFireState::current->setScriptMadeNonUserObservableChanges();
}
void DOMTimer::fired()
{
// Retain this - if the timer is cancelled while this function is on the stack (implicitly and always
// for one-shot timers, or if removeById is called on itself from within an interval timer fire) then
// wait unit the end of this function to delete DOMTimer.
RefPtr<DOMTimer> reference = this;
ASSERT(scriptExecutionContext());
ScriptExecutionContext& context = *scriptExecutionContext();
DOMTimerFireState fireState(context, std::min(m_nestingLevel + 1, maxTimerNestingLevel), m_nestedTimerInterval + m_currentTimerInterval);
ASSERT(!isSuspended());
ASSERT(!context.activeDOMObjectsAreSuspended());
UserGestureIndicator gestureIndicator(m_userGestureTokenToForward);
// Only the first execution of a multi-shot timer should get an affirmative user gesture indicator.
m_userGestureTokenToForward = nullptr;
InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireTimer(context, m_timeoutId);
// Simple case for non-one-shot timers.
if (isActive()) {
if (m_nestingLevel < maxTimerNestingLevel) {
m_nestingLevel++;
updateTimerIntervalIfNecessary();
}
m_action->execute(context);
InspectorInstrumentation::didFireTimer(cookie);
updateThrottlingStateIfNecessary(fireState);
return;
}
context.removeTimeout(m_timeoutId);
#if PLATFORM(IOS)
bool shouldReportLackOfChanges;
bool shouldBeginObservingChanges;
if (is<Document>(context)) {
shouldReportLackOfChanges = WebThreadCountOfObservedContentModifiers() == 1;
shouldBeginObservingChanges = WebThreadContainsObservedContentModifier(this);
} else {
shouldReportLackOfChanges = false;
shouldBeginObservingChanges = false;
}
if (shouldBeginObservingChanges) {
WKBeginObservingContentChanges(false);
WebThreadRemoveObservedContentModifier(this);
}
#endif
// Keep track nested timer installs.
NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context);
if (nestedTimers)
nestedTimers->startTracking();
m_action->execute(context);
#if PLATFORM(IOS)
if (shouldBeginObservingChanges) {
WKStopObservingContentChanges();
if (WKObservedContentChange() == WKContentVisibilityChange || shouldReportLackOfChanges) {
Document& document = downcast<Document>(context);
if (Page* page = document.page())
page->chrome().client().observedContentChange(*document.frame());
}
}
#endif
InspectorInstrumentation::didFireTimer(cookie);
// Check if we should throttle nested single-shot timers.
if (nestedTimers) {
for (auto& keyValue : *nestedTimers) {
auto* timer = keyValue.value;
if (timer->isActive() && !timer->repeatInterval())
timer->updateThrottlingStateIfNecessary(fireState);
}
nestedTimers->stopTracking();
}
}
void DOMTimer::didStop()
{
// Need to release JS objects potentially protected by ScheduledAction
// because they can form circular references back to the ScriptExecutionContext
// which will cause a memory leak.
m_action = nullptr;
}
void DOMTimer::updateTimerIntervalIfNecessary()
{
ASSERT(m_nestingLevel <= maxTimerNestingLevel);
auto previousInterval = m_currentTimerInterval;
m_currentTimerInterval = intervalClampedToMinimum();
if (previousInterval == m_currentTimerInterval)
return;
if (repeatInterval()) {
ASSERT(repeatInterval() == previousInterval);
LOG(DOMTimers, "%p - Updating DOMTimer's repeat interval from %.2f ms to %.2f ms due to throttling.", this, previousInterval.milliseconds(), m_currentTimerInterval.milliseconds());
augmentRepeatInterval(m_currentTimerInterval - previousInterval);
} else {
LOG(DOMTimers, "%p - Updating DOMTimer's fire interval from %.2f ms to %.2f ms due to throttling.", this, previousInterval.milliseconds(), m_currentTimerInterval.milliseconds());
augmentFireInterval(m_currentTimerInterval - previousInterval);
}
}
Seconds DOMTimer::intervalClampedToMinimum() const
{
ASSERT(scriptExecutionContext());
ASSERT(m_nestingLevel <= maxTimerNestingLevel);
Seconds interval = std::max(1_ms, m_originalInterval);
// Only apply throttling to repeating timers.
if (m_nestingLevel < maxTimerNestingLevel)
return interval;
// Apply two throttles - the global (per Page) minimum, and also a per-timer throttle.
interval = std::max(interval, scriptExecutionContext()->minimumDOMTimerInterval());
if (m_throttleState == ShouldThrottle)
interval = std::max(interval, minIntervalForNonUserObservableChangeTimers);
return interval;
}
std::optional<MonotonicTime> DOMTimer::alignedFireTime(MonotonicTime fireTime) const
{
Seconds alignmentInterval = scriptExecutionContext()->domTimerAlignmentInterval(m_nestingLevel >= maxTimerNestingLevel);
if (!alignmentInterval)
return std::nullopt;
static const double randomizedProportion = randomNumber();
// Force alignment to randomizedAlignment fraction of the way between alignemntIntervals, e.g.
// if alignmentInterval is 10_ms and randomizedAlignment is 0.3 this will align to 3, 13, 23, ...
Seconds randomizedOffset = alignmentInterval * randomizedProportion;
MonotonicTime adjustedFireTime = fireTime - randomizedOffset;
return adjustedFireTime - (adjustedFireTime % alignmentInterval) + alignmentInterval + randomizedOffset;
}
const char* DOMTimer::activeDOMObjectName() const
{
return "DOMTimer";
}
} // namespace WebCore