task.c File Reference

#include "mshtml_private.h"

Include dependency graph for task.c:

Go to the source code of this file.

Classes
struct	task_timer_t

Macros
#define	WM_PROCESSTASK   0x8008
#define	TIMER_ID   0x3000

Functions
static void	default_task_destr (task_t *task)
HRESULT	push_task (task_t *task, task_proc_t proc, task_proc_t destr, LONG magic)
static task_t *	pop_task (void)
static void	release_task_timer (HWND thread_hwnd, task_timer_t *timer)
void	flush_pending_tasks (LONG target)
void	remove_target_tasks (LONG target)
LONG	get_task_target_magic (void)
static BOOL	queue_timer (thread_data_t *thread_data, task_timer_t *timer)
HRESULT	set_task_timer (HTMLInnerWindow *window, DWORD msec, BOOL interval, IDispatch *disp, LONG *id)
HRESULT	clear_task_timer (HTMLInnerWindow *window, BOOL interval, DWORD id)
static void	call_timer_disp (IDispatch *disp)
static LRESULT	process_timer (void)
static LRESULT WINAPI	hidden_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
static HWND	create_thread_hwnd (void)
HWND	get_thread_hwnd (void)
thread_data_t *	get_thread_data (BOOL create)

Macro Definition Documentation

TIMER_ID

#define TIMER_ID   0x3000

Definition at line 22 of file task.c.

WM_PROCESSTASK

#define WM_PROCESSTASK   0x8008

Definition at line 21 of file task.c.

Function Documentation

call_timer_disp()

static void call_timer_disp ( IDispatch *  disp )

static

Definition at line 220 of file task.c.

{
    DISPPARAMS dp = {NULL, NULL, 0, 0};
    EXCEPINFO ei;
    VARIANT res;
    HRESULT hres;
 
    V_VT(&res) = VT_EMPTY;
    memset(&ei, 0, sizeof(ei));
 
    TRACE(">>>\n");
    hres = IDispatch_Invoke(disp, DISPID_VALUE, &IID_NULL, 0, DISPATCH_METHOD, &dp, &res, &ei, NULL);
    if(hres == S_OK)
        TRACE("<<<\n");
    else
        WARN("<<< %08x\n", hres);
 
    VariantClear(&res);
}

Referenced by process_timer().

clear_task_timer()

HRESULT clear_task_timer	(	HTMLInnerWindow *	window,
		BOOL	interval,
		DWORD	id
	)

Definition at line 201 of file task.c.

{
    thread_data_t *thread_data = get_thread_data(FALSE);
    task_timer_t *iter;
 
    if(!thread_data)
        return S_OK;
 
    LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
        if(iter->id == id && iter->window == window && !iter->interval == !interval) {
            release_task_timer(thread_data->thread_hwnd, iter);
            return S_OK;
        }
    }
 
    WARN("timet not found\n");
    return S_OK;
}

Referenced by HTMLWindow2_clearInterval(), and HTMLWindow2_clearTimeout().

create_thread_hwnd()

static HWND create_thread_hwnd ( void  )

static

Definition at line 316 of file task.c.

{
    static ATOM hidden_wnd_class = 0;
    static const WCHAR wszInternetExplorer_Hidden[] = {'I','n','t','e','r','n','e','t',
            ' ','E','x','p','l','o','r','e','r','_','H','i','d','d','e','n',0};
 
    if(!hidden_wnd_class) {
        WNDCLASSEXW wndclass = {
            sizeof(WNDCLASSEXW), 0,
            hidden_proc,
            0, 0, hInst, NULL, NULL, NULL, NULL,
            wszInternetExplorer_Hidden,
            NULL
        };
 
        hidden_wnd_class = RegisterClassExW(&wndclass);
    }
 
    return CreateWindowExW(0, wszInternetExplorer_Hidden, NULL, WS_POPUP,
                           0, 0, 0, 0, NULL, NULL, hInst, NULL);
}

Referenced by get_thread_hwnd().

default_task_destr()

static void default_task_destr ( task_t *  task )

static

Definition at line 34 of file task.c.

{
    heap_free(task);
}

Referenced by push_task().

flush_pending_tasks()

void flush_pending_tasks

(

LONG

target

)

Definition at line 88 of file task.c.

{
    thread_data_t *thread_data = get_thread_data(FALSE);
    struct list *liter, *ltmp;
    task_t *task;
 
    if(!thread_data)
        return;
 
    LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->task_list) {
        task = LIST_ENTRY(liter, task_t, entry);
        if(task->target_magic == target) {
            list_remove(&task->entry);
            task->proc(task);
            task->destr(task);
        }
    }
}

