Video sometimes flickers when playing to AppleTV
[WebKit-https.git] / Source / WebCore / platform / Timer.h
1 /*
2  * Copyright (C) 2006 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 #pragma once
27
28 #include <functional>
29 #include <wtf/Function.h>
30 #include <wtf/MonotonicTime.h>
31 #include <wtf/Noncopyable.h>
32 #include <wtf/Optional.h>
33 #include <wtf/Seconds.h>
34 #include <wtf/Threading.h>
35 #include <wtf/Vector.h>
36
37 #if PLATFORM(IOS)
38 #include "WebCoreThread.h"
39 #endif
40
41 namespace WebCore {
42
43 // Time intervals are all in seconds.
44
45 class TimerHeapElement;
46
47 class TimerBase {
48     WTF_MAKE_NONCOPYABLE(TimerBase);
49     WTF_MAKE_FAST_ALLOCATED;
50 public:
51     WEBCORE_EXPORT TimerBase();
52     WEBCORE_EXPORT virtual ~TimerBase();
53
54     WEBCORE_EXPORT void start(Seconds nextFireInterval, Seconds repeatInterval);
55
56     void startRepeating(Seconds repeatInterval) { start(repeatInterval, repeatInterval); }
57     void startOneShot(Seconds interval) { start(interval, 0_s); }
58
59     WEBCORE_EXPORT void stop();
60     bool isActive() const;
61
62     Seconds nextFireInterval() const;
63     Seconds nextUnalignedFireInterval() const;
64     Seconds repeatInterval() const { return m_repeatInterval; }
65
66     void augmentFireInterval(Seconds delta) { setNextFireTime(m_nextFireTime + delta); }
67     void augmentRepeatInterval(Seconds delta) { augmentFireInterval(delta); m_repeatInterval += delta; }
68
69     void didChangeAlignmentInterval();
70
71     static void fireTimersInNestedEventLoop();
72
73 private:
74     virtual void fired() = 0;
75
76     virtual std::optional<MonotonicTime> alignedFireTime(MonotonicTime) const { return std::nullopt; }
77
78     void checkConsistency() const;
79     void checkHeapIndex() const;
80
81     void setNextFireTime(MonotonicTime);
82
83     bool inHeap() const { return m_heapIndex != -1; }
84
85     bool hasValidHeapPosition() const;
86     void updateHeapIfNeeded(MonotonicTime oldTime);
87
88     void heapDecreaseKey();
89     void heapDelete();
90     void heapDeleteMin();
91     void heapIncreaseKey();
92     void heapInsert();
93     void heapPop();
94     void heapPopMin();
95
96     Vector<TimerBase*>& timerHeap() const { ASSERT(m_cachedThreadGlobalTimerHeap); return *m_cachedThreadGlobalTimerHeap; }
97
98     MonotonicTime m_nextFireTime; // 0 if inactive
99     MonotonicTime m_unalignedNextFireTime; // m_nextFireTime not considering alignment interval
100     Seconds m_repeatInterval; // 0 if not repeating
101     int m_heapIndex { -1 }; // -1 if not in heap
102     unsigned m_heapInsertionOrder; // Used to keep order among equal-fire-time timers
103     bool m_wasDeleted { false };
104     Vector<TimerBase*>* m_cachedThreadGlobalTimerHeap { nullptr };
105
106     Ref<Thread> m_thread { Thread::current() };
107
108     friend class ThreadTimers;
109     friend class TimerHeapLessThanFunction;
110     friend class TimerHeapReference;
111 };
112
113
114 class Timer : public TimerBase {
115     WTF_MAKE_FAST_ALLOCATED;
116 public:
117     template <typename TimerFiredClass, typename TimerFiredBaseClass>
118     Timer(TimerFiredClass& object, void (TimerFiredBaseClass::*function)())
119         : m_function(std::bind(function, &object))
120     {
121     }
122
123     Timer(WTF::Function<void ()>&& function)
124         : m_function(WTFMove(function))
125     {
126     }
127
128 private:
129     void fired() override
130     {
131         m_function();
132     }
133     
134     WTF::Function<void ()> m_function;
135 };
136
137 inline bool TimerBase::isActive() const
138 {
139     // FIXME: Write this in terms of USE(WEB_THREAD) instead of PLATFORM(IOS).
140 #if !PLATFORM(IOS)
141     ASSERT(m_thread.ptr() == &Thread::current());
142 #else
143     ASSERT(WebThreadIsCurrent() || pthread_main_np() || m_thread.ptr() == &Thread::current());
144 #endif // PLATFORM(IOS)
145     return static_cast<bool>(m_nextFireTime);
146 }
147
148 class DeferrableOneShotTimer : protected TimerBase {
149     WTF_MAKE_FAST_ALLOCATED;
150 public:
151     template<typename TimerFiredClass>
152     DeferrableOneShotTimer(TimerFiredClass& object, void (TimerFiredClass::*function)(), Seconds delay)
153         : DeferrableOneShotTimer(std::bind(function, &object), delay)
154     {
155     }
156
157     DeferrableOneShotTimer(WTF::Function<void ()>&& function, Seconds delay)
158         : m_function(WTFMove(function))
159         , m_delay(delay)
160         , m_shouldRestartWhenTimerFires(false)
161     {
162     }
163
164     void restart()
165     {
166         // Setting this boolean is much more efficient than calling startOneShot
167         // again, which might result in rescheduling the system timer which
168         // can be quite expensive.
169
170         if (isActive()) {
171             m_shouldRestartWhenTimerFires = true;
172             return;
173         }
174         startOneShot(m_delay);
175     }
176
177     void stop()
178     {
179         m_shouldRestartWhenTimerFires = false;
180         TimerBase::stop();
181     }
182
183     using TimerBase::isActive;
184
185 private:
186     void fired() override
187     {
188         if (m_shouldRestartWhenTimerFires) {
189             m_shouldRestartWhenTimerFires = false;
190             startOneShot(m_delay);
191             return;
192         }
193
194         m_function();
195     }
196
197     WTF::Function<void ()> m_function;
198
199     Seconds m_delay;
200     bool m_shouldRestartWhenTimerFires;
201 };
202
203 }