July 2015 - Wine-Commits - list.winehq.org

Sebastian Lackner : ntdll/tests: Add tests for threadpool timer merging.
by Alexandre Julliard July 3, 2015

July 3, 2015

Module: wine Branch: master Commit: 9f71015a994a18656b2c0093bd3f525e959460d3 URL: http://source.winehq.org/git/wine.git/?a=commit;h=9f71015a994a18656b2c0093b… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Fri Jul 3 01:59:02 2015 +0200 ntdll/tests: Add tests for threadpool timer merging. --- dlls/ntdll/tests/threadpool.c | 117 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 117 insertions(+) diff --git a/dlls/ntdll/tests/threadpool.c b/dlls/ntdll/tests/threadpool.c index 460e85e..0671202 100644 --- a/dlls/ntdll/tests/threadpool.c +++ b/dlls/ntdll/tests/threadpool.c @@ -790,6 +790,122 @@ static void test_tp_timer(void) CloseHandle(semaphore); } +struct window_length_info +{ + HANDLE semaphore; + DWORD ticks; +}; + +static void CALLBACK window_length_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_TIMER *timer) +{ + struct window_length_info *info = userdata; + trace("Running window length callback\n"); + info->ticks = GetTickCount(); + ReleaseSemaphore(info->semaphore, 1, NULL); +} + +static void test_tp_window_length(void) +{ + struct window_length_info info1, info2; + TP_CALLBACK_ENVIRON environment; + TP_TIMER *timer1, *timer2; + LARGE_INTEGER when; + HANDLE semaphore; + NTSTATUS status; + TP_POOL *pool; + DWORD result; + + semaphore = CreateSemaphoreA(NULL, 0, 2, NULL); + ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + + /* allocate new threadpool */ + pool = NULL; + status = pTpAllocPool(&pool, NULL); + ok(!status, "TpAllocPool failed with status %x\n", status); + ok(pool != NULL, "expected pool != NULL\n"); + + /* allocate two identical timers */ + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + + timer1 = NULL; + info1.semaphore = semaphore; + status = pTpAllocTimer(&timer1, window_length_cb, &info1, &environment); + ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(timer1 != NULL, "expected timer1 != NULL\n"); + + timer2 = NULL; + info2.semaphore = semaphore; + status = pTpAllocTimer(&timer2, window_length_cb, &info2, &environment); + ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(timer2 != NULL, "expected timer2 != NULL\n"); + + /* choose parameters so that timers are not merged */ + info1.ticks = 0; + info2.ticks = 0; + + NtQuerySystemTime( &when ); + when.QuadPart += (ULONGLONG)250 * 10000; + pTpSetTimer(timer2, &when, 0, 0); + Sleep(50); + when.QuadPart -= (ULONGLONG)150 * 10000; + pTpSetTimer(timer1, &when, 0, 75); + + result = WaitForSingleObject(semaphore, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphore, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n"); + ok(info2.ticks >= info1.ticks + 75 || broken(info2.ticks < info1.ticks + 75) /* Win 2008 */, + "expected that timers are not merged\n"); + + /* timers will be merged */ + info1.ticks = 0; + info2.ticks = 0; + + NtQuerySystemTime( &when ); + when.QuadPart += (ULONGLONG)250 * 10000; + pTpSetTimer(timer2, &when, 0, 0); + Sleep(50); + when.QuadPart -= (ULONGLONG)150 * 10000; + pTpSetTimer(timer1, &when, 0, 200); + + result = WaitForSingleObject(semaphore, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphore, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n"); + ok(info2.ticks >= info1.ticks - 50 && info2.ticks <= info1.ticks + 50, + "expected that timers are merged\n"); + + /* on Windows the timers also get merged in this case */ + info1.ticks = 0; + info2.ticks = 0; + + NtQuerySystemTime( &when ); + when.QuadPart += (ULONGLONG)100 * 10000; + pTpSetTimer(timer1, &when, 0, 200); + Sleep(50); + when.QuadPart += (ULONGLONG)150 * 10000; + pTpSetTimer(timer2, &when, 0, 0); + + result = WaitForSingleObject(semaphore, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphore, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ok(info1.ticks != 0 && info2.ticks != 0, "expected that ticks are nonzero\n"); + todo_wine + ok(info2.ticks >= info1.ticks - 50 && info2.ticks <= info1.ticks + 50, + "expected that timers are merged\n"); + + /* cleanup */ + pTpReleaseTimer(timer1); + pTpReleaseTimer(timer2); + pTpReleasePool(pool); + CloseHandle(semaphore); +} + START_TEST(threadpool) { if (!init_threadpool()) @@ -802,4 +918,5 @@ START_TEST(threadpool) test_tp_instance(); test_tp_disassociate(); test_tp_timer(); + test_tp_window_length(); }

1 0

Sebastian Lackner : ntdll/tests: Add basic tests for threadpool timer functions.
by Alexandre Julliard July 3, 2015

July 3, 2015

