CTTE Timer and DeferrableOneShotTimer
[WebKit-https.git] / Source / WebCore / platform / Timer.h
1 /*
2  * Copyright (C) 2006 Apple Computer, 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 COMPUTER, 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 COMPUTER, 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 <wtf/Noncopyable.h>
30 #include <wtf/Threading.h>
31 #include <wtf/Vector.h>
32
33 #if PLATFORM(IOS)
34 #include "WebCoreThread.h"
35 #endif
36
37 namespace WebCore {
38
39 // Time intervals are all in seconds.
40
41 class TimerHeapElement;
42
43 class TimerBase {
44     WTF_MAKE_NONCOPYABLE(TimerBase);
45     WTF_FASTMALLOC_OPERATORS;
46 public:
47     TimerBase();
48     virtual ~TimerBase();
49
50     void start(double nextFireInterval, double repeatInterval);
51
52     void startRepeating(double repeatInterval) { start(repeatInterval, repeatInterval); }
53     void startOneShot(double interval) { start(interval, 0); }
54
55     void stop();
56     bool isActive() const;
57
58     double nextFireInterval() const;
59     double nextUnalignedFireInterval() const;
60     double repeatInterval() const { return m_repeatInterval; }
61
62     void augmentFireInterval(double delta) { setNextFireTime(m_nextFireTime + delta); }
63     void augmentRepeatInterval(double delta) { augmentFireInterval(delta); m_repeatInterval += delta; }
64
65     void didChangeAlignmentInterval();
66
67     static void fireTimersInNestedEventLoop();
68
69 private:
70     virtual void fired() = 0;
71
72     virtual double alignedFireTime(double fireTime) const { return fireTime; }
73
74     void checkConsistency() const;
75     void checkHeapIndex() const;
76
77     void setNextFireTime(double);
78
79     bool inHeap() const { return m_heapIndex != -1; }
80
81     bool hasValidHeapPosition() const;
82     void updateHeapIfNeeded(double oldTime);
83
84     void heapDecreaseKey();
85     void heapDelete();
86     void heapDeleteMin();
87     void heapIncreaseKey();
88     void heapInsert();
89     void heapPop();
90     void heapPopMin();
91
92     Vector<TimerBase*>& timerHeap() const { ASSERT(m_cachedThreadGlobalTimerHeap); return *m_cachedThreadGlobalTimerHeap; }
93
94     double m_nextFireTime; // 0 if inactive
95     double m_unalignedNextFireTime; // m_nextFireTime not considering alignment interval
96     double m_repeatInterval; // 0 if not repeating
97     int m_heapIndex; // -1 if not in heap
98     unsigned m_heapInsertionOrder; // Used to keep order among equal-fire-time timers
99     Vector<TimerBase*>* m_cachedThreadGlobalTimerHeap;
100
101 #ifndef NDEBUG
102     ThreadIdentifier m_thread;
103     bool m_wasDeleted;
104 #endif
105
106     friend class ThreadTimers;
107     friend class TimerHeapLessThanFunction;
108     friend class TimerHeapReference;
109 };
110
111 template <typename TimerFiredClass> class Timer : public TimerBase {
112 public:
113     typedef void (TimerFiredClass::*TimerFiredFunction)(Timer&);
114     typedef void (TimerFiredClass::*DeprecatedTimerFiredFunction)(Timer*);
115
116     Timer(TimerFiredClass* object, TimerFiredFunction function)
117         : m_object(object)
118         , m_deprecatedFunction(nullptr)
119         , m_function(function)
120     {
121     }
122
123     Timer(TimerFiredClass* object, DeprecatedTimerFiredFunction function)
124         : m_object(object)
125         , m_deprecatedFunction(function)
126         , m_function(nullptr)
127     {
128     }
129
130 private:
131     virtual void fired() OVERRIDE
132     {
133         if (m_deprecatedFunction) {
134             (m_object->*m_deprecatedFunction)(this);
135             return;
136         }
137
138         (m_object->*m_function)(*this);
139     }
140
141     TimerFiredClass* m_object;
142     DeprecatedTimerFiredFunction m_deprecatedFunction;
143     TimerFiredFunction m_function;
144 };
145
146 inline bool TimerBase::isActive() const
147 {
148     // FIXME: Write this in terms of USE(WEB_THREAD) instead of PLATFORM(IOS).
149 #if !PLATFORM(IOS)
150     ASSERT(m_thread == currentThread());
151 #else
152     // On iOS timers are always run on the main thread or the Web Thread.
153     // Unless we have workers enabled in which case timers can run on other threads.
154 #if ENABLE(WORKERS)
155     ASSERT(WebThreadIsCurrent() || pthread_main_np() || m_thread == currentThread());
156 #else
157     ASSERT(WebThreadIsCurrent() || pthread_main_np());
158 #endif
159 #endif // PLATFORM(IOS)
160     return m_nextFireTime;
161 }
162
163 template <typename TimerFiredClass> class DeferrableOneShotTimer : protected TimerBase {
164 public:
165     typedef void (TimerFiredClass::*TimerFiredFunction)(DeferrableOneShotTimer&);
166     typedef void (TimerFiredClass::*DeprecatedTimerFiredFunction)(DeferrableOneShotTimer*);
167
168     DeferrableOneShotTimer(TimerFiredClass* object, TimerFiredFunction function, double delay)
169         : m_object(object)
170         , m_function(function)
171         , m_deprecatedFunction(nullptr)
172         , m_delay(delay)
173         , m_shouldRestartWhenTimerFires(false)
174     {
175     }
176
177     DeferrableOneShotTimer(TimerFiredClass* object, DeprecatedTimerFiredFunction function, double delay)
178         : m_object(object)
179         , m_function(nullptr)
180         , m_deprecatedFunction(function)
181         , m_delay(delay)
182         , m_shouldRestartWhenTimerFires(false)
183     {
184     }
185
186     void restart()
187     {
188         // Setting this boolean is much more efficient than calling startOneShot
189         // again, which might result in rescheduling the system timer which
190         // can be quite expensive.
191
192         if (isActive()) {
193             m_shouldRestartWhenTimerFires = true;
194             return;
195         }
196         startOneShot(m_delay);
197     }
198
199     void stop()
200     {
201         m_shouldRestartWhenTimerFires = false;
202         TimerBase::stop();
203     }
204
205     using TimerBase::isActive;
206
207 private:
208     virtual void fired() OVERRIDE
209     {
210         if (m_shouldRestartWhenTimerFires) {
211             m_shouldRestartWhenTimerFires = false;
212             startOneShot(m_delay);
213             return;
214         }
215
216         if (m_deprecatedFunction) {
217             (m_object->*m_deprecatedFunction)(this);
218             return;
219         }
220
221         (m_object->*m_function)(*this);
222     }
223
224     TimerFiredClass* m_object;
225     TimerFiredFunction m_function;
226     DeprecatedTimerFiredFunction m_deprecatedFunction;
227
228     double m_delay;
229     bool m_shouldRestartWhenTimerFires;
230 };
231
232 }
233
234 #endif