mstask: Actually run a test and fix the expected behaviour.
[wine] / dlls / mshtml / task.c
1 /*
2  * Copyright 2006 Jacek Caban for CodeWeavers
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This library is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with this library; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17  */
18
19 #include "config.h"
20
21 #include <stdarg.h>
22 #include <stdio.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "ole2.h"
30
31 #include "wine/debug.h"
32
33 #include "mshtml_private.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(mshtml);
36
37 #define WM_PROCESSTASK 0x8008
38 #define TIMER_ID 0x3000
39
40 typedef struct {
41     HTMLDocument *doc;
42     DWORD id;
43     DWORD time;
44     DWORD interval;
45     IDispatch *disp;
46
47     struct list entry;
48 } task_timer_t;
49
50 static void default_task_destr(task_t *task)
51 {
52     heap_free(task);
53 }
54
55 void push_task(task_t *task, task_proc_t proc, task_proc_t destr, LONG magic)
56 {
57     thread_data_t *thread_data = get_thread_data(TRUE);
58
59     task->target_magic = magic;
60     task->proc = proc;
61     task->destr = destr ? destr : default_task_destr;
62     task->next = NULL;
63
64     if(thread_data->task_queue_tail)
65         thread_data->task_queue_tail->next = task;
66     else
67         thread_data->task_queue_head = task;
68
69     thread_data->task_queue_tail = task;
70
71     PostMessageW(thread_data->thread_hwnd, WM_PROCESSTASK, 0, 0);
72 }
73
74 static task_t *pop_task(void)
75 {
76     thread_data_t *thread_data = get_thread_data(TRUE);
77     task_t *task = thread_data->task_queue_head;
78
79     if(!task)
80         return NULL;
81
82     thread_data->task_queue_head = task->next;
83     if(!thread_data->task_queue_head)
84         thread_data->task_queue_tail = NULL;
85
86     return task;
87 }
88
89 static void release_task_timer(HWND thread_hwnd, task_timer_t *timer)
90 {
91     list_remove(&timer->entry);
92
93     IDispatch_Release(timer->disp);
94
95     heap_free(timer);
96 }
97
98 void remove_target_tasks(LONG target)
99 {
100     thread_data_t *thread_data = get_thread_data(FALSE);
101     struct list *liter, *ltmp;
102     task_timer_t *timer;
103     task_t *iter, *tmp;
104
105     if(!thread_data)
106         return;
107
108     LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->timer_list) {
109         timer = LIST_ENTRY(liter, task_timer_t, entry);
110         if(timer->doc->task_magic == target)
111             release_task_timer(thread_data->thread_hwnd, timer);
112     }
113
114     if(!list_empty(&thread_data->timer_list)) {
115         timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
116         SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time - GetTickCount(), NULL);
117     }
118
119     while(thread_data->task_queue_head && thread_data->task_queue_head->target_magic == target) {
120         iter = pop_task();
121         iter->destr(iter);
122     }
123
124     for(iter = thread_data->task_queue_head; iter; iter = iter->next) {
125         while(iter->next && iter->next->target_magic == target) {
126             tmp = iter->next;
127             iter->next = tmp->next;
128             tmp->destr(tmp);
129         }
130
131         if(!iter->next)
132             thread_data->task_queue_tail = iter;
133     }
134 }
135
136 LONG get_task_target_magic(void)
137 {
138     static LONG magic = 0x10000000;
139     return InterlockedIncrement(&magic);
140 }
141
142 static BOOL queue_timer(thread_data_t *thread_data, task_timer_t *timer)
143 {
144     task_timer_t *iter;
145
146     list_remove(&timer->entry);
147
148     if(list_empty(&thread_data->timer_list)
149        || LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry)->time > timer->time) {
150
151         list_add_head(&thread_data->timer_list, &timer->entry);
152         return TRUE;
153     }
154
155     LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
156         if(iter->time > timer->time) {
157             list_add_tail(&iter->entry, &timer->entry);
158             return FALSE;
159         }
160     }
161
162     list_add_tail(&thread_data->timer_list, &timer->entry);
163     return FALSE;
164 }
165
166 DWORD set_task_timer(HTMLDocument *doc, DWORD msec, BOOL interval, IDispatch *disp)
167 {
168     thread_data_t *thread_data = get_thread_data(TRUE);
169     task_timer_t *timer;
170     DWORD tc = GetTickCount();
171
172     static DWORD id_cnt = 0x20000000;
173
174     timer = heap_alloc(sizeof(task_timer_t));
175     timer->id = id_cnt++;
176     timer->doc = doc;
177     timer->time = tc + msec;
178     timer->interval = interval ? msec : 0;
179     list_init(&timer->entry);
180
181     IDispatch_AddRef(disp);
182     timer->disp = disp;
183
184     if(queue_timer(thread_data, timer))
185         SetTimer(thread_data->thread_hwnd, TIMER_ID, msec, NULL);
186
187     return timer->id;
188 }
189
190 HRESULT clear_task_timer(HTMLDocument *doc, BOOL interval, DWORD id)
191 {
192     thread_data_t *thread_data = get_thread_data(FALSE);
193     task_timer_t *iter;
194
195     if(!thread_data)
196         return S_OK;
197
198     LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
199         if(iter->id == id && iter->doc == doc && (iter->interval == 0) == !interval) {
200             release_task_timer(thread_data->thread_hwnd, iter);
201             return S_OK;
202         }
203     }
204
205     WARN("timet not found\n");
206     return S_OK;
207 }
208
209 static void call_timer_disp(IDispatch *disp)
210 {
211     DISPPARAMS dp = {NULL, NULL, 0, 0};
212     EXCEPINFO ei;
213     VARIANT res;
214     HRESULT hres;
215
216     V_VT(&res) = VT_EMPTY;
217     memset(&ei, 0, sizeof(ei));
218
219     TRACE(">>>\n");
220     hres = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
221     if(hres == S_OK)
222         TRACE("<<<\n");
223     else
224         WARN("<<< %08x\n", hres);
225
226     VariantClear(&res);
227 }
228
229 static LRESULT process_timer(void)
230 {
231     thread_data_t *thread_data = get_thread_data(TRUE);
232     IDispatch *disp;
233     DWORD tc;
234     task_timer_t *timer;
235
236     TRACE("\n");
237
238     while(!list_empty(&thread_data->timer_list)) {
239         timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
240
241         tc = GetTickCount();
242         if(timer->time > tc) {
243             SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time-tc, NULL);
244             return 0;
245         }
246
247         disp = timer->disp;
248         IDispatch_AddRef(disp);
249
250         if(timer->interval) {
251             timer->time += timer->interval;
252             queue_timer(thread_data, timer);
253         }else {
254             release_task_timer(thread_data->thread_hwnd, timer);
255         }
256
257         call_timer_disp(disp);
258
259         IDispatch_Release(disp);
260     }
261
262     KillTimer(thread_data->thread_hwnd, TIMER_ID);
263     return 0;
264 }
265
266 static LRESULT WINAPI hidden_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
267 {
268     switch(msg) {
269     case WM_PROCESSTASK:
270         while(1) {
271             task_t *task = pop_task();
272             if(!task)
273                 break;
274
275             task->proc(task);
276             task->destr(task);
277         }
278
279         return 0;
280     case WM_TIMER:
281         return process_timer();
282     }
283
284     if(msg > WM_USER)
285         FIXME("(%p %d %lx %lx)\n", hwnd, msg, wParam, lParam);
286
287     return DefWindowProcW(hwnd, msg, wParam, lParam);
288 }
289
290 static HWND create_thread_hwnd(void)
291 {
292     static ATOM hidden_wnd_class = 0;
293     static const WCHAR wszInternetExplorer_Hidden[] = {'I','n','t','e','r','n','e','t',
294             ' ','E','x','p','l','o','r','e','r','_','H','i','d','d','e','n',0};
295
296     if(!hidden_wnd_class) {
297         WNDCLASSEXW wndclass = {
298             sizeof(WNDCLASSEXW), 0,
299             hidden_proc,
300             0, 0, hInst, NULL, NULL, NULL, NULL,
301             wszInternetExplorer_Hidden,
302             NULL
303         };
304
305         hidden_wnd_class = RegisterClassExW(&wndclass);
306     }
307
308     return CreateWindowExW(0, wszInternetExplorer_Hidden, NULL, WS_POPUP,
309                            0, 0, 0, 0, NULL, NULL, hInst, NULL);
310 }
311
312 HWND get_thread_hwnd(void)
313 {
314     thread_data_t *thread_data = get_thread_data(TRUE);
315
316     if(!thread_data->thread_hwnd)
317         thread_data->thread_hwnd = create_thread_hwnd();
318
319     return thread_data->thread_hwnd;
320 }
321
322 thread_data_t *get_thread_data(BOOL create)
323 {
324     thread_data_t *thread_data;
325
326     if(mshtml_tls == TLS_OUT_OF_INDEXES) {
327         DWORD tls;
328
329         if(!create)
330             return NULL;
331
332         tls = TlsAlloc();
333         if(tls == TLS_OUT_OF_INDEXES)
334             return NULL;
335
336         tls = InterlockedCompareExchange((LONG*)&mshtml_tls, tls, TLS_OUT_OF_INDEXES);
337         if(tls != mshtml_tls)
338             TlsFree(tls);
339     }
340
341     thread_data = TlsGetValue(mshtml_tls);
342     if(!thread_data && create) {
343         thread_data = heap_alloc_zero(sizeof(thread_data_t));
344         TlsSetValue(mshtml_tls, thread_data);
345         list_init(&thread_data->timer_list);
346     }
347
348     return thread_data;
349 }