system/wine
system/wine
1
0
Fork 0
mirror of git://source.winehq.org/git/wine.git synced 2024-07-21 12:24:10 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

uiautomationcore: Use CRT allocation functions.

Browse source
This commit is contained in:
Alex Henrie 2023-09-01 21:36:24 -06:00 committed by Alexandre Julliard
parent f62464dd46
commit d89665847f
7 changed files with 99 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
dlls/uiautomationcore/uia_client.c
View file

@ -39,7 +39,7 @@ static void clear_node_array(struct uia_node_array *nodes)
for (i = 0; i < nodes->node_count; i++) for (i = 0; i < nodes->node_count; i++)
UiaNodeRelease(nodes->nodes[i]); UiaNodeRelease(nodes->nodes[i]);
heap_free(nodes->nodes); free(nodes->nodes);
} }
memset(nodes, 0, sizeof(*nodes)); memset(nodes, 0, sizeof(*nodes));
@ -429,7 +429,7 @@ static ULONG WINAPI uia_node_Release(IWineUiaNode *iface)
if (node->nested_node) if (node->nested_node)
uia_stop_provider_thread(); uia_stop_provider_thread();
heap_free(node); free(node);
} }
return ref; return ref;
@ -697,7 +697,7 @@ HRESULT clone_uia_node(HUIANODE in_node, HUIANODE *out_node)
} }
} }
if (!(node = heap_alloc_zero(sizeof(*node)))) if (!(node = calloc(1, sizeof(*node))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
node->IWineUiaNode_iface.lpVtbl = &uia_node_vtbl; node->IWineUiaNode_iface.lpVtbl = &uia_node_vtbl;
@ -1327,7 +1327,7 @@ static ULONG WINAPI uia_provider_Release(IWineUiaProvider *iface)
if (!ref) if (!ref)
{ {
IRawElementProviderSimple_Release(prov->elprov); IRawElementProviderSimple_Release(prov->elprov);
heap_free(prov); free(prov);
} }
return ref; return ref;
@ -1919,7 +1919,7 @@ static const IWineUiaProviderVtbl uia_provider_vtbl = {
static HRESULT create_wine_uia_provider(struct uia_node *node, IRawElementProviderSimple *elprov, static HRESULT create_wine_uia_provider(struct uia_node *node, IRawElementProviderSimple *elprov,
int prov_type) int prov_type)
{ {
struct uia_provider *prov = heap_alloc_zero(sizeof(*prov)); struct uia_provider *prov = calloc(1, sizeof(*prov));
if (!prov) if (!prov)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -1967,7 +1967,7 @@ HRESULT create_uia_node_from_elprov(IRawElementProviderSimple *elprov, HUIANODE
else else
prov_type = PROV_TYPE_MAIN; prov_type = PROV_TYPE_MAIN;
node = heap_alloc_zero(sizeof(*node)); node = calloc(1, sizeof(*node));
if (!node) if (!node)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -1980,7 +1980,7 @@ HRESULT create_uia_node_from_elprov(IRawElementProviderSimple *elprov, HUIANODE
hr = create_wine_uia_provider(node, elprov, prov_type); hr = create_wine_uia_provider(node, elprov, prov_type);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(node); free(node);
return hr; return hr;
} }
@ -2222,7 +2222,7 @@ static ULONG WINAPI uia_nested_node_provider_Release(IWineUiaProvider *iface)
{ {
IWineUiaNode_Release(prov->nested_node); IWineUiaNode_Release(prov->nested_node);
uia_stop_client_thread(); uia_stop_client_thread();
heap_free(prov); free(prov);
} }
return ref; return ref;
@ -2447,7 +2447,7 @@ static HRESULT create_wine_uia_nested_node_provider(struct uia_node *node, LRESU
} }
else else
{ {
prov = heap_alloc_zero(sizeof(*prov)); prov = calloc(1, sizeof(*prov));
if (!prov) if (!prov)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -2493,7 +2493,7 @@ HRESULT uia_node_from_lresult(LRESULT lr, HUIANODE *huianode)
HRESULT hr; HRESULT hr;
*huianode = NULL; *huianode = NULL;
node = heap_alloc_zero(sizeof(*node)); node = calloc(1, sizeof(*node));
if (!node) if (!node)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -2506,7 +2506,7 @@ HRESULT uia_node_from_lresult(LRESULT lr, HUIANODE *huianode)
hr = create_wine_uia_nested_node_provider(node, lr, FALSE); hr = create_wine_uia_nested_node_provider(node, lr, FALSE);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(node); free(node);
return hr; return hr;
} }
@ -2577,7 +2577,7 @@ HRESULT WINAPI UiaNodeFromHandle(HWND hwnd, HUIANODE *huianode)
if (!IsWindow(hwnd)) if (!IsWindow(hwnd))
return UIA_E_ELEMENTNOTAVAILABLE; return UIA_E_ELEMENTNOTAVAILABLE;
node = heap_alloc_zero(sizeof(*node)); node = calloc(1, sizeof(*node));
if (!node) if (!node)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -2590,7 +2590,7 @@ HRESULT WINAPI UiaNodeFromHandle(HWND hwnd, HUIANODE *huianode)
hr = uia_get_providers_for_hwnd(node); hr = uia_get_providers_for_hwnd(node);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(node); free(node);
return hr; return hr;
} }
@ -3515,7 +3515,7 @@ HRESULT WINAPI UiaFind(HUIANODE huianode, struct UiaFindParams *find_params, str
goto exit; goto exit;
} }
if (!(tmp_reqs = heap_alloc_zero(sizeof(*tmp_reqs) * nodes.node_count))) if (!(tmp_reqs = calloc(nodes.node_count, sizeof(*tmp_reqs))))
{ {
hr = E_OUTOFMEMORY; hr = E_OUTOFMEMORY;
goto exit; goto exit;
@ -3555,7 +3555,7 @@ HRESULT WINAPI UiaFind(HUIANODE huianode, struct UiaFindParams *find_params, str
if (nodes.node_count == 1) if (nodes.node_count == 1)
{ {
req = tmp_reqs[0]; req = tmp_reqs[0];
heap_free(tmp_reqs); free(tmp_reqs);
tmp_reqs = NULL; tmp_reqs = NULL;
} }
else else
@ -3586,7 +3586,7 @@ exit:
{ {
for (i = 0; i < nodes.node_count; i++) for (i = 0; i < nodes.node_count; i++)
SafeArrayDestroy(tmp_reqs[i]); SafeArrayDestroy(tmp_reqs[i]);
heap_free(tmp_reqs); free(tmp_reqs);
} }
if (FAILED(hr)) if (FAILED(hr))

68
dlls/uiautomationcore/uia_com_client.c
View file

@ -84,9 +84,9 @@ static ULONG WINAPI uia_or_condition_Release(IUIAutomationOrCondition *iface)
} }
} }
heap_free(uia_or_condition->child_ifaces); free(uia_or_condition->child_ifaces);
heap_free(uia_or_condition->condition.ppConditions); free(uia_or_condition->condition.ppConditions);
heap_free(uia_or_condition); free(uia_or_condition);
} }
return ref; return ref;
@ -164,21 +164,21 @@ static HRESULT create_uia_or_condition_iface(IUIAutomationCondition **out_cond,
*out_cond = NULL; *out_cond = NULL;
uia_or_condition = heap_alloc_zero(sizeof(*uia_or_condition)); uia_or_condition = calloc(1, sizeof(*uia_or_condition));
if (!uia_or_condition) if (!uia_or_condition)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
uia_or_condition->IUIAutomationOrCondition_iface.lpVtbl = &uia_or_condition_vtbl; uia_or_condition->IUIAutomationOrCondition_iface.lpVtbl = &uia_or_condition_vtbl;
uia_or_condition->ref = 1; uia_or_condition->ref = 1;
uia_or_condition->child_ifaces = heap_alloc_zero(sizeof(*in_conds) * in_cond_count); uia_or_condition->child_ifaces = calloc(in_cond_count, sizeof(*in_conds));
if (!uia_or_condition->child_ifaces) if (!uia_or_condition->child_ifaces)
{ {
IUIAutomationOrCondition_Release(&uia_or_condition->IUIAutomationOrCondition_iface); IUIAutomationOrCondition_Release(&uia_or_condition->IUIAutomationOrCondition_iface);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
uia_or_condition->condition.ppConditions = heap_alloc_zero(sizeof(*uia_or_condition->condition.ppConditions) * in_cond_count); uia_or_condition->condition.ppConditions = calloc(in_cond_count, sizeof(*uia_or_condition->condition.ppConditions));
if (!uia_or_condition->condition.ppConditions) if (!uia_or_condition->condition.ppConditions)
{ {
IUIAutomationOrCondition_Release(&uia_or_condition->IUIAutomationOrCondition_iface); IUIAutomationOrCondition_Release(&uia_or_condition->IUIAutomationOrCondition_iface);
@ -253,7 +253,7 @@ static ULONG WINAPI uia_not_condition_Release(IUIAutomationNotCondition *iface)
if (!ref) if (!ref)
{ {
IUIAutomationCondition_Release(uia_not_condition->child_iface); IUIAutomationCondition_Release(uia_not_condition->child_iface);
heap_free(uia_not_condition); free(uia_not_condition);
} }
return ref; return ref;
@ -295,7 +295,7 @@ static HRESULT create_uia_not_condition_iface(IUIAutomationCondition **out_cond,
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
uia_not_condition = heap_alloc_zero(sizeof(*uia_not_condition)); uia_not_condition = calloc(1, sizeof(*uia_not_condition));
if (!uia_not_condition) if (!uia_not_condition)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -357,7 +357,7 @@ static ULONG WINAPI uia_property_condition_Release(IUIAutomationPropertyConditio
if (!ref) if (!ref)
{ {
VariantClear(&uia_property_condition->condition.Value); VariantClear(&uia_property_condition->condition.Value);
heap_free(uia_property_condition); free(uia_property_condition);
} }
return ref; return ref;
@ -445,7 +445,7 @@ static HRESULT create_uia_property_condition_iface(IUIAutomationCondition **out_
return E_NOTIMPL; return E_NOTIMPL;
} }
uia_property_condition = heap_alloc_zero(sizeof(*uia_property_condition)); uia_property_condition = calloc(1, sizeof(*uia_property_condition));
if (!uia_property_condition) if (!uia_property_condition)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -504,7 +504,7 @@ static ULONG WINAPI uia_bool_condition_Release(IUIAutomationBoolCondition *iface
TRACE("%p, refcount %ld\n", uia_bool_condition, ref); TRACE("%p, refcount %ld\n", uia_bool_condition, ref);
if (!ref) if (!ref)
heap_free(uia_bool_condition); free(uia_bool_condition);
return ref; return ref;
} }
@ -540,7 +540,7 @@ static HRESULT create_uia_bool_condition_iface(IUIAutomationCondition **out_cond
if (!out_cond) if (!out_cond)
return E_POINTER; return E_POINTER;
uia_bool_condition = heap_alloc_zero(sizeof(*uia_bool_condition)); uia_bool_condition = calloc(1, sizeof(*uia_bool_condition));
if (!uia_bool_condition) if (!uia_bool_condition)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -673,8 +673,8 @@ static ULONG WINAPI uia_cache_request_Release(IUIAutomationCacheRequest *iface)
if (!ref) if (!ref)
{ {
IUIAutomationCondition_Release(uia_cache_request->view_condition); IUIAutomationCondition_Release(uia_cache_request->view_condition);
heap_free(uia_cache_request->prop_ids); free(uia_cache_request->prop_ids);
heap_free(uia_cache_request); free(uia_cache_request);
} }
return ref; return ref;
@ -861,7 +861,7 @@ static HRESULT create_uia_cache_request_iface(IUIAutomationCacheRequest **out_ca
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
uia_cache_request = heap_alloc_zero(sizeof(*uia_cache_request)); uia_cache_request = calloc(1, sizeof(*uia_cache_request));
if (!uia_cache_request) if (!uia_cache_request)
{ {
IUIAutomationCondition_Release(view_condition); IUIAutomationCondition_Release(view_condition);
@ -975,7 +975,7 @@ static HRESULT uia_event_handlers_add_handler(IUnknown *handler_iface, SAFEARRAY
event_map = RB_ENTRY_VALUE(rb_entry, struct uia_event_handler_map_entry, entry); event_map = RB_ENTRY_VALUE(rb_entry, struct uia_event_handler_map_entry, entry);
else else
{ {
if (!(event_map = heap_alloc_zero(sizeof(*event_map)))) if (!(event_map = calloc(1, sizeof(*event_map))))
{ {
hr = E_OUTOFMEMORY; hr = E_OUTOFMEMORY;
goto exit; goto exit;
@ -984,7 +984,7 @@ static HRESULT uia_event_handlers_add_handler(IUnknown *handler_iface, SAFEARRAY
hr = SafeArrayCopy(runtime_id, &event_map->runtime_id); hr = SafeArrayCopy(runtime_id, &event_map->runtime_id);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(event_map); free(event_map);
goto exit; goto exit;
} }
@ -1013,7 +1013,7 @@ static void uia_event_handler_destroy(struct uia_com_event *event)
UiaRemoveEvent(event->event); UiaRemoveEvent(event->event);
if (event->git_cookie) if (event->git_cookie)
unregister_interface_in_git(event->git_cookie); unregister_interface_in_git(event->git_cookie);
heap_free(event); free(event);
} }
static void uia_event_handler_map_entry_destroy(struct uia_event_handler_map_entry *entry) static void uia_event_handler_map_entry_destroy(struct uia_event_handler_map_entry *entry)
@ -1029,7 +1029,7 @@ static void uia_event_handler_map_entry_destroy(struct uia_event_handler_map_ent
rb_remove(&com_event_handlers.handler_map, &entry->entry); rb_remove(&com_event_handlers.handler_map, &entry->entry);
IUnknown_Release(entry->handler_iface); IUnknown_Release(entry->handler_iface);
SafeArrayDestroy(entry->runtime_id); SafeArrayDestroy(entry->runtime_id);
heap_free(entry); free(entry);
} }
static void uia_event_handlers_remove_handlers(IUnknown *handler_iface, SAFEARRAY *runtime_id, int event_id) static void uia_event_handlers_remove_handlers(IUnknown *handler_iface, SAFEARRAY *runtime_id, int event_id)
@ -1153,8 +1153,8 @@ static ULONG WINAPI uia_element_array_Release(IUIAutomationElementArray *iface)
IUIAutomationElement_Release(element_arr->elements[i]); IUIAutomationElement_Release(element_arr->elements[i]);
} }
} }
heap_free(element_arr->elements); free(element_arr->elements);
heap_free(element_arr); free(element_arr);
} }
return ref; return ref;
@ -1203,7 +1203,7 @@ static const IUIAutomationElementArrayVtbl uia_element_array_vtbl = {
static HRESULT create_uia_element_array_iface(IUIAutomationElementArray **iface, int elements_count) static HRESULT create_uia_element_array_iface(IUIAutomationElementArray **iface, int elements_count)
{ {
struct uia_element_array *element_arr = heap_alloc_zero(sizeof(*element_arr)); struct uia_element_array *element_arr = calloc(1, sizeof(*element_arr));
*iface = NULL; *iface = NULL;
if (!element_arr) if (!element_arr)
@ -1212,9 +1212,9 @@ static HRESULT create_uia_element_array_iface(IUIAutomationElementArray **iface,
element_arr->IUIAutomationElementArray_iface.lpVtbl = &uia_element_array_vtbl; element_arr->IUIAutomationElementArray_iface.lpVtbl = &uia_element_array_vtbl;
element_arr->ref = 1; element_arr->ref = 1;
element_arr->elements_count = elements_count; element_arr->elements_count = elements_count;
if (!(element_arr->elements = heap_alloc_zero(sizeof(*element_arr->elements) * elements_count))) if (!(element_arr->elements = calloc(elements_count, sizeof(*element_arr->elements))))
{ {
heap_free(element_arr); free(element_arr);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
@ -1293,9 +1293,9 @@ static ULONG WINAPI uia_element_Release(IUIAutomationElement9 *iface)
} }
IUnknown_Release(element->marshal); IUnknown_Release(element->marshal);
heap_free(element->cached_props); free(element->cached_props);
UiaNodeRelease(element->node); UiaNodeRelease(element->node);
heap_free(element); free(element);
} }
return ref; return ref;
@ -2539,7 +2539,7 @@ static const IUIAutomationElement9Vtbl uia_element_vtbl = {
static HRESULT create_uia_element(IUIAutomationElement **iface, BOOL from_cui8, HUIANODE node) static HRESULT create_uia_element(IUIAutomationElement **iface, BOOL from_cui8, HUIANODE node)
{ {
struct uia_element *element = heap_alloc_zero(sizeof(*element)); struct uia_element *element = calloc(1, sizeof(*element));
HRESULT hr; HRESULT hr;
*iface = NULL; *iface = NULL;
@ -2554,7 +2554,7 @@ static HRESULT create_uia_element(IUIAutomationElement **iface, BOOL from_cui8,
hr = CoCreateFreeThreadedMarshaler((IUnknown *)&element->IUIAutomationElement9_iface, &element->marshal); hr = CoCreateFreeThreadedMarshaler((IUnknown *)&element->IUIAutomationElement9_iface, &element->marshal);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(element); free(element);
return hr; return hr;
} }
@ -2603,7 +2603,7 @@ static HRESULT create_uia_element_from_cache_req(IUIAutomationElement **iface, B
{ {
LONG i; LONG i;
elem_data->cached_props = heap_alloc_zero(sizeof(*elem_data->cached_props) * cache_req->cProperties); elem_data->cached_props = calloc(cache_req->cProperties, sizeof(*elem_data->cached_props));
if (!elem_data->cached_props) if (!elem_data->cached_props)
{ {
hr = E_OUTOFMEMORY; hr = E_OUTOFMEMORY;
@ -2702,7 +2702,7 @@ static ULONG WINAPI uia_tree_walker_Release(IUIAutomationTreeWalker *iface)
if (tree_walker->default_cache_req) if (tree_walker->default_cache_req)
IUIAutomationCacheRequest_Release(tree_walker->default_cache_req); IUIAutomationCacheRequest_Release(tree_walker->default_cache_req);
IUIAutomationCondition_Release(tree_walker->nav_cond); IUIAutomationCondition_Release(tree_walker->nav_cond);
heap_free(tree_walker); free(tree_walker);
} }
return ref; return ref;
@ -2895,7 +2895,7 @@ static HRESULT create_uia_tree_walker(IUIAutomationTreeWalker **out_tree_walker,
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
tree_walker = heap_alloc_zero(sizeof(*tree_walker)); tree_walker = calloc(1, sizeof(*tree_walker));
if (!tree_walker) if (!tree_walker)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -2968,7 +2968,7 @@ static ULONG WINAPI uia_iface_Release(IUIAutomation6 *iface)
TRACE("%p, refcount %ld\n", uia_iface, ref); TRACE("%p, refcount %ld\n", uia_iface, ref);
if (!ref) if (!ref)
heap_free(uia_iface); free(uia_iface);
return ref; return ref;
} }
@ -3288,7 +3288,7 @@ static HRESULT uia_add_com_event_handler(IUIAutomation6 *iface, EVENTID event_id
if (FAILED(hr)) if (FAILED(hr))
goto exit; goto exit;
if (!(com_event = heap_alloc_zero(sizeof(*com_event)))) if (!(com_event = calloc(1, sizeof(*com_event))))
{ {
hr = E_OUTOFMEMORY; hr = E_OUTOFMEMORY;
goto exit; goto exit;
@ -3925,7 +3925,7 @@ HRESULT create_uia_iface(IUnknown **iface, BOOL is_cui8)
{ {
struct uia_iface *uia; struct uia_iface *uia;
uia = heap_alloc_zero(sizeof(*uia)); uia = calloc(1, sizeof(*uia));
if (!uia) if (!uia)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;

40
dlls/uiautomationcore/uia_event.c
View file

@ -139,7 +139,7 @@ static HRESULT uia_event_map_add_event(struct uia_event *event)
if (!(event_entry = uia_get_event_map_entry_for_event(event->event_id))) if (!(event_entry = uia_get_event_map_entry_for_event(event->event_id)))
{ {
if (!(event_entry = heap_alloc_zero(sizeof(*event_entry)))) if (!(event_entry = calloc(1, sizeof(*event_entry))))
{ {
LeaveCriticalSection(&event_map_cs); LeaveCriticalSection(&event_map_cs);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -207,7 +207,7 @@ static void uia_event_map_entry_release(struct uia_event_map_entry *entry)
IWineUiaEvent_Release(&event->IWineUiaEvent_iface); IWineUiaEvent_Release(&event->IWineUiaEvent_iface);
} }
heap_free(entry); free(entry);
} }
} }
@ -219,7 +219,7 @@ static void uia_event_map_entry_release(struct uia_event_map_entry *entry)
*/ */
static struct uia_event_args *create_uia_event_args(const struct uia_event_info *event_info) static struct uia_event_args *create_uia_event_args(const struct uia_event_info *event_info)
{ {
struct uia_event_args *args = heap_alloc_zero(sizeof(*args)); struct uia_event_args *args = calloc(1, sizeof(*args));
if (!args) if (!args)
return NULL; return NULL;
@ -234,7 +234,7 @@ static struct uia_event_args *create_uia_event_args(const struct uia_event_info
static void uia_event_args_release(struct uia_event_args *args) static void uia_event_args_release(struct uia_event_args *args)
{ {
if (!InterlockedDecrement(&args->ref)) if (!InterlockedDecrement(&args->ref))
heap_free(args); free(args);
} }
/* /*
@ -412,7 +412,7 @@ static void uia_event_thread_process_queue(struct list *event_queue)
uia_event_args_release(event->args); uia_event_args_release(event->args);
IWineUiaEvent_Release(&event->event->IWineUiaEvent_iface); IWineUiaEvent_Release(&event->event->IWineUiaEvent_iface);
heap_free(event); free(event);
} }
} }
@ -581,8 +581,8 @@ static ULONG WINAPI uia_event_Release(IWineUiaEvent *iface)
for (i = 0; i < event->event_advisers_count; i++) for (i = 0; i < event->event_advisers_count; i++)
IWineUiaEventAdviser_Release(event->event_advisers[i]); IWineUiaEventAdviser_Release(event->event_advisers[i]);
heap_free(event->event_advisers); free(event->event_advisers);
heap_free(event); free(event);
} }
return ref; return ref;
@ -626,7 +626,7 @@ static HRESULT WINAPI uia_event_advise_events(IWineUiaEvent *iface, BOOL advise_
for (i = 0; i < event->event_advisers_count; i++) for (i = 0; i < event->event_advisers_count; i++)
IWineUiaEventAdviser_Release(event->event_advisers[i]); IWineUiaEventAdviser_Release(event->event_advisers[i]);
heap_free(event->event_advisers); free(event->event_advisers);
event->event_advisers_count = event->event_advisers_arr_size = 0; event->event_advisers_count = event->event_advisers_arr_size = 0;
} }
@ -671,12 +671,12 @@ static HRESULT WINAPI uia_event_raise_event(IWineUiaEvent *iface, VARIANT in_nod
assert(event->event_type != EVENT_TYPE_SERVERSIDE); assert(event->event_type != EVENT_TYPE_SERVERSIDE);
if (!(queue_event = heap_alloc_zero(sizeof(*queue_event)))) if (!(queue_event = calloc(1, sizeof(*queue_event))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (!(args = create_uia_event_args(uia_event_info_from_id(event->event_id)))) if (!(args = create_uia_event_args(uia_event_info_from_id(event->event_id))))
{ {
heap_free(queue_event); free(queue_event);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
} }
@ -712,7 +712,7 @@ static struct uia_event *unsafe_impl_from_IWineUiaEvent(IWineUiaEvent *iface)
static HRESULT create_uia_event(struct uia_event **out_event, LONG event_cookie, int event_type) static HRESULT create_uia_event(struct uia_event **out_event, LONG event_cookie, int event_type)
{ {
struct uia_event *event = heap_alloc_zero(sizeof(*event)); struct uia_event *event = calloc(1, sizeof(*event));
*out_event = NULL; *out_event = NULL;
if (!event) if (!event)
@ -775,7 +775,7 @@ HRESULT create_serverside_uia_event(struct uia_event **out_event, LONG process_i
if (!uia_start_event_thread()) if (!uia_start_event_thread())
{ {
heap_free(event); free(event);
hr = E_FAIL; hr = E_FAIL;
goto exit; goto exit;
} }
@ -856,7 +856,7 @@ static ULONG WINAPI uia_event_adviser_Release(IWineUiaEventAdviser *iface)
WARN("Failed to revoke advise events interface from GIT\n"); WARN("Failed to revoke advise events interface from GIT\n");
} }
IRawElementProviderAdviseEvents_Release(adv_events->advise_events); IRawElementProviderAdviseEvents_Release(adv_events->advise_events);
heap_free(adv_events); free(adv_events);
} }
return ref; return ref;
@ -920,7 +920,7 @@ HRESULT uia_event_add_provider_event_adviser(IRawElementProviderAdviseEvents *ad
if (FAILED(hr)) if (FAILED(hr))
return hr; return hr;
if (!(adv_events = heap_alloc_zero(sizeof(*adv_events)))) if (!(adv_events = calloc(1, sizeof(*adv_events))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
if (prov_opts & ProviderOptions_UseComThreading) if (prov_opts & ProviderOptions_UseComThreading)
@ -929,7 +929,7 @@ HRESULT uia_event_add_provider_event_adviser(IRawElementProviderAdviseEvents *ad
&adv_events->git_cookie); &adv_events->git_cookie);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(adv_events); free(adv_events);
return hr; return hr;
} }
} }
@ -990,7 +990,7 @@ static ULONG WINAPI uia_serverside_event_adviser_Release(IWineUiaEventAdviser *i
if (!ref) if (!ref)
{ {
IWineUiaEvent_Release(adv_events->event_iface); IWineUiaEvent_Release(adv_events->event_iface);
heap_free(adv_events); free(adv_events);
} }
return ref; return ref;
} }
@ -1057,7 +1057,7 @@ HRESULT uia_event_add_serverside_event_adviser(IWineUiaEvent *serverside_event,
} }
} }
if (!(adv_events = heap_alloc_zero(sizeof(*adv_events)))) if (!(adv_events = calloc(1, sizeof(*adv_events))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
adv_events->IWineUiaEventAdviser_iface.lpVtbl = &uia_serverside_event_adviser_vtbl; adv_events->IWineUiaEventAdviser_iface.lpVtbl = &uia_serverside_event_adviser_vtbl;
@ -1280,14 +1280,14 @@ static HRESULT uia_event_invoke(HUIANODE node, HUIANODE nav_start_node, struct u
struct uia_queue_event *queue_event; struct uia_queue_event *queue_event;
HUIANODE node2, nav_start_node2; HUIANODE node2, nav_start_node2;
if (!(queue_event = heap_alloc_zero(sizeof(*queue_event)))) if (!(queue_event = calloc(1, sizeof(*queue_event))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
node2 = nav_start_node2 = NULL; node2 = nav_start_node2 = NULL;
hr = clone_uia_node(node, &node2); hr = clone_uia_node(node, &node2);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(queue_event); free(queue_event);
return hr; return hr;
} }
@ -1296,7 +1296,7 @@ static HRESULT uia_event_invoke(HUIANODE node, HUIANODE nav_start_node, struct u
hr = clone_uia_node(nav_start_node, &nav_start_node2); hr = clone_uia_node(nav_start_node, &nav_start_node2);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(queue_event); free(queue_event);
UiaNodeRelease(node2); UiaNodeRelease(node2);
return hr; return hr;
} }

14
dlls/uiautomationcore/uia_main.c
View file

@ -68,7 +68,7 @@ static ULONG WINAPI uia_object_wrapper_Release(IUnknown *iface)
if (!refcount) if (!refcount)
{ {
IUnknown_Release(wrapper->marshaler); IUnknown_Release(wrapper->marshaler);
heap_free(wrapper); free(wrapper);
} }
return refcount; return refcount;
@ -92,7 +92,7 @@ static HRESULT create_uia_object_wrapper(IUnknown *reserved, void **ppv)
TRACE("%p, %p\n", reserved, ppv); TRACE("%p, %p\n", reserved, ppv);
wrapper = heap_alloc(sizeof(*wrapper)); wrapper = calloc(1, sizeof(*wrapper));
if (!wrapper) if (!wrapper)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -102,7 +102,7 @@ static HRESULT create_uia_object_wrapper(IUnknown *reserved, void **ppv)
if (FAILED(hr = CoCreateFreeThreadedMarshaler(&wrapper->IUnknown_iface, &wrapper->marshaler))) if (FAILED(hr = CoCreateFreeThreadedMarshaler(&wrapper->IUnknown_iface, &wrapper->marshaler)))
{ {
heap_free(wrapper); free(wrapper);
return hr; return hr;
} }
@ -193,7 +193,7 @@ ULONG WINAPI hwnd_host_provider_Release(IRawElementProviderSimple *iface)
TRACE("%p, refcount %ld\n", iface, refcount); TRACE("%p, refcount %ld\n", iface, refcount);
if (!refcount) if (!refcount)
heap_free(host_prov); free(host_prov);
return refcount; return refcount;
} }
@ -370,7 +370,7 @@ HRESULT WINAPI UiaHostProviderFromHwnd(HWND hwnd, IRawElementProviderSimple **pr
if (!IsWindow(hwnd) || !provider) if (!IsWindow(hwnd) || !provider)
return E_INVALIDARG; return E_INVALIDARG;
host_prov = heap_alloc(sizeof(*host_prov)); host_prov = calloc(1, sizeof(*host_prov));
if (!host_prov) if (!host_prov)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -446,7 +446,7 @@ static ULONG WINAPI uia_cf_Release(IClassFactory *iface)
TRACE("%p, refcount %ld\n", cf, ref); TRACE("%p, refcount %ld\n", cf, ref);
if (!ref) if (!ref)
heap_free(cf); free(cf);
return ref; return ref;
} }
@ -496,7 +496,7 @@ static const IClassFactoryVtbl uia_cf_Vtbl =
static inline HRESULT create_uia_cf(REFCLSID clsid, REFIID riid, void **ppv) static inline HRESULT create_uia_cf(REFCLSID clsid, REFIID riid, void **ppv)
{ {
struct uia_cf *cf = heap_alloc_zero(sizeof(*cf)); struct uia_cf *cf = calloc(1, sizeof(*cf));
HRESULT hr; HRESULT hr;
*ppv = NULL; *ppv = NULL;

6
dlls/uiautomationcore/uia_private.h
View file

@ -22,7 +22,6 @@
#include "uia_classes.h" #include "uia_classes.h"
#include "wine/list.h" #include "wine/list.h"
#include "wine/rbtree.h" #include "wine/rbtree.h"
#include "wine/heap.h"
extern HMODULE huia_module DECLSPEC_HIDDEN; extern HMODULE huia_module DECLSPEC_HIDDEN;
@ -187,10 +186,7 @@ static inline BOOL uia_array_reserve(void **elements, SIZE_T *capacity, SIZE_T c
if (new_capacity < count) if (new_capacity < count)
new_capacity = count; new_capacity = count;
if (!*elements) new_elements = _recalloc(*elements, new_capacity, size);
new_elements = heap_alloc_zero(new_capacity * size);
else
new_elements = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *elements, new_capacity * size);
if (!new_elements) if (!new_elements)
return FALSE; return FALSE;

20
dlls/uiautomationcore/uia_provider.c
View file

@ -342,7 +342,7 @@ static HRESULT msaa_acc_get_child_pos(IAccessible *acc, IAccessible **out_parent
return hr; return hr;
} }
children = heap_alloc_zero(sizeof(*children) * child_count); children = calloc(child_count, sizeof(*children));
if (!children) if (!children)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -396,7 +396,7 @@ exit:
IAccessible_Release(children[i]); IAccessible_Release(children[i]);
} }
heap_free(children); free(children);
return hr; return hr;
} }
@ -572,7 +572,7 @@ ULONG WINAPI msaa_provider_Release(IRawElementProviderSimple *iface)
IAccessible_Release(msaa_prov->parent); IAccessible_Release(msaa_prov->parent);
if (msaa_prov->ia2) if (msaa_prov->ia2)
IAccessible2_Release(msaa_prov->ia2); IAccessible2_Release(msaa_prov->ia2);
heap_free(msaa_prov); free(msaa_prov);
} }
return refcount; return refcount;
@ -1136,7 +1136,7 @@ static const ILegacyIAccessibleProviderVtbl msaa_acc_provider_vtbl = {
HRESULT create_msaa_provider(IAccessible *acc, LONG child_id, HWND hwnd, BOOL known_root_acc, HRESULT create_msaa_provider(IAccessible *acc, LONG child_id, HWND hwnd, BOOL known_root_acc,
IRawElementProviderSimple **elprov) IRawElementProviderSimple **elprov)
{ {
struct msaa_provider *msaa_prov = heap_alloc_zero(sizeof(*msaa_prov)); struct msaa_provider *msaa_prov = calloc(1, sizeof(*msaa_prov));
if (!msaa_prov) if (!msaa_prov)
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -1337,7 +1337,7 @@ static ULONG WINAPI base_hwnd_provider_Release(IRawElementProviderSimple *iface)
TRACE("%p, refcount %ld\n", iface, refcount); TRACE("%p, refcount %ld\n", iface, refcount);
if (!refcount) if (!refcount)
heap_free(base_hwnd_prov); free(base_hwnd_prov);
return refcount; return refcount;
} }
@ -1629,7 +1629,7 @@ HRESULT create_base_hwnd_provider(HWND hwnd, IRawElementProviderSimple **elprov)
if (!IsWindow(hwnd)) if (!IsWindow(hwnd))
return UIA_E_ELEMENTNOTAVAILABLE; return UIA_E_ELEMENTNOTAVAILABLE;
if (!(base_hwnd_prov = heap_alloc_zero(sizeof(*base_hwnd_prov)))) if (!(base_hwnd_prov = calloc(1, sizeof(*base_hwnd_prov))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
base_hwnd_prov->IRawElementProviderSimple_iface.lpVtbl = &base_hwnd_provider_vtbl; base_hwnd_prov->IRawElementProviderSimple_iface.lpVtbl = &base_hwnd_provider_vtbl;
@ -1695,7 +1695,7 @@ void uia_provider_thread_remove_node(HUIANODE node)
{ {
rb_remove(&provider_thread.node_map, &node_data->map->entry); rb_remove(&provider_thread.node_map, &node_data->map->entry);
SafeArrayDestroy(node_data->map->runtime_id); SafeArrayDestroy(node_data->map->runtime_id);
heap_free(node_data->map); free(node_data->map);
} }
node_data->map = NULL; node_data->map = NULL;
} }
@ -1736,7 +1736,7 @@ static void uia_provider_thread_disconnect_node(SAFEARRAY *sa)
rb_remove(&provider_thread.node_map, &prov_map->entry); rb_remove(&provider_thread.node_map, &prov_map->entry);
SafeArrayDestroy(prov_map->runtime_id); SafeArrayDestroy(prov_map->runtime_id);
heap_free(prov_map); free(prov_map);
} }
exit: exit:
@ -1768,7 +1768,7 @@ static HRESULT uia_provider_thread_add_node(HUIANODE node, SAFEARRAY *rt_id)
prov_map = RB_ENTRY_VALUE(rb_entry, struct uia_provider_thread_map_entry, entry); prov_map = RB_ENTRY_VALUE(rb_entry, struct uia_provider_thread_map_entry, entry);
else else
{ {
prov_map = heap_alloc_zero(sizeof(*prov_map)); prov_map = calloc(1, sizeof(*prov_map));
if (!prov_map) if (!prov_map)
{ {
hr = E_OUTOFMEMORY; hr = E_OUTOFMEMORY;
@ -1778,7 +1778,7 @@ static HRESULT uia_provider_thread_add_node(HUIANODE node, SAFEARRAY *rt_id)
hr = SafeArrayCopy(rt_id, &prov_map->runtime_id); hr = SafeArrayCopy(rt_id, &prov_map->runtime_id);
if (FAILED(hr)) if (FAILED(hr))
{ {
heap_free(prov_map); free(prov_map);
goto exit; goto exit;
} }
list_init(&prov_map->nodes_list); list_init(&prov_map->nodes_list);

22
dlls/uiautomationcore/uia_utils.c
View file

@ -149,7 +149,7 @@ static void uia_condition_destroy(struct UiaCondition *cond)
for (i = 0; i < and_or_cond->cConditions; i++) for (i = 0; i < and_or_cond->cConditions; i++)
uia_condition_destroy(and_or_cond->ppConditions[i]); uia_condition_destroy(and_or_cond->ppConditions[i]);
heap_free(and_or_cond->ppConditions); free(and_or_cond->ppConditions);
break; break;
} }
@ -157,7 +157,7 @@ static void uia_condition_destroy(struct UiaCondition *cond)
break; break;
} }
heap_free(cond); free(cond);
} }
static HRESULT uia_condition_clone(struct UiaCondition **dst, struct UiaCondition *src) static HRESULT uia_condition_clone(struct UiaCondition **dst, struct UiaCondition *src)
@ -169,7 +169,7 @@ static HRESULT uia_condition_clone(struct UiaCondition **dst, struct UiaConditio
{ {
case ConditionType_True: case ConditionType_True:
case ConditionType_False: case ConditionType_False:
if (!(*dst = heap_alloc_zero(sizeof(**dst)))) if (!(*dst = calloc(1, sizeof(**dst))))
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
(*dst)->ConditionType = src->ConditionType; (*dst)->ConditionType = src->ConditionType;
@ -177,7 +177,7 @@ static HRESULT uia_condition_clone(struct UiaCondition **dst, struct UiaConditio
case ConditionType_Property: case ConditionType_Property:
{ {
struct UiaPropertyCondition *prop_cond = heap_alloc_zero(sizeof(*prop_cond)); struct UiaPropertyCondition *prop_cond = calloc(1, sizeof(*prop_cond));
struct UiaPropertyCondition *src_cond = (struct UiaPropertyCondition *)src; struct UiaPropertyCondition *src_cond = (struct UiaPropertyCondition *)src;
if (!prop_cond) if (!prop_cond)
@ -194,7 +194,7 @@ static HRESULT uia_condition_clone(struct UiaCondition **dst, struct UiaConditio
case ConditionType_Not: case ConditionType_Not:
{ {
struct UiaNotCondition *not_cond = heap_alloc_zero(sizeof(*not_cond)); struct UiaNotCondition *not_cond = calloc(1, sizeof(*not_cond));
struct UiaNotCondition *src_cond = (struct UiaNotCondition *)src; struct UiaNotCondition *src_cond = (struct UiaNotCondition *)src;
if (!not_cond) if (!not_cond)
@ -209,7 +209,7 @@ static HRESULT uia_condition_clone(struct UiaCondition **dst, struct UiaConditio
case ConditionType_And: case ConditionType_And:
case ConditionType_Or: case ConditionType_Or:
{ {
struct UiaAndOrCondition *and_or_cond = heap_alloc_zero(sizeof(*and_or_cond)); struct UiaAndOrCondition *and_or_cond = calloc(1, sizeof(*and_or_cond));
struct UiaAndOrCondition *src_cond = (struct UiaAndOrCondition *)src; struct UiaAndOrCondition *src_cond = (struct UiaAndOrCondition *)src;
int i; int i;
@ -218,7 +218,7 @@ static HRESULT uia_condition_clone(struct UiaCondition **dst, struct UiaConditio
*dst = (struct UiaCondition *)and_or_cond; *dst = (struct UiaCondition *)and_or_cond;
and_or_cond->ConditionType = src_cond->ConditionType; and_or_cond->ConditionType = src_cond->ConditionType;
and_or_cond->ppConditions = heap_alloc_zero(sizeof(*and_or_cond->ppConditions) * src_cond->cConditions); and_or_cond->ppConditions = calloc(src_cond->cConditions, sizeof(*and_or_cond->ppConditions));
if (!and_or_cond->ppConditions) if (!and_or_cond->ppConditions)
{ {
hr = E_OUTOFMEMORY; hr = E_OUTOFMEMORY;
@ -257,8 +257,8 @@ exit:
void uia_cache_request_destroy(struct UiaCacheRequest *cache_req) void uia_cache_request_destroy(struct UiaCacheRequest *cache_req)
{ {
uia_condition_destroy(cache_req->pViewCondition); uia_condition_destroy(cache_req->pViewCondition);
heap_free(cache_req->pProperties); free(cache_req->pProperties);
heap_free(cache_req->pPatterns); free(cache_req->pPatterns);
} }
HRESULT uia_cache_request_clone(struct UiaCacheRequest *dst, struct UiaCacheRequest *src) HRESULT uia_cache_request_clone(struct UiaCacheRequest *dst, struct UiaCacheRequest *src)
@ -273,7 +273,7 @@ HRESULT uia_cache_request_clone(struct UiaCacheRequest *dst, struct UiaCacheRequ
dst->automationElementMode = src->automationElementMode; dst->automationElementMode = src->automationElementMode;
if (src->cProperties) if (src->cProperties)
{ {
if (!(dst->pProperties = heap_alloc_zero(sizeof(*dst->pProperties) * src->cProperties))) if (!(dst->pProperties = calloc(src->cProperties, sizeof(*dst->pProperties))))
{ {
uia_cache_request_destroy(dst); uia_cache_request_destroy(dst);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;
@ -285,7 +285,7 @@ HRESULT uia_cache_request_clone(struct UiaCacheRequest *dst, struct UiaCacheRequ
if (src->cPatterns) if (src->cPatterns)
{ {
if (!(dst->pPatterns = heap_alloc_zero(sizeof(*dst->pPatterns) * src->cPatterns))) if (!(dst->pPatterns = calloc(src->cPatterns, sizeof(*dst->pPatterns))))
{ {
uia_cache_request_destroy(dst); uia_cache_request_destroy(dst);
return E_OUTOFMEMORY; return E_OUTOFMEMORY;