Module: wine Branch: master Commit: aefb85ddab60045666d9de3ebe523a24fa83ea42 URL: http://source.winehq.org/git/wine.git/?a=commit;h=aefb85ddab60045666d9de3eb… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Fri Jul 3 01:58:45 2015 +0200 ntdll/tests: Add basic tests for threadpool timer functions. --- dlls/ntdll/tests/threadpool.c | 145 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 145 insertions(+) diff --git a/dlls/ntdll/tests/threadpool.c b/dlls/ntdll/tests/threadpool.c index a75b622..460e85e 100644 --- a/dlls/ntdll/tests/threadpool.c +++ b/dlls/ntdll/tests/threadpool.c @@ -23,17 +23,22 @@ static HMODULE hntdll = 0; static NTSTATUS (WINAPI *pTpAllocCleanupGroup)(TP_CLEANUP_GROUP **); static NTSTATUS (WINAPI *pTpAllocPool)(TP_POOL **,PVOID); +static NTSTATUS (WINAPI *pTpAllocTimer)(TP_TIMER **,PTP_TIMER_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *); static NTSTATUS (WINAPI *pTpAllocWork)(TP_WORK **,PTP_WORK_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *); static NTSTATUS (WINAPI *pTpCallbackMayRunLong)(TP_CALLBACK_INSTANCE *); static VOID (WINAPI *pTpCallbackReleaseSemaphoreOnCompletion)(TP_CALLBACK_INSTANCE *,HANDLE,DWORD); static VOID (WINAPI *pTpDisassociateCallback)(TP_CALLBACK_INSTANCE *); +static BOOL (WINAPI *pTpIsTimerSet)(TP_TIMER *); static VOID (WINAPI *pTpPostWork)(TP_WORK *); static VOID (WINAPI *pTpReleaseCleanupGroup)(TP_CLEANUP_GROUP *); static VOID (WINAPI *pTpReleaseCleanupGroupMembers)(TP_CLEANUP_GROUP *,BOOL,PVOID); static VOID (WINAPI *pTpReleasePool)(TP_POOL *); +static VOID (WINAPI *pTpReleaseTimer)(TP_TIMER *); static VOID (WINAPI *pTpReleaseWork)(TP_WORK *); static VOID (WINAPI *pTpSetPoolMaxThreads)(TP_POOL *,DWORD); +static VOID (WINAPI *pTpSetTimer)(TP_TIMER *,LARGE_INTEGER *,LONG,LONG); static NTSTATUS (WINAPI *pTpSimpleTryPost)(PTP_SIMPLE_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *); +static VOID (WINAPI *pTpWaitForTimer)(TP_TIMER *,BOOL); static VOID (WINAPI *pTpWaitForWork)(TP_WORK *,BOOL); #define NTDLL_GET_PROC(func) \ @@ -55,17 +60,22 @@ static BOOL init_threadpool(void) NTDLL_GET_PROC(TpAllocCleanupGroup); NTDLL_GET_PROC(TpAllocPool); + NTDLL_GET_PROC(TpAllocTimer); NTDLL_GET_PROC(TpAllocWork); NTDLL_GET_PROC(TpCallbackMayRunLong); NTDLL_GET_PROC(TpCallbackReleaseSemaphoreOnCompletion); NTDLL_GET_PROC(TpDisassociateCallback); + NTDLL_GET_PROC(TpIsTimerSet); NTDLL_GET_PROC(TpPostWork); NTDLL_GET_PROC(TpReleaseCleanupGroup); NTDLL_GET_PROC(TpReleaseCleanupGroupMembers); NTDLL_GET_PROC(TpReleasePool); + NTDLL_GET_PROC(TpReleaseTimer); NTDLL_GET_PROC(TpReleaseWork); NTDLL_GET_PROC(TpSetPoolMaxThreads); + NTDLL_GET_PROC(TpSetTimer); NTDLL_GET_PROC(TpSimpleTryPost); + NTDLL_GET_PROC(TpWaitForTimer); NTDLL_GET_PROC(TpWaitForWork); if (!pTpAllocPool) @@ -646,6 +656,140 @@ static void test_tp_disassociate(void) CloseHandle(semaphores[1]); } +static void CALLBACK timer_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_TIMER *timer) +{ + HANDLE semaphore = userdata; + trace("Running timer callback\n"); + ReleaseSemaphore(semaphore, 1, NULL); +} + +static void test_tp_timer(void) +{ + TP_CALLBACK_ENVIRON environment; + DWORD result, ticks; + LARGE_INTEGER when; + HANDLE semaphore; + NTSTATUS status; + TP_TIMER *timer; + TP_POOL *pool; + BOOL success; + int i; + + semaphore = CreateSemaphoreA(NULL, 0, 1, NULL); + ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + + /* allocate new threadpool */ + pool = NULL; + status = pTpAllocPool(&pool, NULL); + ok(!status, "TpAllocPool failed with status %x\n", status); + ok(pool != NULL, "expected pool != NULL\n"); + + /* allocate new timer */ + timer = NULL; + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + status = pTpAllocTimer(&timer, timer_cb, semaphore, &environment); + ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(timer != NULL, "expected timer != NULL\n"); + + success = pTpIsTimerSet(timer); + ok(!success, "TpIsTimerSet returned TRUE\n"); + + /* test timer with a relative timeout */ + when.QuadPart = (ULONGLONG)200 * -10000; + pTpSetTimer(timer, &when, 0, 0); + success = pTpIsTimerSet(timer); + ok(success, "TpIsTimerSet returned FALSE\n"); + + pTpWaitForTimer(timer, FALSE); + + result = WaitForSingleObject(semaphore, 100); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphore, 200); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + success = pTpIsTimerSet(timer); + ok(success, "TpIsTimerSet returned FALSE\n"); + + /* test timer with an absolute timeout */ + NtQuerySystemTime( &when ); + when.QuadPart += (ULONGLONG)200 * 10000; + pTpSetTimer(timer, &when, 0, 0); + success = pTpIsTimerSet(timer); + ok(success, "TpIsTimerSet returned FALSE\n"); + + pTpWaitForTimer(timer, FALSE); + + result = WaitForSingleObject(semaphore, 100); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphore, 200); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + success = pTpIsTimerSet(timer); + ok(success, "TpIsTimerSet returned FALSE\n"); + + /* test timer with zero timeout */ + when.QuadPart = 0; + pTpSetTimer(timer, &when, 0, 0); + success = pTpIsTimerSet(timer); + ok(success, "TpIsTimerSet returned FALSE\n"); + + pTpWaitForTimer(timer, FALSE); + + result = WaitForSingleObject(semaphore, 50); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + success = pTpIsTimerSet(timer); + ok(success, "TpIsTimerSet returned FALSE\n"); + + /* unset the timer */ + pTpSetTimer(timer, NULL, 0, 0); + success = pTpIsTimerSet(timer); + ok(!success, "TpIsTimerSet returned TRUE\n"); + pTpWaitForTimer(timer, TRUE); + + pTpReleaseTimer(timer); + CloseHandle(semaphore); + + semaphore = CreateSemaphoreA(NULL, 0, 3, NULL); + ok(semaphore != NULL, "CreateSemaphoreA failed %u\n", GetLastError()); + + /* allocate a new timer */ + timer = NULL; + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + status = pTpAllocTimer(&timer, timer_cb, semaphore, &environment); + ok(!status, "TpAllocTimer failed with status %x\n", status); + ok(timer != NULL, "expected timer != NULL\n"); + + /* test a relative timeout repeated periodically */ + when.QuadPart = (ULONGLONG)200 * -10000; + pTpSetTimer(timer, &when, 200, 0); + success = pTpIsTimerSet(timer); + ok(success, "TpIsTimerSet returned FALSE\n"); + + /* wait until the timer was triggered three times */ + ticks = GetTickCount(); + for (i = 0; i < 3; i++) + { + result = WaitForSingleObject(semaphore, 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + } + ticks = GetTickCount() - ticks; + ok(ticks >= 500 && (ticks <= 700 || broken(ticks <= 750)) /* Win 7 */, + "expected approximately 600 ticks, got %u\n", ticks); + + /* unset the timer */ + pTpSetTimer(timer, NULL, 0, 0); + success = pTpIsTimerSet(timer); + ok(!success, "TpIsTimerSet returned TRUE\n"); + pTpWaitForTimer(timer, TRUE); + + /* cleanup */ + pTpReleaseTimer(timer); + pTpReleasePool(pool); + CloseHandle(semaphore); +} + START_TEST(threadpool) { if (!init_threadpool()) @@ -657,4 +801,5 @@ START_TEST(threadpool) test_tp_group_cancel(); test_tp_instance(); test_tp_disassociate(); + test_tp_timer(); }

