[PATCH 0/5] MR9272: d2d1/tests: Extend test geometry sink.

[Nikolay Sivov (＠nsivov)]

Signed-off-by: Nikolay Sivov

[PATCH 1/5] d2d1/tests: Extend test geometry sink.

[Nikolay Sivov]

From: Nikolay Sivov

Signed-off-by: Nikolay Sivov 
---
 dlls/d2d1/tests/d2d1.c | 226 ++++++++++++++++++++++++++++++++---------
 1 file changed, 179 insertions(+), 47 deletions(-)

diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c
index a6a038dbbbf..ca86f98e211 100644
--- a/dlls/d2d1/tests/d2d1.c
+++ b/dlls/d2d1/tests/d2d1.c
@@ -347,7 +347,7 @@ struct figure

struct geometry_sink
 {
-    ID2D1SimplifiedGeometrySink ID2D1SimplifiedGeometrySink_iface;
+    ID2D1GeometrySink ID2D1GeometrySink_iface;

struct geometry_figure
     {
@@ -359,11 +359,15 @@ struct geometry_sink
             enum
             {
                 SEGMENT_BEZIER,
+                SEGMENT_QUADRATIC_BEZIER,
+                SEGMENT_ARC,
                 SEGMENT_LINE,
             } type;
             union
             {
                 D2D1_BEZIER_SEGMENT bezier;
+                D2D1_QUADRATIC_BEZIER_SEGMENT quadratic_bezier;
+                D2D1_ARC_SEGMENT arc;
                 D2D1_POINT_2F line;
             } u;
             DWORD flags;
@@ -832,6 +836,24 @@ static BOOL compare_bezier_segment(const D2D1_BEZIER_SEGMENT *b, float x1, float
             && compare_point(&b->point3, x3, y3, ulps);
 }

+static BOOL compare_quadratic_bezier_segment(const D2D1_QUADRATIC_BEZIER_SEGMENT *b, float x1, float y1,
+        float x2, float y2, unsigned int ulps)
+{
+    return compare_point(&b->point1, x1, y1, ulps)
+            && compare_point(&b->point2, x2, y2, ulps);
+}
+
+static BOOL compare_arc_segment(const D2D1_ARC_SEGMENT *a, float x, float y, float width, float height,
+        float angle, D2D1_SWEEP_DIRECTION sweep_direction, D2D1_ARC_SIZE arc_size, unsigned int ulps)
+{
+    return compare_point(&a->point, x, y, ulps)
+            && compare_float(a->size.width, width, ulps)
+            && compare_float(a->size.height, height, ulps)
+            && compare_float(a->rotationAngle, angle, ulps)
+            && a->sweepDirection == sweep_direction
+            && a->arcSize == arc_size;
+}
+
 static BOOL compare_sha1(void *data, unsigned int pitch, unsigned int bpp,
         unsigned int w, unsigned int h, const char *ref_sha1)
 {
@@ -1418,15 +1440,16 @@ static void check_bitmap_surface_(unsigned int line, ID2D1Bitmap *bitmap, BOOL h
     ID2D1Bitmap1_Release(bitmap1);
 }

-static inline struct geometry_sink *impl_from_ID2D1SimplifiedGeometrySink(ID2D1SimplifiedGeometrySink *iface)
+static inline struct geometry_sink *impl_from_ID2D1GeometrySink(ID2D1GeometrySink *iface)
 {
-    return CONTAINING_RECORD(iface, struct geometry_sink, ID2D1SimplifiedGeometrySink_iface);
+    return CONTAINING_RECORD(iface, struct geometry_sink, ID2D1GeometrySink_iface);
 }

-static HRESULT STDMETHODCALLTYPE geometry_sink_QueryInterface(ID2D1SimplifiedGeometrySink *iface,
+static HRESULT STDMETHODCALLTYPE geometry_sink_QueryInterface(ID2D1GeometrySink *iface,
         REFIID iid, void **out)
 {
-    if (IsEqualGUID(iid, &IID_ID2D1SimplifiedGeometrySink)
+    if (IsEqualGUID(iid, &IID_ID2D1GeometrySink)
+            || IsEqualGUID(iid, &IID_ID2D1SimplifiedGeometrySink)
             || IsEqualGUID(iid, &IID_IUnknown))
     {
         *out = iface;
@@ -1437,35 +1460,35 @@ static HRESULT STDMETHODCALLTYPE geometry_sink_QueryInterface(ID2D1SimplifiedGeo
     return E_NOINTERFACE;
 }

-static ULONG STDMETHODCALLTYPE geometry_sink_AddRef(ID2D1SimplifiedGeometrySink *iface)
+static ULONG STDMETHODCALLTYPE geometry_sink_AddRef(ID2D1GeometrySink *iface)
 {
     return 0;
 }

-static ULONG STDMETHODCALLTYPE geometry_sink_Release(ID2D1SimplifiedGeometrySink *iface)
+static ULONG STDMETHODCALLTYPE geometry_sink_Release(ID2D1GeometrySink *iface)
 {
     return 0;
 }

-static void STDMETHODCALLTYPE geometry_sink_SetFillMode(ID2D1SimplifiedGeometrySink *iface, D2D1_FILL_MODE mode)
+static void STDMETHODCALLTYPE geometry_sink_SetFillMode(ID2D1GeometrySink *iface, D2D1_FILL_MODE mode)
 {
-    struct geometry_sink *sink = impl_from_ID2D1SimplifiedGeometrySink(iface);
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);

sink->fill_mode = mode;
 }

-static void STDMETHODCALLTYPE geometry_sink_SetSegmentFlags(ID2D1SimplifiedGeometrySink *iface,
+static void STDMETHODCALLTYPE geometry_sink_SetSegmentFlags(ID2D1GeometrySink *iface,
         D2D1_PATH_SEGMENT flags)
 {
-    struct geometry_sink *sink = impl_from_ID2D1SimplifiedGeometrySink(iface);
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);

sink->segment_flags = flags;
 }

-static void STDMETHODCALLTYPE geometry_sink_BeginFigure(ID2D1SimplifiedGeometrySink *iface,
+static void STDMETHODCALLTYPE geometry_sink_BeginFigure(ID2D1GeometrySink *iface,
         D2D1_POINT_2F start_point, D2D1_FIGURE_BEGIN figure_begin)
 {
-    struct geometry_sink *sink = impl_from_ID2D1SimplifiedGeometrySink(iface);
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);
     struct geometry_figure *figure;

if (sink->figure_count == sink->figures_size)
@@ -1494,10 +1517,10 @@ static struct geometry_segment *geometry_figure_add_segment(struct geometry_figu
     return &figure->segments[figure->segment_count++];
 }

-static void STDMETHODCALLTYPE geometry_sink_AddLines(ID2D1SimplifiedGeometrySink *iface,
+static void STDMETHODCALLTYPE geometry_sink_AddLines(ID2D1GeometrySink *iface,
         const D2D1_POINT_2F *points, UINT32 count)
 {
-    struct geometry_sink *sink = impl_from_ID2D1SimplifiedGeometrySink(iface);
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);
     struct geometry_figure *figure = &sink->figures[sink->figure_count - 1];
     struct geometry_segment *segment;
     unsigned int i;
@@ -1511,10 +1534,10 @@ static void STDMETHODCALLTYPE geometry_sink_AddLines(ID2D1SimplifiedGeometrySink
     }
 }

-static void STDMETHODCALLTYPE geometry_sink_AddBeziers(ID2D1SimplifiedGeometrySink *iface,
+static void STDMETHODCALLTYPE geometry_sink_AddBeziers(ID2D1GeometrySink *iface,
         const D2D1_BEZIER_SEGMENT *beziers, UINT32 count)
 {
-    struct geometry_sink *sink = impl_from_ID2D1SimplifiedGeometrySink(iface);
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);
     struct geometry_figure *figure = &sink->figures[sink->figure_count - 1];
     struct geometry_segment *segment;
     unsigned int i;
@@ -1528,25 +1551,71 @@ static void STDMETHODCALLTYPE geometry_sink_AddBeziers(ID2D1SimplifiedGeometrySi
     }
 }

-static void STDMETHODCALLTYPE geometry_sink_EndFigure(ID2D1SimplifiedGeometrySink *iface,
+static void STDMETHODCALLTYPE geometry_sink_EndFigure(ID2D1GeometrySink *iface,
         D2D1_FIGURE_END figure_end)
 {
-    struct geometry_sink *sink = impl_from_ID2D1SimplifiedGeometrySink(iface);
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);
     struct geometry_figure *figure = &sink->figures[sink->figure_count - 1];

figure->end = figure_end;
 }

-static HRESULT STDMETHODCALLTYPE geometry_sink_Close(ID2D1SimplifiedGeometrySink *iface)
+static HRESULT STDMETHODCALLTYPE geometry_sink_Close(ID2D1GeometrySink *iface)
 {
-    struct geometry_sink *sink = impl_from_ID2D1SimplifiedGeometrySink(iface);
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);

sink->closed = TRUE;

return S_OK;
 }

-static const struct ID2D1SimplifiedGeometrySinkVtbl geometry_sink_vtbl =
+static void STDMETHODCALLTYPE geometry_sink_AddLine(ID2D1GeometrySink *iface, D2D1_POINT_2F point)
+{
+    geometry_sink_AddLines(iface, &point, 1);
+}
+
+static void STDMETHODCALLTYPE geometry_sink_AddBezier(ID2D1GeometrySink *iface,
+        const D2D1_BEZIER_SEGMENT *bezier)
+{
+    geometry_sink_AddBeziers(iface, bezier, 1);
+}
+
+static void STDMETHODCALLTYPE geometry_sink_AddQuadraticBezier(ID2D1GeometrySink *iface,
+        const D2D1_QUADRATIC_BEZIER_SEGMENT *bezier)
+{
+    ID2D1GeometrySink_AddQuadraticBeziers(iface, bezier, 1);
+}
+
+static void STDMETHODCALLTYPE geometry_sink_AddQuadraticBeziers(ID2D1GeometrySink *iface,
+        const D2D1_QUADRATIC_BEZIER_SEGMENT *beziers, UINT32 count)
+{
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);
+    struct geometry_figure *figure = &sink->figures[sink->figure_count - 1];
+    struct geometry_segment *segment;
+    unsigned int i;
+
+    for (i = 0; i < count; ++i)
+    {
+        segment = geometry_figure_add_segment(figure);
+        segment->type = SEGMENT_QUADRATIC_BEZIER;
+        segment->u.quadratic_bezier = beziers[i];
+        segment->flags = sink->segment_flags;
+    }
+}
+
+static void STDMETHODCALLTYPE geometry_sink_AddArc(ID2D1GeometrySink *iface,
+        const D2D1_ARC_SEGMENT *arc)
+{
+    struct geometry_sink *sink = impl_from_ID2D1GeometrySink(iface);
+    struct geometry_figure *figure = &sink->figures[sink->figure_count - 1];
+    struct geometry_segment *segment = geometry_figure_add_segment(figure);
+
+    segment->type = SEGMENT_ARC;
+    segment->u.arc = *arc;
+    segment->flags = sink->segment_flags;
+}
+
+static const struct ID2D1GeometrySinkVtbl geometry_sink_vtbl =
 {
     geometry_sink_QueryInterface,
     geometry_sink_AddRef,
@@ -1558,12 +1627,17 @@ static const struct ID2D1SimplifiedGeometrySinkVtbl geometry_sink_vtbl =
     geometry_sink_AddBeziers,
     geometry_sink_EndFigure,
     geometry_sink_Close,
+    geometry_sink_AddLine,
+    geometry_sink_AddBezier,
+    geometry_sink_AddQuadraticBezier,
+    geometry_sink_AddQuadraticBeziers,
+    geometry_sink_AddArc,
 };

static void geometry_sink_init(struct geometry_sink *sink)
 {
     memset(sink, 0, sizeof(*sink));
-    sink->ID2D1SimplifiedGeometrySink_iface.lpVtbl = &geometry_sink_vtbl;
+    sink->ID2D1GeometrySink_iface.lpVtbl = &geometry_sink_vtbl;
     sink->figures_size = 4;
     sink->figures = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
             sink->figures_size * sizeof(*sink->figures));
@@ -1657,6 +1731,36 @@ static void geometry_sink_check_(unsigned int line, const struct geometry_sink *
                             expected_segment->u.bezier.point2.x, expected_segment->u.bezier.point2.y,
                             expected_segment->u.bezier.point3.x, expected_segment->u.bezier.point3.y);
                     break;
+               case SEGMENT_QUADRATIC_BEZIER:
+                    match = compare_quadratic_bezier_segment(&segment->u.quadratic_bezier,
+                            expected_segment->u.bezier.point1.x, expected_segment->u.bezier.point1.y,
+                            expected_segment->u.bezier.point2.x, expected_segment->u.bezier.point2.y,
+                            ulps);
+                    ok_(__FILE__, line)(match, "Got unexpected figure %u segment %u "
+                            "{%.8e, %.8e, %.8e, %.8e}, "
+                            "expected {%.8e, %.8e, %.8e, %.8e}.\n",
+                            i, j, segment->u.bezier.point1.x, segment->u.bezier.point1.y,
+                            segment->u.bezier.point2.x, segment->u.bezier.point2.y,
+                            expected_segment->u.bezier.point1.x, expected_segment->u.bezier.point1.y,
+                            expected_segment->u.bezier.point2.x, expected_segment->u.bezier.point2.y);
+                    break;
+               case SEGMENT_ARC:
+                    match = compare_arc_segment(&segment->u.arc,
+                            expected_segment->u.arc.point.x, expected_segment->u.arc.point.y,
+                            expected_segment->u.arc.size.width, expected_segment->u.arc.size.height,
+                            expected_segment->u.arc.rotationAngle, expected_segment->u.arc.sweepDirection,
+                            expected_segment->u.arc.arcSize, ulps);
+                    ok_(__FILE__, line)(match, "Got unexpected figure %u segment %u "
+                            "{%.8e, %.8e, %.8e, %.8e, %.8e, %u, %u}, "
+                            "expected {%.8e, %.8e, %.8e, %.8e, %.8e, %u, %u}.\n",
+                            i, j, segment->u.arc.point.x, segment->u.arc.point.y,
+                            segment->u.arc.size.width, segment->u.arc.size.height,
+                            segment->u.arc.rotationAngle, segment->u.arc.sweepDirection, segment->u.arc.arcSize,
+                            expected_segment->u.arc.point.x, expected_segment->u.arc.point.y,
+                            expected_segment->u.arc.size.width, expected_segment->u.arc.size.height,
+                            expected_segment->u.arc.rotationAngle, expected_segment->u.arc.sweepDirection,
+                            expected_segment->u.arc.arcSize);
+                    break;
             }
         }

@@ -1676,6 +1780,20 @@ static void geometry_sink_check_(unsigned int line, const struct geometry_sink *
                             segment->u.bezier.point2.x, segment->u.bezier.point2.y,
                             segment->u.bezier.point3.x, segment->u.bezier.point3.y);
                     break;
+                case SEGMENT_QUADRATIC_BEZIER:
+                    ok_(__FILE__, line)(FALSE, "Missing figure %u segment %u "
+                            "{%.8e, %.8e, %.8e, %.8e}\n",
+                            i, j, segment->u.bezier.point1.x, segment->u.bezier.point1.y,
+                            segment->u.bezier.point2.x, segment->u.bezier.point2.y);
+                    break;
+                case SEGMENT_ARC:
+                    ok_(__FILE__, line)(FALSE, "Missing figure %u segment %u "
+                            "{%.8e, %.8e, %.8e, %.8e, %.8e, %u, %u}\n",
+                            i, j, segment->u.arc.point.x, segment->u.arc.point.y,
+                            segment->u.arc.size.width, segment->u.arc.size.height,
+                            segment->u.arc.rotationAngle, segment->u.arc.sweepDirection,
+                            segment->u.arc.arcSize);
+                    break;
             }
         }

@@ -1695,6 +1813,20 @@ static void geometry_sink_check_(unsigned int line, const struct geometry_sink *
                             segment->u.bezier.point2.x, segment->u.bezier.point2.y,
                             segment->u.bezier.point3.x, segment->u.bezier.point3.y);
                     break;
+                case SEGMENT_QUADRATIC_BEZIER:
+                    ok_(__FILE__, line)(FALSE, "Got unexpected figure %u segment %u "
+                            "{%.8e, %.8e, %.8e, %.8e}\n",
+                            i, j, segment->u.bezier.point1.x, segment->u.bezier.point1.y,
+                            segment->u.bezier.point2.x, segment->u.bezier.point2.y);
+                    break;
+                case SEGMENT_ARC:
+                    ok_(__FILE__, line)(FALSE, "Got unexpected figure %u segment %u "
+                            "{%.8e, %.8e, %.8e, %.8e, %.8e, %u, %u}\n",
+                            i, j, segment->u.arc.point.x, segment->u.arc.point.y,
+                            segment->u.arc.size.width, segment->u.arc.size.height,
+                            segment->u.arc.rotationAngle, segment->u.arc.sweepDirection,
+                            segment->u.arc.arcSize);
+                    break;
             }
         }
     }
