Use "= default" to denote default constructor or destructor
[WebKit-https.git] / Source / WebCore / page / DOMTimer.cpp
1 /*
2  * Copyright (C) 2008, 2014 Apple Inc. All Rights Reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24  *
25  */
26
27 #include "config.h"
28 #include "DOMTimer.h"
29
30 #include "HTMLPlugInElement.h"
31 #include "InspectorInstrumentation.h"
32 #include "Logging.h"
33 #include "Page.h"
34 #include "PluginViewBase.h"
35 #include "ScheduledAction.h"
36 #include "ScriptExecutionContext.h"
37 #include "Settings.h"
38 #include <wtf/CurrentTime.h>
39 #include <wtf/HashMap.h>
40 #include <wtf/MathExtras.h>
41 #include <wtf/NeverDestroyed.h>
42 #include <wtf/RandomNumber.h>
43 #include <wtf/StdLibExtras.h>
44
45 #if PLATFORM(IOS)
46 #include "Chrome.h"
47 #include "ChromeClient.h"
48 #include "Frame.h"
49 #include "WKContentObservation.h"
50 #include "WKContentObservationInternal.h"
51 #endif
52
53 namespace WebCore {
54
55 static const Seconds maxIntervalForUserGestureForwarding { 1_s }; // One second matches Gecko.
56 static const Seconds minIntervalForNonUserObservableChangeTimers { 1_s }; // Empirically determined to maximize battery life.
57 static const int maxTimerNestingLevel = 5;
58
59 class DOMTimerFireState {
60 public:
61     DOMTimerFireState(ScriptExecutionContext& context, int nestingLevel, const Seconds& nestedTimerInterval)
62         : m_context(context)
63         , m_nestedTimerInterval(nestedTimerInterval)
64         , m_contextIsDocument(is<Document>(m_context))
65     {
66         // For worker threads, don't update the current DOMTimerFireState.
67         // Setting this from workers would not be thread-safe, and its not relevant to current uses.
68         if (m_contextIsDocument) {
69             m_initialDOMTreeVersion = downcast<Document>(context).domTreeVersion();
70             m_previous = current;
71             current = this;
72         }
73
74         m_context.setTimerNestingLevel(nestingLevel);
75     }
76
77     ~DOMTimerFireState()
78     {
79         if (m_contextIsDocument)
80             current = m_previous;
81         m_context.setTimerNestingLevel(0);
82     }
83
84     Document* contextDocument() const { return m_contextIsDocument ? &downcast<Document>(m_context) : nullptr; }
85
86     const Seconds& nestedTimerInterval() const { return m_nestedTimerInterval; }
87
88     void setScriptMadeUserObservableChanges() { m_scriptMadeUserObservableChanges = true; }
89     void setScriptMadeNonUserObservableChanges() { m_scriptMadeNonUserObservableChanges = true; }
90
91     bool scriptMadeNonUserObservableChanges() const { return m_scriptMadeNonUserObservableChanges; }
92     bool scriptMadeUserObservableChanges() const
93     {
94         if (m_scriptMadeUserObservableChanges)
95             return true;
96
97         Document* document = contextDocument();
98         // To be conservative, we also consider any DOM Tree change to be user observable.
99         return document && document->domTreeVersion() != m_initialDOMTreeVersion;
100     }
101
102     static DOMTimerFireState* current;
103
104 private:
105     ScriptExecutionContext& m_context;
106     Seconds m_nestedTimerInterval;
107     uint64_t m_initialDOMTreeVersion;
108     DOMTimerFireState* m_previous;
109     bool m_contextIsDocument;
110     bool m_scriptMadeNonUserObservableChanges { false };
111     bool m_scriptMadeUserObservableChanges { false };
112 };
113
114 DOMTimerFireState* DOMTimerFireState::current = nullptr;
115
116 struct NestedTimersMap {
117     typedef HashMap<int, DOMTimer*>::const_iterator const_iterator;
118
119     static NestedTimersMap* instanceForContext(ScriptExecutionContext& context)
120     {
121         // For worker threads, we don't use NestedTimersMap as doing so would not
122         // be thread safe.
123         if (is<Document>(context))
124             return &instance();
125         return nullptr;
126     }
127
128     void startTracking()
129     {
130         // Make sure we start with an empty HashMap. In theory, it is possible the HashMap is not
131         // empty if a timer fires during the execution of another timer (may happen with the
132         // in-process Web Inspector).
133         nestedTimers.clear();
134         isTrackingNestedTimers = true;
135     }
136
137     void stopTracking()
138     {
139         isTrackingNestedTimers = false;
140         nestedTimers.clear();
141     }
142
143     void add(int timeoutId, DOMTimer* timer)
144     {
145         if (isTrackingNestedTimers)
146             nestedTimers.add(timeoutId, timer);
147     }
148
149     void remove(int timeoutId)
150     {
151         if (isTrackingNestedTimers)
152             nestedTimers.remove(timeoutId);
153     }
154
155     const_iterator begin() const { return nestedTimers.begin(); }
156     const_iterator end() const { return nestedTimers.end(); }
157
158 private:
159     static NestedTimersMap& instance()
160     {
161         static NeverDestroyed<NestedTimersMap> map;
162         return map;
163     }
164
165     static bool isTrackingNestedTimers;
166     HashMap<int /* timeoutId */, DOMTimer*> nestedTimers;
167 };
168
169 bool NestedTimersMap::isTrackingNestedTimers = false;
170
171 static inline bool shouldForwardUserGesture(Seconds interval)
172 {
173     return UserGestureIndicator::processingUserGesture()
174         && interval <= maxIntervalForUserGestureForwarding;
175 }
176
177 static inline RefPtr<UserGestureToken> userGestureTokenToForward(Seconds interval)
178 {
179     if (!shouldForwardUserGesture(interval))
180         return nullptr;
181
182     return UserGestureIndicator::currentUserGesture();
183 }
184
185 static inline Seconds currentNestedTimerInterval()
186 {
187     if (DOMTimerFireState::current)
188         return DOMTimerFireState::current->nestedTimerInterval();
189     return { };
190 }
191
192 DOMTimer::DOMTimer(ScriptExecutionContext& context, std::unique_ptr<ScheduledAction> action, Seconds interval, bool singleShot)
193     : SuspendableTimer(context)
194     , m_nestingLevel(context.timerNestingLevel())
195     , m_action(WTFMove(action))
196     , m_originalInterval(interval)
197     , m_throttleState(Undetermined)
198     , m_currentTimerInterval(intervalClampedToMinimum())
199     , m_nestedTimerInterval(currentNestedTimerInterval())
200     , m_userGestureTokenToForward(userGestureTokenToForward(m_nestedTimerInterval + m_currentTimerInterval))
201 {
202     RefPtr<DOMTimer> reference = adoptRef(this);
203
204     // Keep asking for the next id until we're given one that we don't already have.
205     do {
206         m_timeoutId = context.circularSequentialID();
207     } while (!context.addTimeout(m_timeoutId, *this));
208
209     if (singleShot)
210         startOneShot(m_currentTimerInterval);
211     else
212         startRepeating(m_currentTimerInterval);
213 }
214
215 DOMTimer::~DOMTimer() = default;
216
217 int DOMTimer::install(ScriptExecutionContext& context, std::unique_ptr<ScheduledAction> action, Seconds timeout, bool singleShot)
218 {
219     // DOMTimer constructor passes ownership of the initial ref on the object to the constructor.
220     // This reference will be released automatically when a one-shot timer fires, when the context
221     // is destroyed, or if explicitly cancelled by removeById. 
222     DOMTimer* timer = new DOMTimer(context, WTFMove(action), timeout, singleShot);
223 #if PLATFORM(IOS)
224     if (is<Document>(context)) {
225         bool didDeferTimeout = context.activeDOMObjectsAreSuspended();
226         if (!didDeferTimeout && timeout <= 100_ms && singleShot) {
227             WKSetObservedContentChange(WKContentIndeterminateChange);
228             WebThreadAddObservedContentModifier(timer); // Will only take affect if not already visibility change.
229         }
230     }
231 #endif
232
233     timer->suspendIfNeeded();
234     InspectorInstrumentation::didInstallTimer(context, timer->m_timeoutId, timeout, singleShot);
235
236     // Keep track of nested timer installs.
237     if (NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context))
238         nestedTimers->add(timer->m_timeoutId, timer);
239
240     return timer->m_timeoutId;
241 }
242
243 void DOMTimer::removeById(ScriptExecutionContext& context, int timeoutId)
244 {
245     // timeout IDs have to be positive, and 0 and -1 are unsafe to
246     // even look up since they are the empty and deleted value
247     // respectively
248     if (timeoutId <= 0)
249         return;
250
251     if (NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context))
252         nestedTimers->remove(timeoutId);
253
254     InspectorInstrumentation::didRemoveTimer(context, timeoutId);
255     context.removeTimeout(timeoutId);
256 }
257
258 inline bool DOMTimer::isDOMTimersThrottlingEnabled(Document& document) const
259 {
260     auto* page = document.page();
261     if (!page)
262         return true;
263     return page->settings().domTimersThrottlingEnabled();
264 }
265
266 void DOMTimer::updateThrottlingStateIfNecessary(const DOMTimerFireState& fireState)
267 {
268     Document* contextDocument = fireState.contextDocument();
269     // We don't throttle timers in worker threads.
270     if (!contextDocument)
271         return;
272
273     if (UNLIKELY(!isDOMTimersThrottlingEnabled(*contextDocument))) {
274         if (m_throttleState == ShouldThrottle) {
275             // Unthrottle the timer in case it was throttled before the setting was updated.
276             LOG(DOMTimers, "%p - Unthrottling DOM timer because throttling was disabled via settings.", this);
277             m_throttleState = ShouldNotThrottle;
278             updateTimerIntervalIfNecessary();
279         }
280         return;
281     }
282
283     if (fireState.scriptMadeUserObservableChanges()) {
284         if (m_throttleState != ShouldNotThrottle) {
285             m_throttleState = ShouldNotThrottle;
286             updateTimerIntervalIfNecessary();
287         }
288     } else if (fireState.scriptMadeNonUserObservableChanges()) {
289         if (m_throttleState != ShouldThrottle) {
290             m_throttleState = ShouldThrottle;
291             updateTimerIntervalIfNecessary();
292         }
293     }
294 }
295
296 void DOMTimer::scriptDidInteractWithPlugin(HTMLPlugInElement& pluginElement)
297 {
298     if (!DOMTimerFireState::current)
299         return;
300
301     if (pluginElement.isUserObservable())
302         DOMTimerFireState::current->setScriptMadeUserObservableChanges();
303     else
304         DOMTimerFireState::current->setScriptMadeNonUserObservableChanges();
305 }
306
307 void DOMTimer::fired()
308 {
309     // Retain this - if the timer is cancelled while this function is on the stack (implicitly and always
310     // for one-shot timers, or if removeById is called on itself from within an interval timer fire) then
311     // wait unit the end of this function to delete DOMTimer.
312     RefPtr<DOMTimer> reference = this;
313
314     ASSERT(scriptExecutionContext());
315     ScriptExecutionContext& context = *scriptExecutionContext();
316
317     DOMTimerFireState fireState(context, std::min(m_nestingLevel + 1, maxTimerNestingLevel), m_nestedTimerInterval + m_currentTimerInterval);
318
319     ASSERT(!isSuspended());
320     ASSERT(!context.activeDOMObjectsAreSuspended());
321     UserGestureIndicator gestureIndicator(m_userGestureTokenToForward);
322     // Only the first execution of a multi-shot timer should get an affirmative user gesture indicator.
323     m_userGestureTokenToForward = nullptr;
324
325     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireTimer(context, m_timeoutId);
326
327     // Simple case for non-one-shot timers.
328     if (isActive()) {
329         if (m_nestingLevel < maxTimerNestingLevel) {
330             m_nestingLevel++;
331             updateTimerIntervalIfNecessary();
332         }
333
334         m_action->execute(context);
335
336         InspectorInstrumentation::didFireTimer(cookie);
337         updateThrottlingStateIfNecessary(fireState);
338
339         return;
340     }
341
342     context.removeTimeout(m_timeoutId);
343
344 #if PLATFORM(IOS)
345     bool shouldReportLackOfChanges;
346     bool shouldBeginObservingChanges;
347     if (is<Document>(context)) {
348         shouldReportLackOfChanges = WebThreadCountOfObservedContentModifiers() == 1;
349         shouldBeginObservingChanges = WebThreadContainsObservedContentModifier(this);
350     } else {
351         shouldReportLackOfChanges = false;
352         shouldBeginObservingChanges = false;
353     }
354
355     if (shouldBeginObservingChanges) {
356         WKBeginObservingContentChanges(false);
357         WebThreadRemoveObservedContentModifier(this);
358     }
359 #endif
360
361     // Keep track nested timer installs.
362     NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context);
363     if (nestedTimers)
364         nestedTimers->startTracking();
365
366     m_action->execute(context);
367
368 #if PLATFORM(IOS)
369     if (shouldBeginObservingChanges) {
370         WKStopObservingContentChanges();
371
372         if (WKObservedContentChange() == WKContentVisibilityChange || shouldReportLackOfChanges) {
373             Document& document = downcast<Document>(context);
374             if (Page* page = document.page())
375                 page->chrome().client().observedContentChange(*document.frame());
376         }
377     }
378 #endif
379
380     InspectorInstrumentation::didFireTimer(cookie);
381
382     // Check if we should throttle nested single-shot timers.
383     if (nestedTimers) {
384         for (auto& keyValue : *nestedTimers) {
385             auto* timer = keyValue.value;
386             if (timer->isActive() && !timer->repeatInterval())
387                 timer->updateThrottlingStateIfNecessary(fireState);
388         }
389         nestedTimers->stopTracking();
390     }
391 }
392
393 void DOMTimer::didStop()
394 {
395     // Need to release JS objects potentially protected by ScheduledAction
396     // because they can form circular references back to the ScriptExecutionContext
397     // which will cause a memory leak.
398     m_action = nullptr;
399 }
400
401 void DOMTimer::updateTimerIntervalIfNecessary()
402 {
403     ASSERT(m_nestingLevel <= maxTimerNestingLevel);
404
405     auto previousInterval = m_currentTimerInterval;
406     m_currentTimerInterval = intervalClampedToMinimum();
407     if (previousInterval == m_currentTimerInterval)
408         return;
409
410     if (repeatInterval()) {
411         ASSERT(repeatInterval() == previousInterval);
412         LOG(DOMTimers, "%p - Updating DOMTimer's repeat interval from %.2f ms to %.2f ms due to throttling.", this, previousInterval.milliseconds(), m_currentTimerInterval.milliseconds());
413         augmentRepeatInterval(m_currentTimerInterval - previousInterval);
414     } else {
415         LOG(DOMTimers, "%p - Updating DOMTimer's fire interval from %.2f ms to %.2f ms due to throttling.", this, previousInterval.milliseconds(), m_currentTimerInterval.milliseconds());
416         augmentFireInterval(m_currentTimerInterval - previousInterval);
417     }
418 }
419
420 Seconds DOMTimer::intervalClampedToMinimum() const
421 {
422     ASSERT(scriptExecutionContext());
423     ASSERT(m_nestingLevel <= maxTimerNestingLevel);
424
425     Seconds interval = std::max(1_ms, m_originalInterval);
426
427     // Only apply throttling to repeating timers.
428     if (m_nestingLevel < maxTimerNestingLevel)
429         return interval;
430
431     // Apply two throttles - the global (per Page) minimum, and also a per-timer throttle.
432     interval = std::max(interval, scriptExecutionContext()->minimumDOMTimerInterval());
433     if (m_throttleState == ShouldThrottle)
434         interval = std::max(interval, minIntervalForNonUserObservableChangeTimers);
435     return interval;
436 }
437
438 std::optional<MonotonicTime> DOMTimer::alignedFireTime(MonotonicTime fireTime) const
439 {
440     Seconds alignmentInterval = scriptExecutionContext()->domTimerAlignmentInterval(m_nestingLevel >= maxTimerNestingLevel);
441     if (!alignmentInterval)
442         return std::nullopt;
443     
444     static const double randomizedProportion = randomNumber();
445
446     // Force alignment to randomizedAlignment fraction of the way between alignemntIntervals, e.g.
447     // if alignmentInterval is 10_ms and randomizedAlignment is 0.3 this will align to 3, 13, 23, ...
448     Seconds randomizedOffset = alignmentInterval * randomizedProportion;
449     MonotonicTime adjustedFireTime = fireTime - randomizedOffset;
450     return adjustedFireTime - (adjustedFireTime % alignmentInterval) + alignmentInterval + randomizedOffset;
451 }
452
453 const char* DOMTimer::activeDOMObjectName() const
454 {
455     return "DOMTimer";
456 }
457
458 } // namespace WebCore