1 0

Sebastian Lackner : ntdll: Implement threadpool timer queues.
by Alexandre Julliard July 3, 2015

July 3, 2015

Module: wine Branch: master Commit: cb2aae1af8dc039d06e48c456ed9237fa69b02ee URL: http://source.winehq.org/git/wine.git/?a=commit;h=cb2aae1af8dc039d06e48c456… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Fri Jul 3 01:58:29 2015 +0200 ntdll: Implement threadpool timer queues. --- dlls/ntdll/ntdll.spec | 3 + dlls/ntdll/threadpool.c | 321 +++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 321 insertions(+), 3 deletions(-) Diff: http://source.winehq.org/git/wine.git/?a=commitdiff;h=cb2aae1af8dc039d06e48…

1 0

Sebastian Lackner : ntdll: Implement TpAllocTimer and TpReleaseTimer.
by Alexandre Julliard July 3, 2015

July 3, 2015

Module: wine Branch: master Commit: bd7cb07358e726287716e83d9e5b7a6df4f2dd0d URL: http://source.winehq.org/git/wine.git/?a=commit;h=bd7cb07358e726287716e83d9… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Fri Jul 3 01:57:54 2015 +0200 ntdll: Implement TpAllocTimer and TpReleaseTimer. --- dlls/ntdll/ntdll.spec | 2 ++ dlls/ntdll/threadpool.c | 67 ++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 68 insertions(+), 1 deletion(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index ee90705..10d3652 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -972,6 +972,7 @@ @ stdcall RtlxUnicodeStringToOemSize(ptr) RtlUnicodeStringToOemSize @ stdcall TpAllocCleanupGroup(ptr) @ stdcall TpAllocPool(ptr ptr) +@ stdcall TpAllocTimer(ptr ptr ptr ptr) @ stdcall TpAllocWork(ptr ptr ptr ptr) @ stdcall TpCallbackLeaveCriticalSectionOnCompletion(ptr ptr) @ stdcall TpCallbackMayRunLong(ptr) @@ -984,6 +985,7 @@ @ stdcall TpReleaseCleanupGroup(ptr) @ stdcall TpReleaseCleanupGroupMembers(ptr long ptr) @ stdcall TpReleasePool(ptr) +@ stdcall TpReleaseTimer(ptr) @ stdcall TpReleaseWork(ptr) @ stdcall TpSetPoolMaxThreads(ptr long) @ stdcall TpSetPoolMinThreads(ptr long) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index 33e2c8a..cf714a6 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -158,7 +158,8 @@ struct threadpool enum threadpool_objtype { TP_OBJECT_TYPE_SIMPLE, - TP_OBJECT_TYPE_WORK + TP_OBJECT_TYPE_WORK, + TP_OBJECT_TYPE_TIMER }; /* internal threadpool object representation */ @@ -196,6 +197,10 @@ struct threadpool_object { PTP_WORK_CALLBACK callback; } work; + struct + { + PTP_TIMER_CALLBACK callback; + } timer; } u; }; @@ -239,6 +244,13 @@ static inline struct threadpool_object *impl_from_TP_WORK( TP_WORK *work ) return object; } +static inline struct threadpool_object *impl_from_TP_TIMER( TP_TIMER *timer ) +{ + struct threadpool_object *object = (struct threadpool_object *)timer; + assert( object->type == TP_OBJECT_TYPE_TIMER ); + return object; +} + static inline struct threadpool_group *impl_from_TP_CLEANUP_GROUP( TP_CLEANUP_GROUP *group ) { return (struct threadpool_group *)group; @@ -1683,6 +1695,15 @@ static void CALLBACK threadpool_worker_proc( void *param ) break; } + case TP_OBJECT_TYPE_TIMER: + { + TRACE( "executing timer callback %p(%p, %p, %p)\n", + object->u.timer.callback, callback_instance, object->userdata, object ); + object->u.timer.callback( callback_instance, object->userdata, (TP_TIMER *)object ); + TRACE( "callback %p returned\n", object->u.timer.callback ); + break; + } + default: assert(0); break; @@ -1789,6 +1810,37 @@ NTSTATUS WINAPI TpAllocPool( TP_POOL **out, PVOID reserved ) } /*********************************************************************** + * TpAllocTimer (NTDLL.@) + */ +NTSTATUS WINAPI TpAllocTimer( TP_TIMER **out, PTP_TIMER_CALLBACK callback, PVOID userdata, + TP_CALLBACK_ENVIRON *environment ) +{ + struct threadpool_object *object; + struct threadpool *pool; + NTSTATUS status; + + TRACE( "%p %p %p %p\n", out, callback, userdata, environment ); + + object = RtlAllocateHeap( GetProcessHeap(), 0, sizeof(*object) ); + if (!object) + return STATUS_NO_MEMORY; + + status = tp_threadpool_lock( &pool, environment ); + if (status) + { + RtlFreeHeap( GetProcessHeap(), 0, object ); + return status; + } + + object->type = TP_OBJECT_TYPE_TIMER; + object->u.timer.callback = callback; + tp_object_initialize( object, pool, userdata, environment ); + + *out = (TP_TIMER *)object; + return STATUS_SUCCESS; +} + +/*********************************************************************** * TpAllocWork (NTDLL.@) */ NTSTATUS WINAPI TpAllocWork( TP_WORK **out, PTP_WORK_CALLBACK callback, PVOID userdata, @@ -2068,6 +2120,19 @@ VOID WINAPI TpReleasePool( TP_POOL *pool ) } /*********************************************************************** + * TpReleaseTimer (NTDLL.@) + */ +VOID WINAPI TpReleaseTimer( TP_TIMER *timer ) +{ + struct threadpool_object *this = impl_from_TP_TIMER( timer ); + + TRACE( "%p\n", timer ); + + tp_object_shutdown( this ); + tp_object_release( this ); +} + +/*********************************************************************** * TpReleaseWork (NTDLL.@) */ VOID WINAPI TpReleaseWork( TP_WORK *work )

1 0

Sebastian Lackner : ntdll/tests: Add tests for TpDisassociateCallback.
by Alexandre Julliard July 3, 2015

July 3, 2015