@@ -4010,13 +4142,13 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 6, &expected_figures[0], 0);
     geometry_sink_cleanup(&simplify_sink);
     geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 6, &expected_figures[0], 0);
     geometry_sink_cleanup(&simplify_sink);
@@ -4029,7 +4161,7 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1TransformedGeometry_Simplify(transformed_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 6, &expected_figures[6], 0);
     geometry_sink_cleanup(&simplify_sink);
@@ -4044,7 +4176,7 @@ static void test_path_geometry(BOOL d3d11)
             tmp_matrix._22, tmp_matrix._31, tmp_matrix._32);
     geometry_sink_init(&simplify_sink);
     hr = ID2D1Geometry_Simplify(tmp_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            &tmp_matrix, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            &tmp_matrix, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 6, &expected_figures[6], 0);
     geometry_sink_cleanup(&simplify_sink);
@@ -4121,7 +4253,7 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_WINDING, 6, &expected_figures[0], 0);
     geometry_sink_cleanup(&simplify_sink);
@@ -4160,19 +4292,19 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 4, &expected_figures[12], 1);
     geometry_sink_cleanup(&simplify_sink);
     geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 100.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 100.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 4, &expected_figures[20], 1);
     geometry_sink_cleanup(&simplify_sink);
     geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 10.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 10.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 4, &expected_figures[24], 1);
     geometry_sink_cleanup(&simplify_sink);