Referenced by handle_load().

get_task_target_magic()

LONG get_task_target_magic

(

void

)

Definition at line 139 of file task.c.

{
    static LONG magic = 0x10000000;
    return InterlockedIncrement(&magic);
}

Referenced by create_inner_window(), HTMLOuterWindow_Create(), and init_doc().

get_thread_data()

thread_data_t * get_thread_data

(

BOOL

create

)

Definition at line 352 of file task.c.

{
    thread_data_t *thread_data;
 
    if(mshtml_tls == TLS_OUT_OF_INDEXES) {
        DWORD tls;
 
        if(!create)
            return NULL;
 
        tls = TlsAlloc();
        if(tls == TLS_OUT_OF_INDEXES)
            return NULL;
 
        tls = InterlockedCompareExchange((LONG*)&mshtml_tls, tls, TLS_OUT_OF_INDEXES);
        if(tls != mshtml_tls)
            TlsFree(tls);
    }
 
    thread_data = TlsGetValue(mshtml_tls);
    if(!thread_data && create) {
        thread_data = heap_alloc_zero(sizeof(thread_data_t));
        if(!thread_data)
            return NULL;
 
        TlsSetValue(mshtml_tls, thread_data);
        list_init(&thread_data->task_list);
        list_init(&thread_data->timer_list);
    }
 
    return thread_data;
}

Referenced by clear_task_timer(), flush_pending_tasks(), get_thread_hwnd(), pop_task(), process_timer(), push_task(), remove_target_tasks(), set_task_timer(), and thread_detach().

get_thread_hwnd()

HWND get_thread_hwnd

(

void

)

Definition at line 338 of file task.c.

{
    thread_data_t *thread_data;
 
    thread_data = get_thread_data(TRUE);
    if(!thread_data)
        return NULL;
 
    if(!thread_data->thread_hwnd)
        thread_data->thread_hwnd = create_thread_hwnd();
 
    return thread_data->thread_hwnd;
}

Referenced by HTMLDocument_Create().

hidden_proc()

static LRESULT WINAPI hidden_proc ( HWND  hwnd, UINT  msg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 292 of file task.c.

{
    switch(msg) {
    case WM_PROCESSTASK:
        while(1) {
            task_t *task = pop_task();
            if(!task)
                break;
 
            task->proc(task);
            task->destr(task);
        }
 
        return 0;
    case WM_TIMER:
        return process_timer();
    }
 
    if(msg > WM_USER)
        FIXME("(%p %d %lx %lx)\n", hwnd, msg, wParam, lParam);
 
    return DefWindowProcW(hwnd, msg, wParam, lParam);
}

Referenced by create_thread_hwnd().

pop_task()

static task_t * pop_task ( void  )

static

Definition at line 62 of file task.c.

{
    thread_data_t *thread_data;
    task_t *task;
 
    thread_data = get_thread_data(FALSE);
    if(!thread_data)
        return NULL;
 
    if(list_empty(&thread_data->task_list))
        return NULL;
 
    task = LIST_ENTRY(thread_data->task_list.next, task_t, entry);
    list_remove(&task->entry);
    return task;
}

Referenced by hidden_proc().

process_timer()

static LRESULT process_timer ( void  )

static

Definition at line 240 of file task.c.

{
    thread_data_t *thread_data;
    IDispatch *disp;
    DWORD tc;
    task_timer_t *timer=NULL, *last_timer;
 
    TRACE("\n");
 
    thread_data = get_thread_data(FALSE);
    assert(thread_data != NULL);
 
    if(list_empty(&thread_data->timer_list)) {
        KillTimer(thread_data->thread_hwnd, TIMER_ID);
        return 0;
    }
 
    last_timer = LIST_ENTRY(list_tail(&thread_data->timer_list), task_timer_t, entry);
    do {
        tc = GetTickCount();
        if(timer == last_timer) {
            timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
            SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time>tc ? timer->time-tc : 0, NULL);
            return 0;
        }
 
        timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
 
        if(timer->time > tc) {
            SetTimer(thread_data->thread_hwnd, TIMER_ID, timer->time-tc, NULL);
            return 0;
        }
 
        disp = timer->disp;
        IDispatch_AddRef(disp);
 
        if(timer->interval) {
            timer->time += timer->interval;
            queue_timer(thread_data, timer);
        }else {
            release_task_timer(thread_data->thread_hwnd, timer);
        }
 
        call_timer_disp(disp);
 
        IDispatch_Release(disp);
    }while(!list_empty(&thread_data->timer_list));
 
    KillTimer(thread_data->thread_hwnd, TIMER_ID);
    return 0;
}