Module: wine Branch: master Commit: 66c46e69605592aff6c682098b8d67e8b5e4e283 URL: http://source.winehq.org/git/wine.git/?a=commit;h=66c46e69605592aff6c682098… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Fri Jul 3 01:57:38 2015 +0200 ntdll/tests: Add tests for TpDisassociateCallback. --- dlls/ntdll/tests/threadpool.c | 149 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 149 insertions(+) diff --git a/dlls/ntdll/tests/threadpool.c b/dlls/ntdll/tests/threadpool.c index 62bd064..a75b622 100644 --- a/dlls/ntdll/tests/threadpool.c +++ b/dlls/ntdll/tests/threadpool.c @@ -26,6 +26,7 @@ static NTSTATUS (WINAPI *pTpAllocPool)(TP_POOL **,PVOID); static NTSTATUS (WINAPI *pTpAllocWork)(TP_WORK **,PTP_WORK_CALLBACK,PVOID,TP_CALLBACK_ENVIRON *); static NTSTATUS (WINAPI *pTpCallbackMayRunLong)(TP_CALLBACK_INSTANCE *); static VOID (WINAPI *pTpCallbackReleaseSemaphoreOnCompletion)(TP_CALLBACK_INSTANCE *,HANDLE,DWORD); +static VOID (WINAPI *pTpDisassociateCallback)(TP_CALLBACK_INSTANCE *); static VOID (WINAPI *pTpPostWork)(TP_WORK *); static VOID (WINAPI *pTpReleaseCleanupGroup)(TP_CLEANUP_GROUP *); static VOID (WINAPI *pTpReleaseCleanupGroupMembers)(TP_CLEANUP_GROUP *,BOOL,PVOID); @@ -57,6 +58,7 @@ static BOOL init_threadpool(void) NTDLL_GET_PROC(TpAllocWork); NTDLL_GET_PROC(TpCallbackMayRunLong); NTDLL_GET_PROC(TpCallbackReleaseSemaphoreOnCompletion); + NTDLL_GET_PROC(TpDisassociateCallback); NTDLL_GET_PROC(TpPostWork); NTDLL_GET_PROC(TpReleaseCleanupGroup); NTDLL_GET_PROC(TpReleaseCleanupGroupMembers); @@ -498,6 +500,152 @@ static void test_tp_instance(void) CloseHandle(semaphores[1]); } +static void CALLBACK disassociate_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work) +{ + HANDLE *semaphores = userdata; + DWORD result; + + trace("Running disassociate callback\n"); + + pTpDisassociateCallback(instance); + result = WaitForSingleObject(semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + ReleaseSemaphore(semaphores[1], 1, NULL); +} + +static void CALLBACK disassociate2_cb(TP_CALLBACK_INSTANCE *instance, void *userdata, TP_WORK *work) +{ + HANDLE *semaphores = userdata; + DWORD result; + + trace("Running disassociate2 callback\n"); + + pTpDisassociateCallback(instance); + result = WaitForSingleObject(semaphores[0], 100); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ReleaseSemaphore(semaphores[1], 1, NULL); +} + +static void CALLBACK disassociate3_cb(TP_CALLBACK_INSTANCE *instance, void *userdata) +{ + HANDLE *semaphores = userdata; + DWORD result; + + trace("Running disassociate3 callback\n"); + + pTpDisassociateCallback(instance); + result = WaitForSingleObject(semaphores[0], 100); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ReleaseSemaphore(semaphores[1], 1, NULL); +} + +static void test_tp_disassociate(void) +{ + TP_CALLBACK_ENVIRON environment; + TP_CLEANUP_GROUP *group; + HANDLE semaphores[2]; + NTSTATUS status; + TP_POOL *pool; + TP_WORK *work; + DWORD result; + + semaphores[0] = CreateSemaphoreW(NULL, 0, 1, NULL); + ok(semaphores[0] != NULL, "failed to create semaphore\n"); + semaphores[1] = CreateSemaphoreW(NULL, 0, 1, NULL); + ok(semaphores[1] != NULL, "failed to create semaphore\n"); + + /* allocate new threadpool and cleanup group */ + pool = NULL; + status = pTpAllocPool(&pool, NULL); + ok(!status, "TpAllocPool failed with status %x\n", status); + ok(pool != NULL, "expected pool != NULL\n"); + + group = NULL; + status = pTpAllocCleanupGroup(&group); + ok(!status, "TpAllocCleanupGroup failed with status %x\n", status); + ok(group != NULL, "expected pool != NULL\n"); + + /* test TpDisassociateCallback on work objects without group */ + work = NULL; + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + status = pTpAllocWork(&work, disassociate_cb, semaphores, &environment); + ok(!status, "TpAllocWork failed with status %x\n", status); + ok(work != NULL, "expected work != NULL\n"); + + pTpPostWork(work); + pTpWaitForWork(work, FALSE); + + result = WaitForSingleObject(semaphores[1], 100); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ReleaseSemaphore(semaphores[0], 1, NULL); + result = WaitForSingleObject(semaphores[1], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + pTpReleaseWork(work); + + /* test TpDisassociateCallback on work objects with group (1) */ + work = NULL; + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + environment.CleanupGroup = group; + status = pTpAllocWork(&work, disassociate_cb, semaphores, &environment); + ok(!status, "TpAllocWork failed with status %x\n", status); + ok(work != NULL, "expected work != NULL\n"); + + pTpPostWork(work); + pTpWaitForWork(work, FALSE); + + result = WaitForSingleObject(semaphores[1], 100); + ok(result == WAIT_TIMEOUT, "WaitForSingleObject returned %u\n", result); + ReleaseSemaphore(semaphores[0], 1, NULL); + result = WaitForSingleObject(semaphores[1], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + pTpReleaseCleanupGroupMembers(group, FALSE, NULL); + + /* test TpDisassociateCallback on work objects with group (2) */ + work = NULL; + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + environment.CleanupGroup = group; + status = pTpAllocWork(&work, disassociate2_cb, semaphores, &environment); + ok(!status, "TpAllocWork failed with status %x\n", status); + ok(work != NULL, "expected work != NULL\n"); + + pTpPostWork(work); + pTpReleaseCleanupGroupMembers(group, FALSE, NULL); + + ReleaseSemaphore(semaphores[0], 1, NULL); + result = WaitForSingleObject(semaphores[1], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + + /* test TpDisassociateCallback on simple callbacks */ + memset(&environment, 0, sizeof(environment)); + environment.Version = 1; + environment.Pool = pool; + environment.CleanupGroup = group; + status = pTpSimpleTryPost(disassociate3_cb, semaphores, &environment); + ok(!status, "TpSimpleTryPost failed with status %x\n", status); + + pTpReleaseCleanupGroupMembers(group, FALSE, NULL); + + ReleaseSemaphore(semaphores[0], 1, NULL); + result = WaitForSingleObject(semaphores[1], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + result = WaitForSingleObject(semaphores[0], 1000); + ok(result == WAIT_OBJECT_0, "WaitForSingleObject returned %u\n", result); + + /* cleanup */ + pTpReleaseCleanupGroup(group); + pTpReleasePool(pool); + CloseHandle(semaphores[0]); + CloseHandle(semaphores[1]); +} + START_TEST(threadpool) { if (!init_threadpool()) @@ -508,4 +656,5 @@ START_TEST(threadpool) test_tp_work_scheduler(); test_tp_group_cancel(); test_tp_instance(); + test_tp_disassociate(); }