@@ -4187,7 +4319,7 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1TransformedGeometry_Simplify(transformed_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 4, &expected_figures[16], 4);
     geometry_sink_cleanup(&simplify_sink);
@@ -4263,19 +4395,19 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_WINDING, 4, &expected_figures[12], 1);
     geometry_sink_cleanup(&simplify_sink);
     geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 100.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 100.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_WINDING, 4, &expected_figures[20], 1);
     geometry_sink_cleanup(&simplify_sink);
     geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 10.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 10.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_WINDING, 4, &expected_figures[24], 1);
     geometry_sink_cleanup(&simplify_sink);
@@ -4383,7 +4515,7 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[28], 1);
     geometry_sink_cleanup(&simplify_sink);
@@ -4432,7 +4564,7 @@ static void test_path_geometry(BOOL d3d11)

geometry_sink_init(&simplify_sink);
     hr = ID2D1PathGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            NULL, 0.0f, &simplify_sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&simplify_sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&simplify_sink, D2D1_FILL_MODE_ALTERNATE, 4, &expected_figures[29], 1);
     geometry_sink_cleanup(&simplify_sink);
@@ -4626,13 +4758,13 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1RectangleGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            NULL, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[0], 0);
     geometry_sink_cleanup(&sink);
     geometry_sink_init(&sink);
     hr = ID2D1RectangleGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[0], 0);
     geometry_sink_cleanup(&sink);
