Replace WTF::move with WTFMove
[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 "UserGestureIndicator.h"
39 #include <wtf/CurrentTime.h>
40 #include <wtf/HashMap.h>
41 #include <wtf/MathExtras.h>
42 #include <wtf/NeverDestroyed.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 #endif
51
52 namespace WebCore {
53
54 static const int maxIntervalForUserGestureForwarding = 1000; // One second matches Gecko.
55 static const int minIntervalForNonUserObservableChangeTimers = 1000; // Empirically determined to maximize battery life.
56 static const int maxTimerNestingLevel = 5;
57 static const double oneMillisecond = 0.001;
58
59 class DOMTimerFireState {
60 public:
61     explicit DOMTimerFireState(ScriptExecutionContext& context)
62         : m_context(context)
63         , m_contextIsDocument(is<Document>(m_context))
64     {
65         // For worker threads, don't update the current DOMTimerFireState.
66         // Setting this from workers would not be thread-safe, and its not relevant to current uses.
67         if (m_contextIsDocument) {
68             m_initialDOMTreeVersion = downcast<Document>(context).domTreeVersion();
69             m_previous = current;
70             current = this;
71         }
72     }
73
74     ~DOMTimerFireState()
75     {
76         if (m_contextIsDocument)
77             current = m_previous;
78     }
79
80     Document* contextDocument() const { return m_contextIsDocument ? &downcast<Document>(m_context) : nullptr; }
81
82     void setScriptMadeUserObservableChanges() { m_scriptMadeUserObservableChanges = true; }
83     void setScriptMadeNonUserObservableChanges() { m_scriptMadeNonUserObservableChanges = true; }
84
85     bool scriptMadeNonUserObservableChanges() const { return m_scriptMadeNonUserObservableChanges; }
86     bool scriptMadeUserObservableChanges() const
87     {
88         if (m_scriptMadeUserObservableChanges)
89             return true;
90
91         Document* document = contextDocument();
92         // To be conservative, we also consider any DOM Tree change to be user observable.
93         return document && document->domTreeVersion() != m_initialDOMTreeVersion;
94     }
95
96     static DOMTimerFireState* current;
97
98 private:
99     ScriptExecutionContext& m_context;
100     uint64_t m_initialDOMTreeVersion;
101     DOMTimerFireState* m_previous;
102     bool m_contextIsDocument;
103     bool m_scriptMadeNonUserObservableChanges { false };
104     bool m_scriptMadeUserObservableChanges { false };
105 };
106
107 DOMTimerFireState* DOMTimerFireState::current = nullptr;
108
109 struct NestedTimersMap {
110     typedef HashMap<int, DOMTimer*>::const_iterator const_iterator;
111
112     static NestedTimersMap* instanceForContext(ScriptExecutionContext& context)
113     {
114         // For worker threads, we don't use NestedTimersMap as doing so would not
115         // be thread safe.
116         if (is<Document>(context))
117             return &instance();
118         return nullptr;
119     }
120
121     void startTracking()
122     {
123         // Make sure we start with an empty HashMap. In theory, it is possible the HashMap is not
124         // empty if a timer fires during the execution of another timer (may happen with the
125         // in-process Web Inspector).
126         nestedTimers.clear();
127         isTrackingNestedTimers = true;
128     }
129
130     void stopTracking()
131     {
132         isTrackingNestedTimers = false;
133         nestedTimers.clear();
134     }
135
136     void add(int timeoutId, DOMTimer* timer)
137     {
138         if (isTrackingNestedTimers)
139             nestedTimers.add(timeoutId, timer);
140     }
141
142     void remove(int timeoutId)
143     {
144         if (isTrackingNestedTimers)
145             nestedTimers.remove(timeoutId);
146     }
147
148     const_iterator begin() const { return nestedTimers.begin(); }
149     const_iterator end() const { return nestedTimers.end(); }
150
151 private:
152     static NestedTimersMap& instance()
153     {
154         static NeverDestroyed<NestedTimersMap> map;
155         return map;
156     }
157
158     static bool isTrackingNestedTimers;
159     HashMap<int /* timeoutId */, DOMTimer*> nestedTimers;
160 };
161
162 bool NestedTimersMap::isTrackingNestedTimers = false;
163
164 static inline bool shouldForwardUserGesture(int interval, int nestingLevel)
165 {
166     return UserGestureIndicator::processingUserGesture()
167         && interval <= maxIntervalForUserGestureForwarding
168         && !nestingLevel; // Gestures should not be forwarded to nested timers.
169 }
170
171 DOMTimer::DOMTimer(ScriptExecutionContext& context, std::unique_ptr<ScheduledAction> action, int interval, bool singleShot)
172     : SuspendableTimer(context)
173     , m_nestingLevel(context.timerNestingLevel())
174     , m_action(WTFMove(action))
175     , m_originalInterval(interval)
176     , m_throttleState(Undetermined)
177     , m_currentTimerInterval(intervalClampedToMinimum())
178     , m_shouldForwardUserGesture(shouldForwardUserGesture(interval, m_nestingLevel))
179 {
180     RefPtr<DOMTimer> reference = adoptRef(this);
181
182     // Keep asking for the next id until we're given one that we don't already have.
183     do {
184         m_timeoutId = context.circularSequentialID();
185     } while (!context.addTimeout(m_timeoutId, reference));
186
187     if (singleShot)
188         startOneShot(m_currentTimerInterval);
189     else
190         startRepeating(m_currentTimerInterval);
191 }
192
193 DOMTimer::~DOMTimer()
194 {
195 }
196
197 int DOMTimer::install(ScriptExecutionContext& context, std::unique_ptr<ScheduledAction> action, int timeout, bool singleShot)
198 {
199     // DOMTimer constructor passes ownership of the initial ref on the object to the constructor.
200     // This reference will be released automatically when a one-shot timer fires, when the context
201     // is destroyed, or if explicitly cancelled by removeById. 
202     DOMTimer* timer = new DOMTimer(context, WTFMove(action), timeout, singleShot);
203 #if PLATFORM(IOS)
204     if (is<Document>(context)) {
205         bool didDeferTimeout = context.activeDOMObjectsAreSuspended();
206         if (!didDeferTimeout && timeout <= 100 && singleShot) {
207             WKSetObservedContentChange(WKContentIndeterminateChange);
208             WebThreadAddObservedContentModifier(timer); // Will only take affect if not already visibility change.
209         }
210     }
211 #endif
212
213     timer->suspendIfNeeded();
214     InspectorInstrumentation::didInstallTimer(&context, timer->m_timeoutId, timeout, singleShot);
215
216     // Keep track of nested timer installs.
217     if (NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context))
218         nestedTimers->add(timer->m_timeoutId, timer);
219
220     return timer->m_timeoutId;
221 }
222
223 void DOMTimer::removeById(ScriptExecutionContext& context, int timeoutId)
224 {
225     // timeout IDs have to be positive, and 0 and -1 are unsafe to
226     // even look up since they are the empty and deleted value
227     // respectively
228     if (timeoutId <= 0)
229         return;
230
231     if (NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context))
232         nestedTimers->remove(timeoutId);
233
234     InspectorInstrumentation::didRemoveTimer(&context, timeoutId);
235     context.removeTimeout(timeoutId);
236 }
237
238 inline bool DOMTimer::isDOMTimersThrottlingEnabled(Document& document) const
239 {
240     auto* page = document.page();
241     if (!page)
242         return true;
243     return page->settings().domTimersThrottlingEnabled();
244 }
245
246 void DOMTimer::updateThrottlingStateIfNecessary(const DOMTimerFireState& fireState)
247 {
248     Document* contextDocument = fireState.contextDocument();
249     // We don't throttle timers in worker threads.
250     if (!contextDocument)
251         return;
252
253     if (UNLIKELY(!isDOMTimersThrottlingEnabled(*contextDocument))) {
254         if (m_throttleState == ShouldThrottle) {
255             // Unthrottle the timer in case it was throttled before the setting was updated.
256             LOG(DOMTimers, "%p - Unthrottling DOM timer because throttling was disabled via settings.", this);
257             m_throttleState = ShouldNotThrottle;
258             updateTimerIntervalIfNecessary();
259         }
260         return;
261     }
262
263     if (fireState.scriptMadeUserObservableChanges()) {
264         if (m_throttleState != ShouldNotThrottle) {
265             m_throttleState = ShouldNotThrottle;
266             updateTimerIntervalIfNecessary();
267         }
268     } else if (fireState.scriptMadeNonUserObservableChanges()) {
269         if (m_throttleState != ShouldThrottle) {
270             m_throttleState = ShouldThrottle;
271             updateTimerIntervalIfNecessary();
272         }
273     }
274 }
275
276 void DOMTimer::scriptDidInteractWithPlugin(HTMLPlugInElement& pluginElement)
277 {
278     if (!DOMTimerFireState::current)
279         return;
280
281     if (pluginElement.isUserObservable())
282         DOMTimerFireState::current->setScriptMadeUserObservableChanges();
283     else
284         DOMTimerFireState::current->setScriptMadeNonUserObservableChanges();
285 }
286
287 void DOMTimer::fired()
288 {
289     // Retain this - if the timer is cancelled while this function is on the stack (implicitly and always
290     // for one-shot timers, or if removeById is called on itself from within an interval timer fire) then
291     // wait unit the end of this function to delete DOMTimer.
292     RefPtr<DOMTimer> reference = this;
293
294     ASSERT(scriptExecutionContext());
295     ScriptExecutionContext& context = *scriptExecutionContext();
296
297     DOMTimerFireState fireState(context);
298
299     context.setTimerNestingLevel(std::min(m_nestingLevel + 1, maxTimerNestingLevel));
300
301     ASSERT(!isSuspended());
302     ASSERT(!context.activeDOMObjectsAreSuspended());
303     UserGestureIndicator gestureIndicator(m_shouldForwardUserGesture ? DefinitelyProcessingUserGesture : PossiblyProcessingUserGesture);
304     // Only the first execution of a multi-shot timer should get an affirmative user gesture indicator.
305     m_shouldForwardUserGesture = false;
306
307     InspectorInstrumentationCookie cookie = InspectorInstrumentation::willFireTimer(&context, m_timeoutId);
308
309     // Simple case for non-one-shot timers.
310     if (isActive()) {
311         if (m_nestingLevel < maxTimerNestingLevel) {
312             m_nestingLevel++;
313             updateTimerIntervalIfNecessary();
314         }
315
316         m_action->execute(context);
317
318         InspectorInstrumentation::didFireTimer(cookie);
319         updateThrottlingStateIfNecessary(fireState);
320
321         return;
322     }
323
324     context.removeTimeout(m_timeoutId);
325
326 #if PLATFORM(IOS)
327     bool shouldReportLackOfChanges;
328     bool shouldBeginObservingChanges;
329     if (is<Document>(context)) {
330         shouldReportLackOfChanges = WebThreadCountOfObservedContentModifiers() == 1;
331         shouldBeginObservingChanges = WebThreadContainsObservedContentModifier(this);
332     } else {
333         shouldReportLackOfChanges = false;
334         shouldBeginObservingChanges = false;
335     }
336
337     if (shouldBeginObservingChanges) {
338         WKBeginObservingContentChanges(false);
339         WebThreadRemoveObservedContentModifier(this);
340     }
341 #endif
342
343     // Keep track nested timer installs.
344     NestedTimersMap* nestedTimers = NestedTimersMap::instanceForContext(context);
345     if (nestedTimers)
346         nestedTimers->startTracking();
347
348     m_action->execute(context);
349
350 #if PLATFORM(IOS)
351     if (shouldBeginObservingChanges) {
352         WKStopObservingContentChanges();
353
354         if (WKObservedContentChange() == WKContentVisibilityChange || shouldReportLackOfChanges) {
355             Document& document = downcast<Document>(context);
356             if (Page* page = document.page())
357                 page->chrome().client().observedContentChange(document.frame());
358         }
359     }
360 #endif
361
362     InspectorInstrumentation::didFireTimer(cookie);
363
364     // Check if we should throttle nested single-shot timers.
365     if (nestedTimers) {
366         for (auto& keyValue : *nestedTimers) {
367             auto* timer = keyValue.value;
368             if (timer->isActive() && !timer->repeatInterval())
369                 timer->updateThrottlingStateIfNecessary(fireState);
370         }
371         nestedTimers->stopTracking();
372     }
373
374     context.setTimerNestingLevel(0);
375 }
376
377 void DOMTimer::didStop()
378 {
379     // Need to release JS objects potentially protected by ScheduledAction
380     // because they can form circular references back to the ScriptExecutionContext
381     // which will cause a memory leak.
382     m_action = nullptr;
383 }
384
385 void DOMTimer::updateTimerIntervalIfNecessary()
386 {
387     ASSERT(m_nestingLevel <= maxTimerNestingLevel);
388
389     double previousInterval = m_currentTimerInterval;
390     m_currentTimerInterval = intervalClampedToMinimum();
391
392     if (WTF::areEssentiallyEqual(previousInterval, m_currentTimerInterval, oneMillisecond))
393         return;
394
395     if (repeatInterval()) {
396         ASSERT(WTF::areEssentiallyEqual(repeatInterval(), previousInterval, oneMillisecond));
397         LOG(DOMTimers, "%p - Updating DOMTimer's repeat interval from %g ms to %g ms due to throttling.", this, previousInterval * 1000., m_currentTimerInterval * 1000.);
398         augmentRepeatInterval(m_currentTimerInterval - previousInterval);
399     } else {
400         LOG(DOMTimers, "%p - Updating DOMTimer's fire interval from %g ms to %g ms due to throttling.", this, previousInterval * 1000., m_currentTimerInterval * 1000.);
401         augmentFireInterval(m_currentTimerInterval - previousInterval);
402     }
403 }
404
405 double DOMTimer::intervalClampedToMinimum() const
406 {
407     ASSERT(scriptExecutionContext());
408     ASSERT(m_nestingLevel <= maxTimerNestingLevel);
409
410     double intervalInSeconds = std::max(oneMillisecond, m_originalInterval * oneMillisecond);
411
412     // Only apply throttling to repeating timers.
413     if (m_nestingLevel < maxTimerNestingLevel)
414         return intervalInSeconds;
415
416     // Apply two throttles - the global (per Page) minimum, and also a per-timer throttle.
417     intervalInSeconds = std::max(intervalInSeconds, scriptExecutionContext()->minimumTimerInterval());
418     if (m_throttleState == ShouldThrottle)
419         intervalInSeconds = std::max(intervalInSeconds, minIntervalForNonUserObservableChangeTimers * oneMillisecond);
420     return intervalInSeconds;
421 }
422
423 double DOMTimer::alignedFireTime(double fireTime) const
424 {
425     if (double alignmentInterval = scriptExecutionContext()->timerAlignmentInterval(m_nestingLevel >= maxTimerNestingLevel))
426         return ceil(fireTime / alignmentInterval) * alignmentInterval;
427
428     return fireTime;
429 }
430
431 const char* DOMTimer::activeDOMObjectName() const
432 {
433     return "DOMTimer";
434 }
435
436 } // namespace WebCore