1 0

Sebastian Lackner : ntdll: Implement TpDisassociateCallback and add a separate group completion event.
by Alexandre Julliard July 3, 2015

July 3, 2015

Module: wine Branch: master Commit: 775d3dcecb915c6861f37596a6dbdd9ebca44b93 URL: http://source.winehq.org/git/wine.git/?a=commit;h=775d3dcecb915c6861f37596a… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Fri Jul 3 01:57:23 2015 +0200 ntdll: Implement TpDisassociateCallback and add a separate group completion event. --- dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/threadpool.c | 68 ++++++++++++++++++++++++++++++++++++++++++++----- 2 files changed, 63 insertions(+), 6 deletions(-) diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index 134a3f7..ee90705 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -979,6 +979,7 @@ @ stdcall TpCallbackReleaseSemaphoreOnCompletion(ptr long long) @ stdcall TpCallbackSetEventOnCompletion(ptr long) @ stdcall TpCallbackUnloadDllOnCompletion(ptr ptr) +@ stdcall TpDisassociateCallback(ptr) @ stdcall TpPostWork(ptr) @ stdcall TpReleaseCleanupGroup(ptr) @ stdcall TpReleaseCleanupGroupMembers(ptr long ptr) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index eeb275f..33e2c8a 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -181,8 +181,10 @@ struct threadpool_object /* information about the pool, locked via .pool->cs */ struct list pool_entry; RTL_CONDITION_VARIABLE finished_event; + RTL_CONDITION_VARIABLE group_finished_event; LONG num_pending_callbacks; LONG num_running_callbacks; + LONG num_associated_callbacks; /* arguments for callback */ union { @@ -202,6 +204,7 @@ struct threadpool_instance { struct threadpool_object *object; DWORD threadid; + BOOL associated; BOOL may_run_long; struct { @@ -1406,8 +1409,10 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa memset( &object->pool_entry, 0, sizeof(object->pool_entry) ); RtlInitializeConditionVariable( &object->finished_event ); + RtlInitializeConditionVariable( &object->group_finished_event ); object->num_pending_callbacks = 0; object->num_running_callbacks = 0; + object->num_associated_callbacks = 0; if (environment) { @@ -1540,13 +1545,21 @@ static void tp_object_cancel( struct threadpool_object *object, BOOL group_cance * Waits until all pending and running callbacks of a specific object * have been processed. */ -static void tp_object_wait( struct threadpool_object *object ) +static void tp_object_wait( struct threadpool_object *object, BOOL group_wait ) { struct threadpool *pool = object->pool; RtlEnterCriticalSection( &pool->cs ); - while (object->num_pending_callbacks || object->num_running_callbacks) - RtlSleepConditionVariableCS( &object->finished_event, &pool->cs, NULL ); + if (group_wait) + { + while (object->num_pending_callbacks || object->num_running_callbacks) + RtlSleepConditionVariableCS( &object->group_finished_event, &pool->cs, NULL ); + } + else + { + while (object->num_pending_callbacks || object->num_associated_callbacks) + RtlSleepConditionVariableCS( &object->finished_event, &pool->cs, NULL ); + } RtlLeaveCriticalSection( &pool->cs ); } @@ -1576,6 +1589,7 @@ static BOOL tp_object_release( struct threadpool_object *object ) assert( object->shutdown ); assert( !object->num_pending_callbacks ); assert( !object->num_running_callbacks ); + assert( !object->num_associated_callbacks ); /* release reference to the group */ if (object->group) @@ -1631,6 +1645,7 @@ static void CALLBACK threadpool_worker_proc( void *param ) list_add_tail( &pool->pool, &object->pool_entry ); /* Leave critical section and do the actual callback. */ + object->num_associated_callbacks++; object->num_running_callbacks++; pool->num_busy_workers++; RtlLeaveCriticalSection( &pool->cs ); @@ -1639,6 +1654,7 @@ static void CALLBACK threadpool_worker_proc( void *param ) callback_instance = (TP_CALLBACK_INSTANCE *)&instance; instance.object = object; instance.threadid = GetCurrentThreadId(); + instance.associated = TRUE; instance.may_run_long = object->may_run_long; instance.cleanup.critical_section = NULL; instance.cleanup.mutex = NULL; @@ -1709,9 +1725,18 @@ static void CALLBACK threadpool_worker_proc( void *param ) skip_cleanup: RtlEnterCriticalSection( &pool->cs ); pool->num_busy_workers--; + object->num_running_callbacks--; if (!object->num_pending_callbacks && !object->num_running_callbacks) - RtlWakeAllConditionVariable( &object->finished_event ); + RtlWakeAllConditionVariable( &object->group_finished_event ); + + if (instance.associated) + { + object->num_associated_callbacks--; + if (!object->num_pending_callbacks && !object->num_associated_callbacks) + RtlWakeAllConditionVariable( &object->finished_event ); + } + tp_object_release( object ); } @@ -1913,6 +1938,37 @@ VOID WINAPI TpCallbackUnloadDllOnCompletion( TP_CALLBACK_INSTANCE *instance, HMO } /*********************************************************************** + * TpDisassociateCallback (NTDLL.@) + */ +VOID WINAPI TpDisassociateCallback( TP_CALLBACK_INSTANCE *instance ) +{ + struct threadpool_instance *this = impl_from_TP_CALLBACK_INSTANCE( instance ); + struct threadpool_object *object = this->object; + struct threadpool *pool; + + TRACE( "%p\n", instance ); + + if (this->threadid != GetCurrentThreadId()) + { + ERR("called from wrong thread, ignoring\n"); + return; + } + + if (!this->associated) + return; + + pool = object->pool; + RtlEnterCriticalSection( &pool->cs ); + + object->num_associated_callbacks--; + if (!object->num_pending_callbacks && !object->num_associated_callbacks) + RtlWakeAllConditionVariable( &object->finished_event ); + + RtlLeaveCriticalSection( &pool->cs ); + this->associated = FALSE; +} + +/*********************************************************************** * TpPostWork (NTDLL.@) */ VOID WINAPI TpPostWork( TP_WORK *work ) @@ -1993,7 +2049,7 @@ VOID WINAPI TpReleaseCleanupGroupMembers( TP_CLEANUP_GROUP *group, BOOL cancel_p /* Wait for remaining callbacks to finish */ LIST_FOR_EACH_ENTRY_SAFE( object, next, &members, struct threadpool_object, group_entry ) { - tp_object_wait( object ); + tp_object_wait( object, TRUE ); tp_object_release( object ); } } @@ -2115,5 +2171,5 @@ VOID WINAPI TpWaitForWork( TP_WORK *work, BOOL cancel_pending ) if (cancel_pending) tp_object_cancel( this, FALSE, NULL ); - tp_object_wait( this ); + tp_object_wait( this, FALSE ); }

