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