From 5ffd77c36b8f89684ae71d2ca8b0168474539677 Mon Sep 17 00:00:00 2001 From: Robert Mader Date: Fri, 6 Aug 2021 18:17:18 +0200 Subject: [PATCH] tests/wayland: Test reattaching subsurface after parent was destroyed and the subsurface was not previously detached from it using `wl_subsurface_destroy()`. Without 'window-actor/wayland: Remove subsurface actors on dispose' this test would fail. Part-of: --- src/tests/wayland-test-clients/meson.build | 1 + .../subsurface-reparenting.c | 391 ++++++++++++++++++ src/tests/wayland-unit-tests.c | 11 + 3 files changed, 403 insertions(+) create mode 100644 src/tests/wayland-test-clients/subsurface-reparenting.c diff --git a/src/tests/wayland-test-clients/meson.build b/src/tests/wayland-test-clients/meson.build index e26325d70..bbe274dca 100644 --- a/src/tests/wayland-test-clients/meson.build +++ b/src/tests/wayland-test-clients/meson.build @@ -47,6 +47,7 @@ common_sources = [ wayland_test_clients = [ 'subsurface-remap-toplevel', + 'subsurface-reparenting', 'invalid-subsurfaces', 'invalid-xdg-shell-actions', 'xdg-apply-limits', diff --git a/src/tests/wayland-test-clients/subsurface-reparenting.c b/src/tests/wayland-test-clients/subsurface-reparenting.c new file mode 100644 index 000000000..f3f79c327 --- /dev/null +++ b/src/tests/wayland-test-clients/subsurface-reparenting.c @@ -0,0 +1,391 @@ +/* + * Copyright (C) 2019 Red Hat, Inc. + * Copyright (C) 2021 Robert Mader + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, see . + */ + +#include "config.h" + +#include +#include +#include +#include + +#include "wayland-test-client-utils.h" + +#include "test-driver-client-protocol.h" +#include "xdg-shell-client-protocol.h" + +typedef enum _State +{ + STATE_INIT = 0, + STATE_WAIT_FOR_CONFIGURE_1, + STATE_WAIT_FOR_FRAME_1, + STATE_WAIT_FOR_ACTOR_DESTROYED, + STATE_WAIT_FOR_CONFIGURE_2, + STATE_WAIT_FOR_FRAME_2, + STATE_WAIT_FOR_FRAME_3 +} State; + +static struct wl_display *display; +static struct wl_registry *registry; +static struct wl_compositor *compositor; +static struct wl_subcompositor *subcompositor; +static struct xdg_wm_base *xdg_wm_base; +static struct wl_shm *shm; +static struct test_driver *test_driver; + +static struct wl_surface *surface; +static struct xdg_surface *xdg_surface; +static struct xdg_toplevel *xdg_toplevel; + +static struct wl_surface *subsurface_surface; +static struct wl_subsurface *subsurface; + +static struct wl_callback *frame_callback; + +static State state; + +static void init_surfaces (void); + +static void +handle_buffer_release (void *data, + struct wl_buffer *buffer) +{ + wl_buffer_destroy (buffer); +} + +static const struct wl_buffer_listener buffer_listener = { + handle_buffer_release +}; + +static gboolean +create_shm_buffer (int width, + int height, + struct wl_buffer **out_buffer, + void **out_data, + int *out_size) +{ + struct wl_shm_pool *pool; + static struct wl_buffer *buffer; + int fd, size, stride; + int bytes_per_pixel; + void *data; + + bytes_per_pixel = 4; + stride = width * bytes_per_pixel; + size = stride * height; + + fd = create_anonymous_file (size); + if (fd < 0) + { + fprintf (stderr, "Creating a buffer file for %d B failed: %m\n", + size); + return FALSE; + } + + data = mmap (NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (data == MAP_FAILED) + { + fprintf (stderr, "mmap failed: %m\n"); + close (fd); + return FALSE; + } + + pool = wl_shm_create_pool (shm, fd, size); + buffer = wl_shm_pool_create_buffer (pool, 0, + width, height, + stride, + WL_SHM_FORMAT_ARGB8888); + wl_buffer_add_listener (buffer, &buffer_listener, buffer); + wl_shm_pool_destroy (pool); + close (fd); + + *out_buffer = buffer; + *out_data = data; + *out_size = size; + + return TRUE; +} + +static void +fill (void *buffer_data, + int width, + int height, + uint32_t color) +{ + uint32_t *pixels = buffer_data; + int x, y; + + for (y = 0; y < height; y++) + { + for (x = 0; x < width; x++) + pixels[y * width + x] = color; + } +} + +static void +draw (struct wl_surface *surface, + int width, + int height, + uint32_t color) +{ + struct wl_buffer *buffer; + void *buffer_data; + int size; + + if (!create_shm_buffer (width, height, + &buffer, &buffer_data, &size)) + g_error ("Failed to create shm buffer"); + + fill (buffer_data, width, height, color); + + wl_surface_attach (surface, buffer, 0, 0); +} + +static void +draw_main (void) +{ + draw (surface, 700, 500, 0xff00ff00); +} + +static void +draw_subsurface (void) +{ + draw (subsurface_surface, 500, 300, 0xff007f00); +} + +static void +handle_xdg_toplevel_configure (void *data, + struct xdg_toplevel *xdg_toplevel, + int32_t width, + int32_t height, + struct wl_array *state) +{ +} + +static void +handle_xdg_toplevel_close(void *data, + struct xdg_toplevel *xdg_toplevel) +{ + g_assert_not_reached (); +} + +static const struct xdg_toplevel_listener xdg_toplevel_listener = { + handle_xdg_toplevel_configure, + handle_xdg_toplevel_close, +}; + +static void +actor_destroyed (void *data, + struct wl_callback *callback, + uint32_t serial) +{ + g_assert_cmpint (state, ==, STATE_WAIT_FOR_ACTOR_DESTROYED); + + wl_subsurface_destroy (subsurface); + init_surfaces (); + state = STATE_WAIT_FOR_CONFIGURE_2; + + wl_callback_destroy (callback); +} + +static const struct wl_callback_listener actor_destroy_listener = { + actor_destroyed, +}; + +static void +reset_surface (void) +{ + struct wl_callback *callback; + + callback = test_driver_sync_actor_destroyed (test_driver, surface); + wl_callback_add_listener (callback, &actor_destroy_listener, NULL); + + xdg_toplevel_destroy (xdg_toplevel); + xdg_surface_destroy (xdg_surface); + wl_surface_destroy (surface); + + state = STATE_WAIT_FOR_ACTOR_DESTROYED; +} + +static void +handle_frame_callback (void *data, + struct wl_callback *callback, + uint32_t time) +{ + switch (state) + { + case STATE_WAIT_FOR_FRAME_1: + reset_surface (); + break; + case STATE_WAIT_FOR_FRAME_2: + exit (EXIT_SUCCESS); + default: + g_assert_not_reached (); + } +} + +static const struct wl_callback_listener frame_listener = { + handle_frame_callback, +}; + +static void +handle_xdg_surface_configure (void *data, + struct xdg_surface *xdg_surface, + uint32_t serial) +{ + switch (state) + { + case STATE_INIT: + g_assert_not_reached (); + case STATE_WAIT_FOR_CONFIGURE_1: + draw_main (); + state = STATE_WAIT_FOR_FRAME_1; + break; + case STATE_WAIT_FOR_CONFIGURE_2: + draw_main (); + state = STATE_WAIT_FOR_FRAME_2; + break; + default: + /* ignore */ + return; + } + + xdg_surface_ack_configure (xdg_surface, serial); + frame_callback = wl_surface_frame (surface); + wl_callback_add_listener (frame_callback, &frame_listener, NULL); + wl_surface_commit (surface); + wl_display_flush (display); +} + +static const struct xdg_surface_listener xdg_surface_listener = { + handle_xdg_surface_configure, +}; + +static void +handle_xdg_wm_base_ping (void *data, + struct xdg_wm_base *xdg_wm_base, + uint32_t serial) +{ + xdg_wm_base_pong (xdg_wm_base, serial); +} + +static const struct xdg_wm_base_listener xdg_wm_base_listener = { + handle_xdg_wm_base_ping, +}; + +static void +handle_registry_global (void *data, + struct wl_registry *registry, + uint32_t id, + const char *interface, + uint32_t version) +{ + if (strcmp (interface, "wl_compositor") == 0) + { + compositor = wl_registry_bind (registry, id, &wl_compositor_interface, 1); + } + else if (strcmp (interface, "wl_subcompositor") == 0) + { + subcompositor = wl_registry_bind (registry, + id, &wl_subcompositor_interface, 1); + } + else if (strcmp (interface, "xdg_wm_base") == 0) + { + xdg_wm_base = wl_registry_bind (registry, id, + &xdg_wm_base_interface, 1); + xdg_wm_base_add_listener (xdg_wm_base, &xdg_wm_base_listener, NULL); + } + else if (strcmp (interface, "wl_shm") == 0) + { + shm = wl_registry_bind (registry, + id, &wl_shm_interface, 1); + } + else if (strcmp (interface, "test_driver") == 0) + { + test_driver = wl_registry_bind (registry, id, &test_driver_interface, 1); + } +} + +static void +handle_registry_global_remove (void *data, + struct wl_registry *registry, + uint32_t name) +{ +} + +static const struct wl_registry_listener registry_listener = { + handle_registry_global, + handle_registry_global_remove +}; + +static void +init_surfaces (void) +{ + surface = wl_compositor_create_surface (compositor); + xdg_surface = xdg_wm_base_get_xdg_surface (xdg_wm_base, surface); + xdg_surface_add_listener (xdg_surface, &xdg_surface_listener, NULL); + xdg_toplevel = xdg_surface_get_toplevel (xdg_surface); + xdg_toplevel_add_listener (xdg_toplevel, &xdg_toplevel_listener, NULL); + xdg_toplevel_set_title (xdg_toplevel, "subsurface-reparenting-test"); + + subsurface = wl_subcompositor_get_subsurface (subcompositor, + subsurface_surface, + surface); + wl_subsurface_set_position (subsurface, 100, 100); + wl_surface_commit (surface); +} + +int +main (int argc, + char **argv) +{ + display = wl_display_connect (NULL); + registry = wl_display_get_registry (display); + wl_registry_add_listener (registry, ®istry_listener, NULL); + wl_display_roundtrip (display); + + if (!shm) + { + fprintf (stderr, "No wl_shm global\n"); + return EXIT_FAILURE; + } + + if (!xdg_wm_base) + { + fprintf (stderr, "No xdg_wm_base global\n"); + return EXIT_FAILURE; + } + + wl_display_roundtrip (display); + + g_assert_nonnull (test_driver); + + subsurface_surface = wl_compositor_create_surface (compositor); + draw_subsurface (); + wl_surface_commit (subsurface_surface); + + init_surfaces (); + state = STATE_WAIT_FOR_CONFIGURE_1; + + while (TRUE) + { + if (wl_display_dispatch (display) == -1) + return EXIT_FAILURE; + } + + return EXIT_SUCCESS; +} diff --git a/src/tests/wayland-unit-tests.c b/src/tests/wayland-unit-tests.c index 98c2d905a..9dd3831c6 100644 --- a/src/tests/wayland-unit-tests.c +++ b/src/tests/wayland-unit-tests.c @@ -148,6 +148,15 @@ subsurface_remap_toplevel (void) wayland_test_client_finish (wayland_test_client); } +static void +subsurface_reparenting (void) +{ + WaylandTestClient *wayland_test_client; + + wayland_test_client = wayland_test_client_new ("subsurface-reparenting"); + wayland_test_client_finish (wayland_test_client); +} + static void subsurface_invalid_subsurfaces (void) { @@ -255,6 +264,8 @@ init_wayland_tests (void) { g_test_add_func ("/wayland/subsurface/remap-toplevel", subsurface_remap_toplevel); + g_test_add_func ("/wayland/subsurface/reparent", + subsurface_reparenting); g_test_add_func ("/wayland/subsurface/invalid-subsurfaces", subsurface_invalid_subsurfaces); g_test_add_func ("/wayland/subsurface/invalid-xdg-shell-actions",