[WTF] Move currentCPUTime and sleep(Seconds) to CPUTime.h and Seconds.h respectively
[WebKit-https.git] / Source / WTF / wtf / win / RunLoopWin.cpp
1 /*
2  * Copyright (C) 2010 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. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "RunLoop.h"
28
29 #include <wtf/WindowsExtras.h>
30
31 namespace WTF {
32
33 static const UINT PerformWorkMessage = WM_USER + 1;
34 static const LPWSTR kRunLoopMessageWindowClassName = L"RunLoopMessageWindow";
35
36 LRESULT CALLBACK RunLoop::RunLoopWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
37 {
38     if (RunLoop* runLoop = static_cast<RunLoop*>(getWindowPointer(hWnd, 0)))
39         return runLoop->wndProc(hWnd, message, wParam, lParam);
40
41     if (message == WM_CREATE) {
42         LPCREATESTRUCT createStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
43
44         // Associate the RunLoop with the window.
45         setWindowPointer(hWnd, 0, createStruct->lpCreateParams);
46         return 0;
47     }
48
49     return ::DefWindowProc(hWnd, message, wParam, lParam);
50 }
51
52 LRESULT RunLoop::wndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
53 {
54     switch (message) {
55     case PerformWorkMessage:
56         performWork();
57         return 0;
58     case WM_TIMER:
59         RunLoop::TimerBase::timerFired(this, wParam);
60         return 0;
61     }
62
63     return ::DefWindowProc(hWnd, message, wParam, lParam);
64 }
65
66 void RunLoop::run()
67 {
68     MSG message;
69     while (BOOL result = ::GetMessage(&message, 0, 0, 0)) {
70         if (result == -1)
71             break;
72         ::TranslateMessage(&message);
73         ::DispatchMessage(&message);
74     }
75 }
76
77 void RunLoop::stop()
78 {
79     ::PostQuitMessage(0);
80 }
81
82 bool RunLoop::registerRunLoopMessageWindowClass()
83 {
84     // FIXME: This really only needs to be called once.
85
86     WNDCLASS windowClass = { 0 };
87     windowClass.lpfnWndProc     = RunLoop::RunLoopWndProc;
88     windowClass.cbWndExtra      = sizeof(RunLoop*);
89     windowClass.lpszClassName   = kRunLoopMessageWindowClassName;
90
91     return !!::RegisterClass(&windowClass);
92 }
93
94 RunLoop::RunLoop()
95 {
96     registerRunLoopMessageWindowClass();
97
98     m_runLoopMessageWindow = ::CreateWindow(kRunLoopMessageWindowClassName, 0, 0,
99         CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, HWND_MESSAGE, 0, 0, this);
100     ASSERT(::IsWindow(m_runLoopMessageWindow));
101 }
102
103 RunLoop::~RunLoop()
104 {
105     // FIXME: Tear down the work item queue here.
106 }
107
108 void RunLoop::wakeUp()
109 {
110     // FIXME: No need to wake up the run loop if we've already called dispatch
111     // before the run loop has had the time to respond.
112     ::PostMessage(m_runLoopMessageWindow, PerformWorkMessage, reinterpret_cast<WPARAM>(this), 0);
113 }
114
115 // RunLoop::Timer
116
117 void RunLoop::TimerBase::timerFired(RunLoop* runLoop, uint64_t ID)
118 {
119     TimerBase* timer = nullptr;
120     {
121         LockHolder locker(runLoop->m_activeTimersLock);
122         TimerMap::iterator it = runLoop->m_activeTimers.find(ID);
123         if (it == runLoop->m_activeTimers.end()) {
124             // The timer must have been stopped after the WM_TIMER message was posted to the message queue.
125             return;
126         }
127
128         timer = it->value;
129
130         if (!timer->m_isRepeating) {
131             runLoop->m_activeTimers.remove(it);
132             ::KillTimer(runLoop->m_runLoopMessageWindow, ID);
133         } else
134             timer->m_nextFireDate = MonotonicTime::now() + timer->m_interval;
135     }
136
137     timer->fired();
138 }
139
140 static uint64_t generateTimerID()
141 {
142     static uint64_t uniqueTimerID = 1;
143     return uniqueTimerID++;
144 }
145
146 RunLoop::TimerBase::TimerBase(RunLoop& runLoop)
147     : m_runLoop(runLoop)
148     , m_ID(generateTimerID())
149     , m_isRepeating(false)
150 {
151 }
152
153 RunLoop::TimerBase::~TimerBase()
154 {
155     stop();
156 }
157
158 void RunLoop::TimerBase::start(Seconds nextFireInterval, bool repeat)
159 {
160     LockHolder locker(m_runLoop->m_activeTimersLock);
161     m_isRepeating = repeat;
162     m_runLoop->m_activeTimers.set(m_ID, this);
163     m_interval = nextFireInterval;
164     m_nextFireDate = MonotonicTime::now() + m_interval;
165     ::SetTimer(m_runLoop->m_runLoopMessageWindow, m_ID, nextFireInterval.millisecondsAs<unsigned>(), 0);
166 }
167
168 void RunLoop::TimerBase::stop()
169 {
170     LockHolder locker(m_runLoop->m_activeTimersLock);
171     TimerMap::iterator it = m_runLoop->m_activeTimers.find(m_ID);
172     if (it == m_runLoop->m_activeTimers.end())
173         return;
174
175     m_runLoop->m_activeTimers.remove(it);
176     ::KillTimer(m_runLoop->m_runLoopMessageWindow, m_ID);
177 }
178
179 bool RunLoop::TimerBase::isActive(const AbstractLocker&) const
180 {
181     return m_runLoop->m_activeTimers.contains(m_ID);
182 }
183
184 bool RunLoop::TimerBase::isActive() const
185 {
186     LockHolder locker(m_runLoop->m_activeTimersLock);
187     return isActive(locker);
188 }
189
190 Seconds RunLoop::TimerBase::secondsUntilFire() const
191 {
192     LockHolder locker(m_runLoop->m_activeTimersLock);
193     if (isActive(locker))
194         return std::max<Seconds>(m_nextFireDate - MonotonicTime::now(), 0_s);
195     return 0_s;
196 }
197
198
199 } // namespace WTF