[PATCH 5/5] d2d1: Use the global memory allocation helpers.
Henri Verbeet
hverbeet at codeweavers.com
Tue Jan 30 06:24:39 CST 2018
Signed-off-by: Henri Verbeet <hverbeet at codeweavers.com>
---
dlls/d2d1/bitmap.c | 14 +++++-----
dlls/d2d1/bitmap_render_target.c | 2 +-
dlls/d2d1/brush.c | 29 ++++++++++----------
dlls/d2d1/d2d1_private.h | 1 +
dlls/d2d1/dc_render_target.c | 2 +-
dlls/d2d1/factory.c | 32 +++++++++++-----------
dlls/d2d1/geometry.c | 57 ++++++++++++++++++----------------------
dlls/d2d1/hwnd_render_target.c | 2 +-
dlls/d2d1/layer.c | 4 +--
dlls/d2d1/mesh.c | 4 +--
dlls/d2d1/render_target.c | 20 +++++++-------
dlls/d2d1/state_block.c | 2 +-
dlls/d2d1/stroke.c | 6 ++---
dlls/d2d1/wic_render_target.c | 2 +-
include/wine/heap.h | 2 +-
15 files changed, 88 insertions(+), 91 deletions(-)
diff --git a/dlls/d2d1/bitmap.c b/dlls/d2d1/bitmap.c
index b03482a..43ed094 100644
--- a/dlls/d2d1/bitmap.c
+++ b/dlls/d2d1/bitmap.c
@@ -70,7 +70,7 @@ static ULONG STDMETHODCALLTYPE d2d_bitmap_Release(ID2D1Bitmap *iface)
{
ID3D10ShaderResourceView_Release(bitmap->view);
ID2D1Factory_Release(bitmap->factory);
- HeapFree(GetProcessHeap(), 0, bitmap);
+ heap_free(bitmap);
}
return refcount;
@@ -286,7 +286,7 @@ HRESULT d2d_bitmap_create(ID2D1Factory *factory, ID3D10Device *device, D2D1_SIZE
return hr;
}
- if ((*bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**bitmap))))
+ if ((*bitmap = heap_alloc_zero(sizeof(**bitmap))))
{
d2d_bitmap_init(*bitmap, factory, view, size, desc);
TRACE("Created bitmap %p.\n", *bitmap);
@@ -340,7 +340,7 @@ HRESULT d2d_bitmap_create_shared(ID2D1RenderTarget *render_target, ID3D10Device
goto failed;
}
- if (!(*bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**bitmap))))
+ if (!(*bitmap = heap_alloc_zero(sizeof(**bitmap))))
{
hr = E_OUTOFMEMORY;
goto failed;
@@ -386,7 +386,7 @@ HRESULT d2d_bitmap_create_shared(ID2D1RenderTarget *render_target, ID3D10Device
return hr;
}
- if (!(*bitmap = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**bitmap))))
+ if (!(*bitmap = heap_alloc_zero(sizeof(**bitmap))))
{
ID3D10ShaderResourceView_Release(view);
return E_OUTOFMEMORY;
@@ -510,7 +510,7 @@ HRESULT d2d_bitmap_create_from_wic_bitmap(ID2D1Factory *factory, ID3D10Device *d
pitch = ((bpp * size.width) + 15) & ~15;
data_size = pitch * size.height;
- if (!(data = HeapAlloc(GetProcessHeap(), 0, data_size)))
+ if (!(data = heap_alloc(data_size)))
return E_OUTOFMEMORY;
rect.X = 0;
@@ -520,13 +520,13 @@ HRESULT d2d_bitmap_create_from_wic_bitmap(ID2D1Factory *factory, ID3D10Device *d
if (FAILED(hr = IWICBitmapSource_CopyPixels(bitmap_source, &rect, pitch, data_size, data)))
{
WARN("Failed to copy bitmap pixels, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, data);
+ heap_free(data);
return hr;
}
hr = d2d_bitmap_create(factory, device, size, data, pitch, &bitmap_desc, bitmap);
- HeapFree(GetProcessHeap(), 0, data);
+ heap_free(data);
return hr;
}
diff --git a/dlls/d2d1/bitmap_render_target.c b/dlls/d2d1/bitmap_render_target.c
index 105caa9..de58872 100644
--- a/dlls/d2d1/bitmap_render_target.c
+++ b/dlls/d2d1/bitmap_render_target.c
@@ -75,7 +75,7 @@ static ULONG STDMETHODCALLTYPE d2d_bitmap_render_target_Release(ID2D1BitmapRende
{
ID2D1RenderTarget_Release(render_target->dxgi_target);
ID2D1Bitmap_Release(render_target->bitmap);
- HeapFree(GetProcessHeap(), 0, render_target);
+ heap_free(render_target);
}
return refcount;
diff --git a/dlls/d2d1/brush.c b/dlls/d2d1/brush.c
index ba07006..6759019 100644
--- a/dlls/d2d1/brush.c
+++ b/dlls/d2d1/brush.c
@@ -67,10 +67,10 @@ static ULONG STDMETHODCALLTYPE d2d_gradient_Release(ID2D1GradientStopCollection
if (!refcount)
{
- HeapFree(GetProcessHeap(), 0, gradient->stops);
+ heap_free(gradient->stops);
ID3D10ShaderResourceView_Release(gradient->view);
ID2D1Factory_Release(gradient->factory);
- HeapFree(GetProcessHeap(), 0, gradient);
+ heap_free(gradient);
}
return refcount;
@@ -142,7 +142,7 @@ HRESULT d2d_gradient_create(ID2D1Factory *factory, ID3D10Device *device, const D
unsigned int i;
HRESULT hr;
- if (!(data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, 2 * stop_count * sizeof(*data))))
+ if (!(data = heap_alloc_zero(2 * stop_count * sizeof(*data))))
{
ERR("Failed to allocate data.\n");
return E_OUTOFMEMORY;
@@ -168,7 +168,7 @@ HRESULT d2d_gradient_create(ID2D1Factory *factory, ID3D10Device *device, const D
buffer_data.SysMemSlicePitch = 0;
hr = ID3D10Device_CreateBuffer(device, &buffer_desc, &buffer_data, &buffer);
- HeapFree(GetProcessHeap(), 0, data);
+ heap_free(data);
if (FAILED(hr))
{
ERR("Failed to create buffer, hr %#x.\n", hr);
@@ -188,7 +188,7 @@ HRESULT d2d_gradient_create(ID2D1Factory *factory, ID3D10Device *device, const D
return hr;
}
- if (!(*gradient = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**gradient))))
+ if (!(*gradient = heap_alloc_zero(sizeof(**gradient))))
{
ID3D10ShaderResourceView_Release(view);
return E_OUTOFMEMORY;
@@ -205,10 +205,10 @@ HRESULT d2d_gradient_create(ID2D1Factory *factory, ID3D10Device *device, const D
(*gradient)->view = view;
(*gradient)->stop_count = stop_count;
- if (!((*gradient)->stops = HeapAlloc(GetProcessHeap(), 0, stop_count * sizeof(*stops))))
+ if (!((*gradient)->stops = heap_alloc(stop_count * sizeof(*stops))))
{
ID3D10ShaderResourceView_Release(view);
- HeapFree(GetProcessHeap(), 0, *gradient);
+ heap_free(*gradient);
return E_OUTOFMEMORY;
}
memcpy((*gradient)->stops, stops, stop_count * sizeof(*stops));
@@ -233,7 +233,7 @@ static void d2d_gradient_bind(struct d2d_gradient *gradient, ID3D10Device *devic
static void d2d_brush_destroy(struct d2d_brush *brush)
{
ID2D1Factory_Release(brush->factory);
- HeapFree(GetProcessHeap(), 0, brush);
+ heap_free(brush);
}
static void d2d_brush_init(struct d2d_brush *brush, ID2D1Factory *factory,
@@ -386,7 +386,7 @@ static const struct ID2D1SolidColorBrushVtbl d2d_solid_color_brush_vtbl =
HRESULT d2d_solid_color_brush_create(ID2D1Factory *factory, const D2D1_COLOR_F *color,
const D2D1_BRUSH_PROPERTIES *desc, struct d2d_brush **brush)
{
- if (!(*brush = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**brush))))
+ if (!(*brush = heap_alloc_zero(sizeof(**brush))))
return E_OUTOFMEMORY;
d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_SOLID, desc,
@@ -566,10 +566,11 @@ static const struct ID2D1LinearGradientBrushVtbl d2d_linear_gradient_brush_vtbl
d2d_linear_gradient_brush_GetGradientStopCollection,
};
-HRESULT d2d_linear_gradient_brush_create(ID2D1Factory *factory, const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc,
- const D2D1_BRUSH_PROPERTIES *brush_desc, ID2D1GradientStopCollection *gradient, struct d2d_brush **brush)
+HRESULT d2d_linear_gradient_brush_create(ID2D1Factory *factory,
+ const D2D1_LINEAR_GRADIENT_BRUSH_PROPERTIES *gradient_brush_desc, const D2D1_BRUSH_PROPERTIES *brush_desc,
+ ID2D1GradientStopCollection *gradient, struct d2d_brush **brush)
{
- if (!(*brush = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**brush))))
+ if (!(*brush = heap_alloc_zero(sizeof(**brush))))
return E_OUTOFMEMORY;
d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_LINEAR, brush_desc,
@@ -798,7 +799,7 @@ HRESULT d2d_radial_gradient_brush_create(ID2D1Factory *factory,
{
struct d2d_brush *b;
- if (!(b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*b))))
+ if (!(b = heap_alloc_zero(sizeof(*b))))
return E_OUTOFMEMORY;
d2d_brush_init(b, factory, D2D_BRUSH_TYPE_RADIAL, brush_desc, (ID2D1BrushVtbl *)&d2d_radial_gradient_brush_vtbl);
@@ -1034,7 +1035,7 @@ static const struct ID2D1BitmapBrushVtbl d2d_bitmap_brush_vtbl =
HRESULT d2d_bitmap_brush_create(ID2D1Factory *factory, ID2D1Bitmap *bitmap, const D2D1_BITMAP_BRUSH_PROPERTIES *bitmap_brush_desc,
const D2D1_BRUSH_PROPERTIES *brush_desc, struct d2d_brush **brush)
{
- if (!(*brush = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**brush))))
+ if (!(*brush = heap_alloc_zero(sizeof(**brush))))
return E_OUTOFMEMORY;
d2d_brush_init(*brush, factory, D2D_BRUSH_TYPE_BITMAP,
diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h
index f876cbf..caeb4b9 100644
--- a/dlls/d2d1/d2d1_private.h
+++ b/dlls/d2d1/d2d1_private.h
@@ -20,6 +20,7 @@
#define __WINE_D2D1_PRIVATE_H
#include "wine/debug.h"
+#include "wine/heap.h"
#include <assert.h>
#include <limits.h>
diff --git a/dlls/d2d1/dc_render_target.c b/dlls/d2d1/dc_render_target.c
index cdd43b12..d5e4f47 100644
--- a/dlls/d2d1/dc_render_target.c
+++ b/dlls/d2d1/dc_render_target.c
@@ -94,7 +94,7 @@ static ULONG STDMETHODCALLTYPE d2d_dc_render_target_Release(ID2D1DCRenderTarget
{
ID2D1RenderTarget_Release(render_target->dxgi_target);
IDXGISurface1_Release(render_target->dxgi_surface);
- HeapFree(GetProcessHeap(), 0, render_target);
+ heap_free(render_target);
}
return refcount;
diff --git a/dlls/d2d1/factory.c b/dlls/d2d1/factory.c
index f202332..9bacc85 100644
--- a/dlls/d2d1/factory.c
+++ b/dlls/d2d1/factory.c
@@ -104,7 +104,7 @@ static ULONG STDMETHODCALLTYPE d2d_factory_Release(ID2D1Factory1 *iface)
{
if (factory->device)
ID3D10Device1_Release(factory->device);
- HeapFree(GetProcessHeap(), 0, factory);
+ heap_free(factory);
}
return refcount;
@@ -137,13 +137,13 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreateRectangleGeometry(ID2D1Factor
TRACE("iface %p, rect %s, geometry %p.\n", iface, debug_d2d_rect_f(rect), geometry);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = d2d_rectangle_geometry_init(object, (ID2D1Factory *)iface, rect)))
{
WARN("Failed to initialize rectangle geometry, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
@@ -187,7 +187,7 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreateTransformedGeometry(ID2D1Fact
TRACE("iface %p, src_geometry %p, transform %p, transformed_geometry %p.\n",
iface, src_geometry, transform, transformed_geometry);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
d2d_transformed_geometry_init(object, (ID2D1Factory *)iface, src_geometry, transform);
@@ -204,7 +204,7 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreatePathGeometry(ID2D1Factory1 *i
TRACE("iface %p, geometry %p.\n", iface, geometry);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
d2d_path_geometry_init(object, (ID2D1Factory *)iface);
@@ -225,13 +225,13 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreateStrokeStyle(ID2D1Factory1 *if
TRACE("iface %p, desc %p, dashes %p, dash_count %u, stroke_style %p.\n",
iface, desc, dashes, dash_count, stroke_style);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = d2d_stroke_style_init(object, (ID2D1Factory *)iface, desc, dashes, dash_count)))
{
WARN("Failed to initialize stroke style, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
@@ -250,7 +250,7 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDrawingStateBlock(ID2D1Factor
TRACE("iface %p, desc %p, text_rendering_params %p, state_block %p.\n",
iface, desc, text_rendering_params, state_block);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
d2d_state_block_init(object, (ID2D1Factory *)iface, desc, text_rendering_params);
@@ -283,19 +283,19 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreateWicBitmapRenderTarget(ID2D1Fa
TRACE("iface %p, target %p, desc %p, render_target %p.\n", iface, target, desc, render_target);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = d2d_factory_get_device(factory, &device)))
{
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
if (FAILED(hr = d2d_wic_render_target_init(object, (ID2D1Factory *)iface, device, target, desc)))
{
WARN("Failed to initialize render target, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
@@ -319,13 +319,13 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreateHwndRenderTarget(ID2D1Factory
if (FAILED(hr = d2d_factory_get_device(factory, &device)))
return hr;
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = d2d_hwnd_render_target_init(object, (ID2D1Factory *)iface, device, desc, hwnd_rt_desc)))
{
WARN("Failed to initialize render target, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
@@ -356,13 +356,13 @@ static HRESULT STDMETHODCALLTYPE d2d_factory_CreateDCRenderTarget(ID2D1Factory1
if (FAILED(hr = d2d_factory_get_device(factory, &device)))
return hr;
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = d2d_dc_render_target_init(object, (ID2D1Factory *)iface, device, desc)))
{
WARN("Failed to initialize render target, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
@@ -512,7 +512,7 @@ HRESULT WINAPI D2D1CreateFactory(D2D1_FACTORY_TYPE factory_type, REFIID iid,
TRACE("factory_type %#x, iid %s, factory_options %p, factory %p.\n",
factory_type, debugstr_guid(iid), factory_options, factory);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
d2d_factory_init(object, factory_type, factory_options);
diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c
index ab5a0b5..88beee2 100644
--- a/dlls/d2d1/geometry.c
+++ b/dlls/d2d1/geometry.c
@@ -581,12 +581,7 @@ static BOOL d2d_array_reserve(void **elements, size_t *capacity, size_t element_
if (new_capacity < element_count)
new_capacity = max_capacity;
- if (*elements)
- new_elements = HeapReAlloc(GetProcessHeap(), 0, *elements, new_capacity * element_size);
- else
- new_elements = HeapAlloc(GetProcessHeap(), 0, new_capacity * element_size);
-
- if (!new_elements)
+ if (!(new_elements = heap_realloc(*elements, new_capacity * element_size)))
return FALSE;
*elements = new_elements;
@@ -1438,7 +1433,7 @@ static BOOL d2d_cdt_generate_faces(const struct d2d_cdt *cdt, struct d2d_geometr
return TRUE;
fail:
- HeapFree(GetProcessHeap(), 0, geometry->fill.faces);
+ heap_free(geometry->fill.faces);
geometry->fill.faces = NULL;
geometry->fill.faces_size = 0;
geometry->fill.face_count = 0;
@@ -2035,7 +2030,7 @@ static BOOL d2d_geometry_intersect_self(struct d2d_geometry *geometry)
ret = d2d_geometry_apply_intersections(geometry, &intersections);
done:
- HeapFree(GetProcessHeap(), 0, intersections.intersections);
+ heap_free(intersections.intersections);
return ret;
}
@@ -2057,7 +2052,7 @@ static HRESULT d2d_path_geometry_triangulate(struct d2d_geometry *geometry)
return S_OK;
}
- if (!(vertices = HeapAlloc(GetProcessHeap(), 0, vertex_count * sizeof(*vertices))))
+ if (!(vertices = heap_alloc(vertex_count * sizeof(*vertices))))
return E_OUTOFMEMORY;
for (i = 0, j = 0; i < geometry->u.path.figure_count; ++i)
@@ -2091,14 +2086,14 @@ static HRESULT d2d_path_geometry_triangulate(struct d2d_geometry *geometry)
if (!d2d_cdt_generate_faces(&cdt, geometry))
goto fail;
- HeapFree(GetProcessHeap(), 0, cdt.edges);
+ heap_free(cdt.edges);
return S_OK;
fail:
geometry->fill.vertices = NULL;
geometry->fill.vertex_count = 0;
- HeapFree(GetProcessHeap(), 0, vertices);
- HeapFree(GetProcessHeap(), 0, cdt.edges);
+ heap_free(vertices);
+ heap_free(cdt.edges);
return E_FAIL;
}
@@ -2368,13 +2363,13 @@ static BOOL d2d_geometry_add_figure_outline(struct d2d_geometry *geometry,
static void d2d_geometry_cleanup(struct d2d_geometry *geometry)
{
- HeapFree(GetProcessHeap(), 0, geometry->outline.bezier_faces);
- HeapFree(GetProcessHeap(), 0, geometry->outline.beziers);
- HeapFree(GetProcessHeap(), 0, geometry->outline.faces);
- HeapFree(GetProcessHeap(), 0, geometry->outline.vertices);
- HeapFree(GetProcessHeap(), 0, geometry->fill.bezier_vertices);
- HeapFree(GetProcessHeap(), 0, geometry->fill.faces);
- HeapFree(GetProcessHeap(), 0, geometry->fill.vertices);
+ heap_free(geometry->outline.bezier_faces);
+ heap_free(geometry->outline.beziers);
+ heap_free(geometry->outline.faces);
+ heap_free(geometry->outline.vertices);
+ heap_free(geometry->fill.bezier_vertices);
+ heap_free(geometry->fill.faces);
+ heap_free(geometry->fill.vertices);
ID2D1Factory_Release(geometry->factory);
}
@@ -2604,11 +2599,11 @@ static void d2d_path_geometry_free_figures(struct d2d_geometry *geometry)
for (i = 0; i < geometry->u.path.figure_count; ++i)
{
- HeapFree(GetProcessHeap(), 0, geometry->u.path.figures[i].bezier_controls);
- HeapFree(GetProcessHeap(), 0, geometry->u.path.figures[i].original_bezier_controls);
- HeapFree(GetProcessHeap(), 0, geometry->u.path.figures[i].vertices);
+ heap_free(geometry->u.path.figures[i].bezier_controls);
+ heap_free(geometry->u.path.figures[i].original_bezier_controls);
+ heap_free(geometry->u.path.figures[i].vertices);
}
- HeapFree(GetProcessHeap(), 0, geometry->u.path.figures);
+ heap_free(geometry->u.path.figures);
geometry->u.path.figures = NULL;
geometry->u.path.figures_size = 0;
}
@@ -2824,8 +2819,8 @@ static HRESULT d2d_geometry_resolve_beziers(struct d2d_geometry *geometry)
geometry->fill.bezier_vertex_count += 3 * geometry->u.path.figures[i].bezier_control_count;
}
- if (!(geometry->fill.bezier_vertices = HeapAlloc(GetProcessHeap(), 0,
- geometry->fill.bezier_vertex_count * sizeof(*geometry->fill.bezier_vertices))))
+ if (!(geometry->fill.bezier_vertices = heap_alloc(geometry->fill.bezier_vertex_count
+ * sizeof(*geometry->fill.bezier_vertices))))
{
ERR("Failed to allocate bezier vertices array.\n");
geometry->fill.bezier_vertex_count = 0;
@@ -2889,7 +2884,7 @@ static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_Close(ID2D1GeometrySink *ifac
{
struct d2d_figure *figure = &geometry->u.path.figures[i];
size_t size = figure->bezier_control_count * sizeof(*figure->original_bezier_controls);
- if (!(figure->original_bezier_controls = HeapAlloc(GetProcessHeap(), 0, size)))
+ if (!(figure->original_bezier_controls = heap_alloc(size)))
goto done;
memcpy(figure->original_bezier_controls, figure->bezier_controls, size);
}
@@ -2904,7 +2899,7 @@ static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_Close(ID2D1GeometrySink *ifac
done:
if (FAILED(hr))
{
- HeapFree(GetProcessHeap(), 0, geometry->fill.bezier_vertices);
+ heap_free(geometry->fill.bezier_vertices);
geometry->fill.bezier_vertex_count = 0;
d2d_path_geometry_free_figures(geometry);
geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
@@ -3063,7 +3058,7 @@ static ULONG STDMETHODCALLTYPE d2d_path_geometry_Release(ID2D1PathGeometry *ifac
{
d2d_path_geometry_free_figures(geometry);
d2d_geometry_cleanup(geometry);
- HeapFree(GetProcessHeap(), 0, geometry);
+ heap_free(geometry);
}
return refcount;
@@ -3579,7 +3574,7 @@ static ULONG STDMETHODCALLTYPE d2d_rectangle_geometry_Release(ID2D1RectangleGeom
if (!refcount)
{
d2d_geometry_cleanup(geometry);
- HeapFree(GetProcessHeap(), 0, geometry);
+ heap_free(geometry);
}
return refcount;
@@ -3821,7 +3816,7 @@ HRESULT d2d_rectangle_geometry_init(struct d2d_geometry *geometry, ID2D1Factory
d2d_geometry_init(geometry, factory, &identity, (ID2D1GeometryVtbl *)&d2d_rectangle_geometry_vtbl);
geometry->u.rectangle.rect = *rect;
- if (!(geometry->fill.vertices = HeapAlloc(GetProcessHeap(), 0, 4 * sizeof(*geometry->fill.vertices))))
+ if (!(geometry->fill.vertices = heap_alloc(4 * sizeof(*geometry->fill.vertices))))
goto fail;
if (!d2d_array_reserve((void **)&geometry->fill.faces,
&geometry->fill.faces_size, 2, sizeof(*geometry->fill.faces)))
@@ -3923,7 +3918,7 @@ static ULONG STDMETHODCALLTYPE d2d_transformed_geometry_Release(ID2D1Transformed
geometry->fill.vertices = NULL;
ID2D1Geometry_Release(geometry->u.transformed.src_geometry);
d2d_geometry_cleanup(geometry);
- HeapFree(GetProcessHeap(), 0, geometry);
+ heap_free(geometry);
}
return refcount;
diff --git a/dlls/d2d1/hwnd_render_target.c b/dlls/d2d1/hwnd_render_target.c
index 7cbbbaa..04d3353 100644
--- a/dlls/d2d1/hwnd_render_target.c
+++ b/dlls/d2d1/hwnd_render_target.c
@@ -83,7 +83,7 @@ static ULONG STDMETHODCALLTYPE d2d_hwnd_render_target_Release(ID2D1HwndRenderTar
{
ID2D1RenderTarget_Release(render_target->dxgi_target);
IDXGISwapChain_Release(render_target->swapchain);
- HeapFree(GetProcessHeap(), 0, render_target);
+ heap_free(render_target);
}
return refcount;
diff --git a/dlls/d2d1/layer.c b/dlls/d2d1/layer.c
index 25a331b..0f7ade2 100644
--- a/dlls/d2d1/layer.c
+++ b/dlls/d2d1/layer.c
@@ -67,7 +67,7 @@ static ULONG STDMETHODCALLTYPE d2d_layer_Release(ID2D1Layer *iface)
if (!refcount)
{
ID2D1Factory_Release(layer->factory);
- HeapFree(GetProcessHeap(), 0, layer);
+ heap_free(layer);
}
return refcount;
@@ -103,7 +103,7 @@ static const struct ID2D1LayerVtbl d2d_layer_vtbl =
HRESULT d2d_layer_create(ID2D1Factory *factory, const D2D1_SIZE_F *size, struct d2d_layer **layer)
{
- if (!(*layer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**layer))))
+ if (!(*layer = heap_alloc_zero(sizeof(**layer))))
return E_OUTOFMEMORY;
(*layer)->ID2D1Layer_iface.lpVtbl = &d2d_layer_vtbl;
diff --git a/dlls/d2d1/mesh.c b/dlls/d2d1/mesh.c
index eb223ad..ee53c69 100644
--- a/dlls/d2d1/mesh.c
+++ b/dlls/d2d1/mesh.c
@@ -67,7 +67,7 @@ static ULONG STDMETHODCALLTYPE d2d_mesh_Release(ID2D1Mesh *iface)
if (!refcount)
{
ID2D1Factory_Release(mesh->factory);
- HeapFree(GetProcessHeap(), 0, mesh);
+ heap_free(mesh);
}
return refcount;
@@ -100,7 +100,7 @@ static const struct ID2D1MeshVtbl d2d_mesh_vtbl =
HRESULT d2d_mesh_create(ID2D1Factory *factory, struct d2d_mesh **mesh)
{
- if (!(*mesh = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**mesh))))
+ if (!(*mesh = heap_alloc_zero(sizeof(**mesh))))
return E_OUTOFMEMORY;
(*mesh)->ID2D1Mesh_iface.lpVtbl = &d2d_mesh_vtbl;
diff --git a/dlls/d2d1/render_target.c b/dlls/d2d1/render_target.c
index 0c44014..73f15f7 100644
--- a/dlls/d2d1/render_target.c
+++ b/dlls/d2d1/render_target.c
@@ -77,7 +77,7 @@ static void d2d_size_set(D2D1_SIZE_U *dst, float width, float height)
static BOOL d2d_clip_stack_init(struct d2d_clip_stack *stack)
{
- if (!(stack->stack = HeapAlloc(GetProcessHeap(), 0, INITIAL_CLIP_STACK_SIZE * sizeof(*stack->stack))))
+ if (!(stack->stack = heap_alloc(INITIAL_CLIP_STACK_SIZE * sizeof(*stack->stack))))
return FALSE;
stack->size = INITIAL_CLIP_STACK_SIZE;
@@ -88,7 +88,7 @@ static BOOL d2d_clip_stack_init(struct d2d_clip_stack *stack)
static void d2d_clip_stack_cleanup(struct d2d_clip_stack *stack)
{
- HeapFree(GetProcessHeap(), 0, stack->stack);
+ heap_free(stack->stack);
}
static BOOL d2d_clip_stack_push(struct d2d_clip_stack *stack, const D2D1_RECT_F *rect)
@@ -104,7 +104,7 @@ static BOOL d2d_clip_stack_push(struct d2d_clip_stack *stack, const D2D1_RECT_F
return FALSE;
new_size = stack->size * 2;
- if (!(new_stack = HeapReAlloc(GetProcessHeap(), 0, stack->stack, new_size * sizeof(*stack->stack))))
+ if (!(new_stack = heap_realloc(stack->stack, new_size * sizeof(*stack->stack))))
return FALSE;
stack->stack = new_stack;
@@ -272,7 +272,7 @@ static ULONG STDMETHODCALLTYPE d2d_d3d_render_target_Release(ID2D1RenderTarget *
ID3D10RenderTargetView_Release(render_target->view);
ID3D10Device_Release(render_target->device);
ID2D1Factory_Release(render_target->factory);
- HeapFree(GetProcessHeap(), 0, render_target);
+ heap_free(render_target);
}
return refcount;
@@ -434,14 +434,14 @@ static HRESULT STDMETHODCALLTYPE d2d_d3d_render_target_CreateCompatibleRenderTar
TRACE("iface %p, size %p, pixel_size %p, format %p, options %#x, render_target %p.\n",
iface, size, pixel_size, format, options, rt);
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = d2d_bitmap_render_target_init(object, render_target, size, pixel_size,
format, options)))
{
WARN("Failed to initialize render target, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
@@ -1176,7 +1176,7 @@ static void d2d_rt_draw_glyph_run_bitmap(struct d2d_d3d_render_target *render_ta
if (texture_type == DWRITE_TEXTURE_CLEARTYPE_3x1)
bitmap_size.width *= 3;
opacity_values_size = bitmap_size.width * bitmap_size.height;
- if (!(opacity_values = HeapAlloc(GetProcessHeap(), 0, opacity_values_size)))
+ if (!(opacity_values = heap_alloc(opacity_values_size)))
{
ERR("Failed to allocate opacity values.\n");
goto done;
@@ -1237,7 +1237,7 @@ done:
ID2D1BitmapBrush_Release(opacity_brush);
if (opacity_bitmap)
ID2D1Bitmap_Release(opacity_bitmap);
- HeapFree(GetProcessHeap(), 0, opacity_values);
+ heap_free(opacity_values);
IDWriteGlyphRunAnalysis_Release(analysis);
}
@@ -3243,13 +3243,13 @@ HRESULT d2d_d3d_create_render_target(ID2D1Factory *factory, IDXGISurface *surfac
struct d2d_d3d_render_target *object;
HRESULT hr;
- if (!(object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object))))
+ if (!(object = heap_alloc_zero(sizeof(*object))))
return E_OUTOFMEMORY;
if (FAILED(hr = d2d_d3d_render_target_init(object, factory, surface, outer_unknown, desc)))
{
WARN("Failed to initialize render target, hr %#x.\n", hr);
- HeapFree(GetProcessHeap(), 0, object);
+ heap_free(object);
return hr;
}
diff --git a/dlls/d2d1/state_block.c b/dlls/d2d1/state_block.c
index 90195fe..3a3cb2e 100644
--- a/dlls/d2d1/state_block.c
+++ b/dlls/d2d1/state_block.c
@@ -69,7 +69,7 @@ static ULONG STDMETHODCALLTYPE d2d_state_block_Release(ID2D1DrawingStateBlock *i
if (state_block->text_rendering_params)
IDWriteRenderingParams_Release(state_block->text_rendering_params);
ID2D1Factory_Release(state_block->factory);
- HeapFree(GetProcessHeap(), 0, state_block);
+ heap_free(state_block);
}
return refcount;
diff --git a/dlls/d2d1/stroke.c b/dlls/d2d1/stroke.c
index c5a1d50..a0830e3 100644
--- a/dlls/d2d1/stroke.c
+++ b/dlls/d2d1/stroke.c
@@ -68,8 +68,8 @@ static ULONG STDMETHODCALLTYPE d2d_stroke_style_Release(ID2D1StrokeStyle *iface)
{
ID2D1Factory_Release(style->factory);
if (style->desc.dashStyle == D2D1_DASH_STYLE_CUSTOM)
- HeapFree(GetProcessHeap(), 0, style->dashes);
- HeapFree(GetProcessHeap(), 0, style);
+ heap_free(style->dashes);
+ heap_free(style);
}
return refcount;
@@ -212,7 +212,7 @@ HRESULT d2d_stroke_style_init(struct d2d_stroke_style *style, ID2D1Factory *fact
if (!dashes || !dash_count)
return E_INVALIDARG;
- if (!(style->dashes = HeapAlloc(GetProcessHeap(), 0, dash_count * sizeof(*style->dashes))))
+ if (!(style->dashes = heap_alloc(dash_count * sizeof(*style->dashes))))
return E_OUTOFMEMORY;
memcpy(style->dashes, dashes, dash_count * sizeof(*style->dashes));
style->dash_count = dash_count;
diff --git a/dlls/d2d1/wic_render_target.c b/dlls/d2d1/wic_render_target.c
index ef8b356..5642fd4 100644
--- a/dlls/d2d1/wic_render_target.c
+++ b/dlls/d2d1/wic_render_target.c
@@ -144,7 +144,7 @@ static ULONG STDMETHODCALLTYPE d2d_wic_render_target_Release(ID2D1RenderTarget *
ID3D10Texture2D_Release(render_target->readback_texture);
ID2D1RenderTarget_Release(render_target->dxgi_target);
IDXGISurface_Release(render_target->dxgi_surface);
- HeapFree(GetProcessHeap(), 0, render_target);
+ heap_free(render_target);
}
return refcount;
diff --git a/include/wine/heap.h b/include/wine/heap.h
index 014ef61..681887b 100644
--- a/include/wine/heap.h
+++ b/include/wine/heap.h
@@ -22,7 +22,7 @@
#ifndef __WINE_WINE_HEAP_H
#define __WINE_WINE_HEAP_H
-#include <windef.h>
+#include <winbase.h>
static inline void * __WINE_ALLOC_SIZE(1) heap_alloc(SIZE_T len)
{
--
2.1.4
More information about the wine-devel
mailing list