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