@@ -4648,7 +4780,7 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1RectangleGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            &matrix, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            &matrix, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[1], 1);
     geometry_sink_cleanup(&sink);
@@ -4663,7 +4795,7 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1RectangleGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            &matrix, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            &matrix, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[2], 0);
     geometry_sink_cleanup(&sink);
@@ -4678,7 +4810,7 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1RectangleGeometry_Simplify(geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            &matrix, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            &matrix, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[3], 0);
     geometry_sink_cleanup(&sink);
@@ -4697,13 +4829,13 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1TransformedGeometry_Simplify(transformed_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            NULL, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[4], 1);
     geometry_sink_cleanup(&sink);
     geometry_sink_init(&sink);
     hr = ID2D1TransformedGeometry_Simplify(transformed_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            NULL, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            NULL, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[4], 1);
     geometry_sink_cleanup(&sink);
@@ -4718,7 +4850,7 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1TransformedGeometry_Simplify(transformed_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_LINES,
-            &matrix, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            &matrix, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[5], 4);
     geometry_sink_cleanup(&sink);
@@ -4732,7 +4864,7 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1TransformedGeometry_Simplify(transformed_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            &matrix, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            &matrix, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[6], 1);
     geometry_sink_cleanup(&sink);
@@ -4746,7 +4878,7 @@ static void test_rectangle_geometry(BOOL d3d11)
             rect.left, rect.top, rect.right, rect.bottom);
     geometry_sink_init(&sink);
     hr = ID2D1TransformedGeometry_Simplify(transformed_geometry, D2D1_GEOMETRY_SIMPLIFICATION_OPTION_CUBICS_AND_LINES,
-            &matrix, 0.0f, &sink.ID2D1SimplifiedGeometrySink_iface);
+            &matrix, 0.0f, (ID2D1SimplifiedGeometrySink *)&sink.ID2D1GeometrySink_iface);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     geometry_sink_check(&sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[7], 1);
     geometry_sink_cleanup(&sink);