1 0

Jacek Caban : wincrypt.h: Added some missing constants.
by Alexandre Julliard July 3, 2015

July 3, 2015

Module: wine Branch: master Commit: 0d2c6db9d2467517ce67b3cc2a48b61222f62b9f URL: http://source.winehq.org/git/wine.git/?a=commit;h=0d2c6db9d2467517ce67b3cc2… Author: Jacek Caban <jacek(a)codeweavers.com> Date: Thu Jul 2 17:49:50 2015 +0200 wincrypt.h: Added some missing constants. --- include/wincrypt.h | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/include/wincrypt.h b/include/wincrypt.h index 324007d..55c9509 100644 --- a/include/wincrypt.h +++ b/include/wincrypt.h @@ -1557,6 +1557,7 @@ typedef const CERT_CRL_CONTEXT_PAIR *PCCERT_CRL_CONTEXT_PAIR; #define ALG_SID_DSS_ANY 0 #define ALG_SID_DSS_PKCS 1 #define ALG_SID_DSS_DMS 2 +#define ALG_SID_ECDSA 3 /* DES SIDs */ #define ALG_SID_DES 1 @@ -1573,6 +1574,9 @@ typedef const CERT_CRL_CONTEXT_PAIR *PCCERT_CRL_CONTEXT_PAIR; #define ALG_SID_AES_192 15 #define ALG_SID_AES_256 16 #define ALG_SID_AES 17 +/* Fortezza */ +#define ALG_SID_SKIPJACK 10 +#define ALG_SID_TEK 11 /* Diffie-Hellmans SIDs */ #define ALG_SID_DH_SANDF 1 #define ALG_SID_DH_EPHEM 2 @@ -1609,6 +1613,8 @@ typedef const CERT_CRL_CONTEXT_PAIR *PCCERT_CRL_CONTEXT_PAIR; #define ALG_SID_SCHANNEL_ENC_KEY 7 #define ALG_SID_EXAMPLE 80 +#define ALG_SID_ECMQV 1 + /* Algorithm Definitions */ #define CALG_MD2 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD2) #define CALG_MD4 (ALG_CLASS_HASH | ALG_TYPE_ANY | ALG_SID_MD4) @@ -1626,14 +1632,20 @@ typedef const CERT_CRL_CONTEXT_PAIR *PCCERT_CRL_CONTEXT_PAIR; #define CALG_RSA_SIGN (ALG_CLASS_SIGNATURE | ALG_TYPE_RSA | ALG_SID_RSA_ANY) #define CALG_DSS_SIGN (ALG_CLASS_SIGNATURE | ALG_TYPE_DSS | ALG_SID_DSS_ANY) #define CALG_NO_SIGN (ALG_CLASS_SIGNATURE | ALG_TYPE_ANY | ALG_SID_ANY) +#define CALG_ECDSA (ALG_CLASS_SIGNATURE | ALG_TYPE_DSS | ALG_SID_ECDSA) #define CALG_DH_SF (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_DH_SANDF) #define CALG_DH_EPHEM (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_DH_EPHEM) +#define CALG_AGREEDKEY_ANY (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_AGREED_KEY_ANY) +#define CALG_KEA_KEYX (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_KEA) +#define CALG_HUGHES_MD5 (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_ANY | ALG_SID_MD5) #define CALG_ECDH (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_DH | ALG_SID_ECDH) #define CALG_RSA_KEYX (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_RSA | ALG_SID_RSA_ANY) +#define CALG_ECMQV (ALG_CLASS_KEY_EXCHANGE | ALG_TYPE_ANY | ALG_SID_ECMQV) #define CALG_DES (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_DES) #define CALG_RC2 (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_RC2) #define CALG_3DES (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_3DES) #define CALG_3DES_112 (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_3DES_112) +#define CALG_DESX (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_DESX) #define CALG_AES_128 (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_128) #define CALG_AES_192 (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_192) #define CALG_AES_256 (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_AES_256) @@ -1641,6 +1653,9 @@ typedef const CERT_CRL_CONTEXT_PAIR *PCCERT_CRL_CONTEXT_PAIR; #define CALG_RC4 (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_STREAM | ALG_SID_RC4) #define CALG_SEAL (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_STREAM | ALG_SID_SEAL) #define CALG_RC5 (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_STREAM | ALG_SID_RC5) +#define CALG_SKIPJACK (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_SKIPJACK) +#define CALG_TEK (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_TEK) +#define CALG_CYLINK_MEK (ALG_CLASS_DATA_ENCRYPT | ALG_TYPE_BLOCK | ALG_SID_CYLINK_MEK) #define CALG_SSL3_MASTER (ALG_CLASS_MSG_ENCRYPT | ALG_TYPE_SECURECHANNEL | ALG_SID_SSL3_MASTER) #define CALG_SCHANNEL_MASTER_HASH (ALG_CLASS_MSG_ENCRYPT | ALG_TYPE_SECURECHANNEL | ALG_SID_SCHANNEL_MASTER_HASH) #define CALG_SCHANNEL_MAC_KEY (ALG_CLASS_MSG_ENCRYPT | ALG_TYPE_SECURECHANNEL | ALG_SID_SCHANNEL_MAC_KEY)

1 0

Vincent Povirk : winex11.drv: Track external changes to _NET_WM_STATE in net_wm_state.
by Alexandre Julliard July 2, 2015

July 2, 2015

