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