[PATCH 2/5] d2d1/tests: Add a basic test for geometry streaming.

[Nikolay Sivov]

From: Nikolay Sivov

Signed-off-by: Nikolay Sivov 
---
 dlls/d2d1/tests/d2d1.c | 69 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c
index ca86f98e211..978401152a7 100644
--- a/dlls/d2d1/tests/d2d1.c
+++ b/dlls/d2d1/tests/d2d1.c
@@ -3823,6 +3823,18 @@ static void test_path_geometry(BOOL d3d11)
     ok(!count, "Got unexpected segment count %u.\n", count);
     ID2D1PathGeometry_Release(geometry);

+    /* Invalid segment flags. */
+    hr = ID2D1Factory_CreatePathGeometry(factory, &geometry);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    hr = ID2D1PathGeometry_Open(geometry, &sink);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    ID2D1GeometrySink_SetSegmentFlags(sink, 0xff);
+    hr = ID2D1GeometrySink_Close(sink);
+    todo_wine
+    ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
+    ID2D1GeometrySink_Release(sink);
+    ID2D1PathGeometry_Release(geometry);
+
     /* Open() when closed. */
     hr = ID2D1Factory_CreatePathGeometry(factory, &geometry);
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
@@ -16477,6 +16489,62 @@ static void test_geometry_realization(BOOL d3d11)
     release_test_context(&ctx);
 }