Module: wine Branch: master Commit: 3d8353fe182f3e7742cd7dab3420635e45ace129 URL: http://source.winehq.org/git/wine.git/?a=commit;h=3d8353fe182f3e7742cd7dab3… Author: Vincent Povirk <vincent(a)codeweavers.com> Date: Wed Jul 1 13:43:48 2015 -0500 winex11.drv: Track external changes to _NET_WM_STATE in net_wm_state. In some cases, WM's will modify the _NET_WM_STATE of our own windows. Most notably, this can happen when the WM maximizes our window, but mutter has been known to alter the fullscreen state as well. If we want to reconfigure our window later, we'll probably have to remove these states, which means we need to remember that they were set. --- dlls/winex11.drv/event.c | 35 +++---------------------- dlls/winex11.drv/window.c | 67 ++++++++++++++++++++++++++++++++++++++--------- dlls/winex11.drv/x11drv.h | 1 + 3 files changed, 59 insertions(+), 44 deletions(-) diff --git a/dlls/winex11.drv/event.c b/dlls/winex11.drv/event.c index a1abfe7..ee30259 100644 --- a/dlls/winex11.drv/event.c +++ b/dlls/winex11.drv/event.c @@ -949,35 +949,6 @@ static void X11DRV_UnmapNotify( HWND hwnd, XEvent *event ) /*********************************************************************** - * is_net_wm_state_maximized - */ -static BOOL is_net_wm_state_maximized( Display *display, struct x11drv_win_data *data ) -{ - Atom type, *state; - int format, ret = 0; - unsigned long i, count, remaining; - - if (!data->whole_window) return FALSE; - - if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(_NET_WM_STATE), 0, - 65536/sizeof(CARD32), False, XA_ATOM, &type, &format, &count, - &remaining, (unsigned char **)&state )) - { - if (type == XA_ATOM && format == 32) - { - for (i = 0; i < count; i++) - { - if (state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_VERT) || - state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ)) - ret++; - } - } - XFree( state ); - } - return (ret == 2); -} - -/*********************************************************************** * reparent_notify */ static void reparent_notify( Display *display, HWND hwnd, Window xparent, int x, int y ) @@ -1132,7 +1103,8 @@ void X11DRV_ConfigureNotify( HWND hwnd, XEvent *xev ) style = GetWindowLongW( data->hwnd, GWL_STYLE ); if ((style & WS_CAPTION) == WS_CAPTION) { - if (is_net_wm_state_maximized( event->display, data )) + read_net_wm_states( event->display, data ); + if ((data->net_wm_state & (1 << NET_WM_STATE_MAXIMIZED))) { if (!(style & WS_MAXIMIZE)) { @@ -1267,7 +1239,8 @@ static void handle_wm_state_notify( HWND hwnd, XPropertyEvent *event, BOOL updat if (data->iconic && data->wm_state == NormalState) /* restore window */ { data->iconic = FALSE; - if ((style & WS_CAPTION) == WS_CAPTION && is_net_wm_state_maximized( event->display, data )) + read_net_wm_states( event->display, data ); + if ((style & WS_CAPTION) == WS_CAPTION && (data->net_wm_state & (1 << NET_WM_STATE_MAXIMIZED))) { if ((style & WS_MAXIMIZEBOX) && !(style & WS_DISABLED)) { diff --git a/dlls/winex11.drv/window.c b/dlls/winex11.drv/window.c index 69f6446..50c3290 100644 --- a/dlls/winex11.drv/window.c +++ b/dlls/winex11.drv/window.c @@ -65,6 +65,15 @@ WINE_DEFAULT_DEBUG_CHANNEL(x11drv); #define _NET_WM_STATE_ADD 1 #define _NET_WM_STATE_TOGGLE 2 +static const unsigned int net_wm_state_atoms[NB_NET_WM_STATES] = +{ + XATOM__NET_WM_STATE_FULLSCREEN, + XATOM__NET_WM_STATE_ABOVE, + XATOM__NET_WM_STATE_MAXIMIZED_VERT, + XATOM__NET_WM_STATE_SKIP_PAGER, + XATOM__NET_WM_STATE_SKIP_TASKBAR +}; + #define SWP_AGG_NOPOSCHANGE (SWP_NOSIZE | SWP_NOMOVE | SWP_NOCLIENTSIZE | SWP_NOCLIENTMOVE | SWP_NOZORDER) /* is cursor clipping active? */ @@ -960,15 +969,6 @@ void update_user_time( Time time ) */ void update_net_wm_states( struct x11drv_win_data *data ) { - static const unsigned int state_atoms[NB_NET_WM_STATES] = - { - XATOM__NET_WM_STATE_FULLSCREEN, - XATOM__NET_WM_STATE_ABOVE, - XATOM__NET_WM_STATE_MAXIMIZED_VERT, - XATOM__NET_WM_STATE_SKIP_PAGER, - XATOM__NET_WM_STATE_SKIP_TASKBAR - }; - DWORD i, style, ex_style, new_state = 0; if (!data->managed) return; @@ -1005,8 +1005,8 @@ void update_net_wm_states( struct x11drv_win_data *data ) if (!(new_state & (1 << i))) continue; TRACE( "setting wm state %u for unmapped window %p/%lx\n", i, data->hwnd, data->whole_window ); - atoms[count++] = X11DRV_Atoms[state_atoms[i] - FIRST_XATOM]; - if (state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) + atoms[count++] = X11DRV_Atoms[net_wm_state_atoms[i] - FIRST_XATOM]; + if (net_wm_state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) atoms[count++] = x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ); } XChangeProperty( data->display, data->whole_window, x11drv_atom(_NET_WM_STATE), XA_ATOM, @@ -1034,8 +1034,8 @@ void update_net_wm_states( struct x11drv_win_data *data ) (new_state & (1 << i)) != 0, (data->net_wm_state & (1 << i)) != 0 ); xev.xclient.data.l[0] = (new_state & (1 << i)) ? _NET_WM_STATE_ADD : _NET_WM_STATE_REMOVE; - xev.xclient.data.l[1] = X11DRV_Atoms[state_atoms[i] - FIRST_XATOM]; - xev.xclient.data.l[2] = ((state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) ? + xev.xclient.data.l[1] = X11DRV_Atoms[net_wm_state_atoms[i] - FIRST_XATOM]; + xev.xclient.data.l[2] = ((net_wm_state_atoms[i] == XATOM__NET_WM_STATE_MAXIMIZED_VERT) ? x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ) : 0); XSendEvent( data->display, root_window, False, SubstructureRedirectMask | SubstructureNotifyMask, &xev ); @@ -1044,6 +1044,47 @@ void update_net_wm_states( struct x11drv_win_data *data ) data->net_wm_state = new_state; } +/*********************************************************************** + * read_net_wm_states + */ +void read_net_wm_states( Display* display, struct x11drv_win_data *data ) +{ + Atom type, *state; + int format; + unsigned long i, j, count, remaining; + DWORD new_state = 0; + BOOL maximized_horz = FALSE; + + if (!data->whole_window) return; + + if (!XGetWindowProperty( display, data->whole_window, x11drv_atom(_NET_WM_STATE), 0, + 65536/sizeof(CARD32), False, XA_ATOM, &type, &format, &count, + &remaining, (unsigned char **)&state )) + { + if (type == XA_ATOM && format == 32) + { + for (i = 0; i < count; i++) + { + if (state[i] == x11drv_atom(_NET_WM_STATE_MAXIMIZED_HORZ)) + maximized_horz = TRUE; + for (j=0; j < NB_NET_WM_STATES; j++) + { + if (state[i] == X11DRV_Atoms[net_wm_state_atoms[j] - FIRST_XATOM]) + { + new_state |= 1 << j; + } + } + } + } + XFree( state ); + } + + if (!maximized_horz) + new_state &= ~(1 << NET_WM_STATE_MAXIMIZED); + + data->net_wm_state = new_state; +} + /*********************************************************************** * set_xembed_flags diff --git a/dlls/winex11.drv/x11drv.h b/dlls/winex11.drv/x11drv.h index 213f610..cb4b0bb 100644 --- a/dlls/winex11.drv/x11drv.h +++ b/dlls/winex11.drv/x11drv.h @@ -576,6 +576,7 @@ extern void destroy_gl_drawable( HWND hwnd ) DECLSPEC_HIDDEN; extern void wait_for_withdrawn_state( HWND hwnd, BOOL set ) DECLSPEC_HIDDEN; extern Window init_clip_window(void) DECLSPEC_HIDDEN; extern void update_user_time( Time time ) DECLSPEC_HIDDEN; +extern void read_net_wm_states( Display *display, struct x11drv_win_data *data ) DECLSPEC_HIDDEN; extern void update_net_wm_states( struct x11drv_win_data *data ) DECLSPEC_HIDDEN; extern void make_window_embedded( struct x11drv_win_data *data ) DECLSPEC_HIDDEN; extern Window create_client_window( struct x11drv_win_data *data, const XVisualInfo *visual ) DECLSPEC_HIDDEN;