Referenced by hidden_proc().

push_task()

HRESULT push_task	(	task_t *	task,
		task_proc_t	proc,
		task_proc_t	destr,
		LONG	magic
	)

Definition at line 39 of file task.c.

{
    thread_data_t *thread_data;
 
    thread_data = get_thread_data(TRUE);
    if(!thread_data) {
        if(destr)
            destr(task);
        else
            heap_free(task);
        return E_OUTOFMEMORY;
    }
 
    task->target_magic = magic;
    task->proc = proc;
    task->destr = destr ? destr : default_task_destr;
 
    list_add_tail(&thread_data->task_list, &task->entry);
 
    PostMessageW(thread_data->thread_hwnd, WM_PROCESSTASK, 0, 0);
    return S_OK;
}

Referenced by async_open(), async_start_doc_binding(), async_stop_request(), exec_refresh(), set_moniker(), set_ready_state(), set_script_elem_readystate(), and super_navigate().

queue_timer()

static BOOL queue_timer ( thread_data_t *  thread_data, task_timer_t *  timer  )

static

Definition at line 145 of file task.c.

{
    task_timer_t *iter;
 
    list_remove(&timer->entry);
 
    if(list_empty(&thread_data->timer_list)
       || LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry)->time > timer->time) {
 
        list_add_head(&thread_data->timer_list, &timer->entry);
        return TRUE;
    }
 
    LIST_FOR_EACH_ENTRY(iter, &thread_data->timer_list, task_timer_t, entry) {
        if(iter->time > timer->time) {
            list_add_tail(&iter->entry, &timer->entry);
            return FALSE;
        }
    }
 
    list_add_tail(&thread_data->timer_list, &timer->entry);
    return FALSE;
}

release_task_timer()

static void release_task_timer ( HWND  thread_hwnd, task_timer_t *  timer  )

static

Definition at line 79 of file task.c.

{
    list_remove(&timer->entry);
 
    IDispatch_Release(timer->disp);
 
    heap_free(timer);
}

Referenced by clear_task_timer(), process_timer(), and remove_target_tasks().

remove_target_tasks()

void remove_target_tasks

(

LONG

target

)

Definition at line 107 of file task.c.

{
    thread_data_t *thread_data = get_thread_data(FALSE);
    struct list *liter, *ltmp;
    task_timer_t *timer;
    task_t *task;
 
    if(!thread_data)
        return;
 
    LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->timer_list) {
        timer = LIST_ENTRY(liter, task_timer_t, entry);
        if(timer->window->task_magic == target)
            release_task_timer(thread_data->thread_hwnd, timer);
    }
 
    if(!list_empty(&thread_data->timer_list)) {
        DWORD tc = GetTickCount();
 
        timer = LIST_ENTRY(list_head(&thread_data->timer_list), task_timer_t, entry);
        SetTimer(thread_data->thread_hwnd, TIMER_ID, max( (int)(timer->time - tc), 0 ), NULL);
    }
 
    LIST_FOR_EACH_SAFE(liter, ltmp, &thread_data->task_list) {
        task = LIST_ENTRY(liter, task_t, entry);
        if(task->target_magic == target) {
            list_remove(&task->entry);
            task->destr(task);
        }
    }
}

Referenced by abort_window_bindings(), destroy_htmldoc(), detach_inner_window(), release_outer_window(), set_moniker(), and setup_edit_mode().

set_task_timer()

HRESULT set_task_timer	(	HTMLInnerWindow *	window,
		DWORD	msec,
		BOOL	interval,
		IDispatch *	disp,
		LONG *	id
	)

Definition at line 169 of file task.c.

{
    thread_data_t *thread_data;
    task_timer_t *timer;
    DWORD tc = GetTickCount();
 
    static DWORD id_cnt = 0x20000000;
 
    thread_data = get_thread_data(TRUE);
    if(!thread_data)
        return E_OUTOFMEMORY;
 
    timer = heap_alloc(sizeof(task_timer_t));
    if(!timer)
        return E_OUTOFMEMORY;
 
    timer->id = id_cnt++;
    timer->window = window;
    timer->time = tc + msec;
    timer->interval = interval ? msec : 0;
    list_init(&timer->entry);
 
    IDispatch_AddRef(disp);
    timer->disp = disp;
 
    if(queue_timer(thread_data, timer))
        SetTimer(thread_data->thread_hwnd, TIMER_ID, msec, NULL);
 
    *id = timer->id;
    return S_OK;
}

Referenced by window_set_timer().