+static void test_path_geometry_stream(BOOL d3d11)
+{
+    static const struct geometry_segment expected_segments[] =
+    {
+        /* Figure 0. */
+        {SEGMENT_LINE,   {{{165.0f, 300.0f}}}},
+        {SEGMENT_LINE,   {{{235.0f, 300.0f}}}},
+        {SEGMENT_LINE,   {{{235.0f,  20.0f}}}},
+    };
+    static const struct expected_geometry_figure expected_figures[] =
+    {
+        /* 0 */
+        {D2D1_FIGURE_BEGIN_FILLED, D2D1_FIGURE_END_CLOSED, { 15.0f, 20.0f}, 3, &expected_segments[0]},
+    };
+    struct geometry_sink stream_sink;
+    struct d2d1_test_context ctx;
+    ID2D1PathGeometry *geometry;
+    ID2D1GeometrySink *sink;
+    D2D1_POINT_2F point;
+    HRESULT hr;
+
+    if (!init_test_context(&ctx, d3d11))
+        return;
+
+    geometry_sink_init(&stream_sink);
+
+    hr = ID2D1Factory_CreatePathGeometry(ctx.factory, &geometry);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+
+    hr = ID2D1PathGeometry_Stream(geometry, &stream_sink.ID2D1GeometrySink_iface);
+    todo_wine
+    ok(hr == D2DERR_WRONG_STATE, "Got unexpected hr %#lx.\n", hr);
+
+    hr = ID2D1PathGeometry_Open(geometry, &sink);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    set_point(&point, 15.0f, 20.0f);
+    ID2D1GeometrySink_BeginFigure(sink, point, D2D1_FIGURE_BEGIN_FILLED);
+    line_to(sink, 165.0f, 300.0f);
+    line_to(sink, 235.0f, 300.0f);
+    line_to(sink, 235.0f, 20.0f);
+    ID2D1GeometrySink_EndFigure(sink, D2D1_FIGURE_END_CLOSED);
+    hr = ID2D1GeometrySink_Close(sink);
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    ID2D1GeometrySink_Release(sink);
+
+    hr = ID2D1PathGeometry_Stream(geometry, &stream_sink.ID2D1GeometrySink_iface);
+    todo_wine
+    ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
+    if (SUCCEEDED(hr))
+        geometry_sink_check(&stream_sink, D2D1_FILL_MODE_ALTERNATE, 1, &expected_figures[0], 1);
+    geometry_sink_cleanup(&stream_sink);
+    ID2D1PathGeometry_Release(geometry);
+
+    release_test_context(&ctx);
+}
+
 START_TEST(d2d1)
 {
     HMODULE d2d1_dll = GetModuleHandleA("d2d1.dll");
@@ -16581,6 +16649,7 @@ START_TEST(d2d1)
     queue_test(test_no_target);
     queue_test(test_mesh);
     queue_test(test_geometry_realization);
+    queue_d3d10_test(test_path_geometry_stream);

run_queued_tests();
 }

[PATCH 3/5] d2d1: Track specific failure reason during geometry population.

[Nikolay Sivov]

From: Nikolay Sivov

Signed-off-by: Nikolay Sivov 
---
 dlls/d2d1/d2d1_private.h |  1 +
 dlls/d2d1/geometry.c     | 50 +++++++++++++++++++++++++---------------
 2 files changed, 32 insertions(+), 19 deletions(-)

diff --git a/dlls/d2d1/d2d1_private.h b/dlls/d2d1/d2d1_private.h
index 24116bbe41a..51bf830fc0a 100644
--- a/dlls/d2d1/d2d1_private.h
+++ b/dlls/d2d1/d2d1_private.h
@@ -580,6 +580,7 @@ struct d2d_geometry
             size_t figure_count;

enum d2d_geometry_state state;
+            HRESULT code;
             D2D1_FILL_MODE fill_mode;
             UINT32 segment_count;

diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c
index 19707ba609e..b75525a5aee 100644
--- a/dlls/d2d1/geometry.c
+++ b/dlls/d2d1/geometry.c
@@ -2859,6 +2859,15 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_SetSegmentFlags(ID2D1GeometrySin
         FIXME("Ignoring flags %#x.\n", flags);
 }