1 0

Michael Stefaniuc : dmstyle/tests: Remove skips wrongly copied from the dmime tests.
by Alexandre Julliard July 2, 2015

July 2, 2015

Module: wine Branch: master Commit: 396dd9d14136b25ff51f1f3c3a5b713788d92b79 URL: http://source.winehq.org/git/wine.git/?a=commit;h=396dd9d14136b25ff51f1f3c3… Author: Michael Stefaniuc <mstefani(a)redhat.de> Date: Thu Jul 2 12:00:34 2015 +0200 dmstyle/tests: Remove skips wrongly copied from the dmime tests. --- dlls/dmstyle/tests/dmstyle.c | 8 -------- 1 file changed, 8 deletions(-) diff --git a/dlls/dmstyle/tests/dmstyle.c b/dlls/dmstyle/tests/dmstyle.c index 2677daa..404dad6 100644 --- a/dlls/dmstyle/tests/dmstyle.c +++ b/dlls/dmstyle/tests/dmstyle.c @@ -184,10 +184,6 @@ static void test_COM_track(void) /* Same refcount for all DirectMusicTrack interfaces */ hr = CoCreateInstance(class[i].clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicTrack8, (void**)&dmt8); - if (hr == E_NOINTERFACE && !dmt8) { - skip("%s not created with CoCreateInstance()\n", class[i].name); - continue; - } ok(hr == S_OK, "%s create failed: %08x, expected S_OK\n", class[i].name, hr); refcount = IDirectMusicTrack8_AddRef(dmt8); ok(refcount == 2, "refcount == %u, expected 2\n", refcount); @@ -267,10 +263,6 @@ static void test_track(void) trace("Testing %s\n", class[i].name); hr = CoCreateInstance(class[i].clsid, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicTrack8, (void**)&dmt8); - if (hr == E_NOINTERFACE && !dmt8) { - skip("%s not created with CoCreateInstance()\n", class[i].name); - continue; - } ok(hr == S_OK, "%s create failed: %08x, expected S_OK\n", class[i].name, hr); /* IDirectMusicTrack8 */

1 0

Sebastian Lackner : ntdll: Add support for threadpool group cancel callback.
by Alexandre Julliard July 2, 2015

July 2, 2015

Module: wine Branch: master Commit: 1839ce8697105a83a5f5a427c4b047422e3ec06c URL: http://source.winehq.org/git/wine.git/?a=commit;h=1839ce8697105a83a5f5a427c… Author: Sebastian Lackner <sebastian(a)fds-team.de> Date: Wed Jul 1 22:52:52 2015 +0200 ntdll: Add support for threadpool group cancel callback. --- dlls/ntdll/threadpool.c | 17 ++++++++++++++--- 1 file changed, 14 insertions(+), 3 deletions(-) diff --git a/dlls/ntdll/threadpool.c b/dlls/ntdll/threadpool.c index da41ba0..93d9b28 100644 --- a/dlls/ntdll/threadpool.c +++ b/dlls/ntdll/threadpool.c @@ -171,6 +171,7 @@ struct threadpool_object struct threadpool *pool; struct threadpool_group *group; PVOID userdata; + PTP_CLEANUP_GROUP_CANCEL_CALLBACK group_cancel_callback; /* information about the group, locked via .group->cs */ struct list group_entry; BOOL is_group_member; @@ -1370,6 +1371,7 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa object->pool = pool; object->group = NULL; object->userdata = userdata; + object->group_cancel_callback = NULL; memset( &object->group_entry, 0, sizeof(object->group_entry) ); object->is_group_member = FALSE; @@ -1385,6 +1387,7 @@ static void tp_object_initialize( struct threadpool_object *object, struct threa FIXME( "unsupported environment version %u\n", environment->Version ); object->group = impl_from_TP_CLEANUP_GROUP( environment->CleanupGroup ); + object->group_cancel_callback = environment->CleanupGroupCancelCallback; WARN( "environment not fully implemented yet\n" ); } @@ -1467,7 +1470,7 @@ static void tp_object_submit( struct threadpool_object *object ) * * Cancels all currently pending callbacks for a specific object. */ -static void tp_object_cancel( struct threadpool_object *object ) +static void tp_object_cancel( struct threadpool_object *object, BOOL group_cancel, PVOID userdata ) { struct threadpool *pool = object->pool; LONG pending_callbacks = 0; @@ -1481,6 +1484,14 @@ static void tp_object_cancel( struct threadpool_object *object ) } RtlLeaveCriticalSection( &pool->cs ); + /* Execute group cancellation callback if defined, and if this was actually a group cancel. */ + if (pending_callbacks && group_cancel && object->group_cancel_callback) + { + TRACE( "executing group cancel callback %p(%p, %p)\n", object->group_cancel_callback, object, userdata ); + object->group_cancel_callback( object, userdata ); + TRACE( "callback %p returned\n", object->group_cancel_callback ); + } + while (pending_callbacks--) tp_object_release( object ); } @@ -1766,7 +1777,7 @@ VOID WINAPI TpReleaseCleanupGroupMembers( TP_CLEANUP_GROUP *group, BOOL cancel_p { LIST_FOR_EACH_ENTRY( object, &members, struct threadpool_object, group_entry ) { - tp_object_cancel( object ); + tp_object_cancel( object, TRUE, userdata ); } } @@ -1894,6 +1905,6 @@ VOID WINAPI TpWaitForWork( TP_WORK *work, BOOL cancel_pending ) TRACE( "%p %u\n", work, cancel_pending ); if (cancel_pending) - tp_object_cancel( this ); + tp_object_cancel( this, FALSE, NULL ); tp_object_wait( this ); }

1 0