+static void d2d_geometry_set_error(struct d2d_geometry *geometry, HRESULT code)
+{
+    if (geometry->u.path.state == D2D_GEOMETRY_STATE_ERROR)
+        return;
+
+    geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+    geometry->u.path.code = code;
+}
+
 static void STDMETHODCALLTYPE d2d_geometry_sink_BeginFigure(ID2D1GeometrySink *iface,
         D2D1_POINT_2F start_point, D2D1_FIGURE_BEGIN figure_begin)
 {
@@ -2870,21 +2879,21 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_BeginFigure(ID2D1GeometrySink *i

if (geometry->u.path.state != D2D_GEOMETRY_STATE_OPEN)
     {
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

if (!d2d_path_geometry_add_figure(geometry))
     {
         ERR("Failed to add figure.\n");
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

figure = &geometry->u.path.figures[geometry->u.path.figure_count - 1];
     if (!d2d_figure_begin(figure, start_point, figure_begin))
     {
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

@@ -2901,7 +2910,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddLines(ID2D1GeometrySink *ifac

if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE)
     {
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

@@ -2924,14 +2933,14 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddBeziers(ID2D1GeometrySink *if

if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE)
     {
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

if (!d2d_figure_add_beziers(figure, beziers, count))
     {
         ERR("Failed to add Bézier curves.\n");
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

@@ -2947,7 +2956,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_EndFigure(ID2D1GeometrySink *ifa

if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE)
     {
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

@@ -2960,7 +2969,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_EndFigure(ID2D1GeometrySink *ifa
     if (!d2d_geometry_add_figure_outline(geometry, figure, figure_end))
     {
         ERR("Failed to add figure outline.\n");
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

@@ -3235,12 +3244,15 @@ static HRESULT STDMETHODCALLTYPE d2d_geometry_sink_Close(ID2D1GeometrySink *ifac

TRACE("iface %p.\n", iface);

-    if (geometry->u.path.state != D2D_GEOMETRY_STATE_OPEN)
-    {
-        if (geometry->u.path.state != D2D_GEOMETRY_STATE_CLOSED)
-            geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+    if (geometry->u.path.state == D2D_GEOMETRY_STATE_CLOSED)
         return D2DERR_WRONG_STATE;
-    }
+
+    if (geometry->u.path.state != D2D_GEOMETRY_STATE_OPEN)
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+
+    if (geometry->u.path.state == D2D_GEOMETRY_STATE_ERROR)
+        return geometry->u.path.code;
+
     geometry->u.path.state = D2D_GEOMETRY_STATE_CLOSED;

if (!d2d_geometry_intersect_self(geometry))
@@ -3257,7 +3269,7 @@ done:
         geometry->fill.bezier_vertices = NULL;
         geometry->fill.bezier_vertex_count = 0;
         d2d_path_geometry_free_figures(geometry);
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
     }
     return hr;
 }
@@ -3295,7 +3307,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1Geometr

if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE)
     {
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

@@ -3310,7 +3322,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1Geometr
         if (!d2d_figure_add_original_bezier_controls(figure, 2, p))
         {
             ERR("Failed to add cubic Bézier controls.\n");
-            geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+            d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
             return;
         }

@@ -3321,14 +3333,14 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1Geometr
         if (!d2d_figure_add_bezier_controls(figure, 1, &beziers[i].point1))
         {
             ERR("Failed to add bezier.\n");
-            geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+            d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
             return;
         }

if (!d2d_figure_add_vertex(figure, beziers[i].point2))
         {
             ERR("Failed to add bezier vertex.\n");
-            geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+            d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
             return;
         }

@@ -3346,7 +3358,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddArc(ID2D1GeometrySink *iface,

if (geometry->u.path.state != D2D_GEOMETRY_STATE_FIGURE)
     {
-        geometry->u.path.state = D2D_GEOMETRY_STATE_ERROR;
+        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
         return;
     }

[PATCH 4/5] d2d1: Set more appropriate error code on geometry population.

[Nikolay Sivov]

From: Nikolay Sivov

Signed-off-by: Nikolay Sivov 
---
 dlls/d2d1/geometry.c | 17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c
index b75525a5aee..5ee959d0e2d 100644
--- a/dlls/d2d1/geometry.c
+++ b/dlls/d2d1/geometry.c
@@ -2886,14 +2886,14 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_BeginFigure(ID2D1GeometrySink *i
     if (!d2d_path_geometry_add_figure(geometry))
     {
         ERR("Failed to add figure.\n");
-        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+        d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
         return;
     }

figure = &geometry->u.path.figures[geometry->u.path.figure_count - 1];
     if (!d2d_figure_begin(figure, start_point, figure_begin))
     {
-        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+        d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
         return;
     }

@@ -2917,6 +2917,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddLines(ID2D1GeometrySink *ifac
     if (!d2d_figure_add_lines(figure, points, count))
     {
         ERR("Failed to add vertex.\n");
+        d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
         return;
     }

@@ -2940,7 +2941,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddBeziers(ID2D1GeometrySink *if
     if (!d2d_figure_add_beziers(figure, beziers, count))
     {
         ERR("Failed to add Bézier curves.\n");
-        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+        d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
         return;
     }

@@ -2969,7 +2970,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_EndFigure(ID2D1GeometrySink *ifa
     if (!d2d_geometry_add_figure_outline(geometry, figure, figure_end))
     {
         ERR("Failed to add figure outline.\n");
-        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+        d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
         return;
     }

@@ -3269,7 +3270,7 @@ done:
         geometry->fill.bezier_vertices = NULL;
         geometry->fill.bezier_vertex_count = 0;
         d2d_path_geometry_free_figures(geometry);
-        d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+        d2d_geometry_set_error(geometry, hr);
     }
     return hr;
 }
@@ -3322,7 +3323,7 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1Geometr
         if (!d2d_figure_add_original_bezier_controls(figure, 2, p))
         {
             ERR("Failed to add cubic Bézier controls.\n");
-            d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+            d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
             return;
         }

@@ -3333,14 +3334,14 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_AddQuadraticBeziers(ID2D1Geometr
         if (!d2d_figure_add_bezier_controls(figure, 1, &beziers[i].point1))
         {
             ERR("Failed to add bezier.\n");
-            d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+            d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
             return;
         }

if (!d2d_figure_add_vertex(figure, beziers[i].point2))
         {
             ERR("Failed to add bezier vertex.\n");
-            d2d_geometry_set_error(geometry, D2DERR_WRONG_STATE);
+            d2d_geometry_set_error(geometry, E_OUTOFMEMORY);
             return;
         }

[PATCH 5/5] d2d1: Handle invalid segment flags in SetSegmentFlags().

[Nikolay Sivov]

From: Nikolay Sivov

Signed-off-by: Nikolay Sivov 
---
 dlls/d2d1/geometry.c   | 24 ++++++++++++++++--------
 dlls/d2d1/tests/d2d1.c |  1 -
 2 files changed, 16 insertions(+), 9 deletions(-)

diff --git a/dlls/d2d1/geometry.c b/dlls/d2d1/geometry.c
index 5ee959d0e2d..633919afa4f 100644
--- a/dlls/d2d1/geometry.c
+++ b/dlls/d2d1/geometry.c
@@ -2851,14 +2851,6 @@ static void STDMETHODCALLTYPE d2d_geometry_sink_SetFillMode(ID2D1GeometrySink *i
     geometry->u.path.fill_mode = mode;
 }

-static void STDMETHODCALLTYPE d2d_geometry_sink_SetSegmentFlags(ID2D1GeometrySink *iface, D2D1_PATH_SEGMENT flags)
-{
-    TRACE("iface %p, flags %#x.\n", iface, flags);
-
-    if (flags != D2D1_PATH_SEGMENT_NONE)
-        FIXME("Ignoring flags %#x.\n", flags);
-}
-
 static void d2d_geometry_set_error(struct d2d_geometry *geometry, HRESULT code)
 {
     if (geometry->u.path.state == D2D_GEOMETRY_STATE_ERROR)
@@ -2868,6 +2860,22 @@ static void d2d_geometry_set_error(struct d2d_geometry *geometry, HRESULT code)
     geometry->u.path.code = code;
 }

+static void STDMETHODCALLTYPE d2d_geometry_sink_SetSegmentFlags(ID2D1GeometrySink *iface, D2D1_PATH_SEGMENT flags)
+{
+    struct d2d_geometry *geometry = impl_from_ID2D1GeometrySink(iface);
+
+    TRACE("iface %p, flags %#x.\n", iface, flags);
+
+    if (flags & ~(D2D1_PATH_SEGMENT_FORCE_UNSTROKED | D2D1_PATH_SEGMENT_FORCE_ROUND_LINE_JOIN))
+    {
+        d2d_geometry_set_error(geometry, E_INVALIDARG);
+        return;
+    }
+
+    if (flags != D2D1_PATH_SEGMENT_NONE)
+        FIXME("Ignoring flags %#x.\n", flags);
+}
+
 static void STDMETHODCALLTYPE d2d_geometry_sink_BeginFigure(ID2D1GeometrySink *iface,
         D2D1_POINT_2F start_point, D2D1_FIGURE_BEGIN figure_begin)
 {
diff --git a/dlls/d2d1/tests/d2d1.c b/dlls/d2d1/tests/d2d1.c
index 978401152a7..7333f24eab9 100644
--- a/dlls/d2d1/tests/d2d1.c
+++ b/dlls/d2d1/tests/d2d1.c
@@ -3830,7 +3830,6 @@ static void test_path_geometry(BOOL d3d11)
     ok(hr == S_OK, "Got unexpected hr %#lx.\n", hr);
     ID2D1GeometrySink_SetSegmentFlags(sink, 0xff);
     hr = ID2D1GeometrySink_Close(sink);
-    todo_wine
     ok(hr == E_INVALIDARG, "Got unexpected hr %#lx.\n", hr);
     ID2D1GeometrySink_Release(sink);
     ID2D1PathGeometry_Release(geometry);