Start to fix wayland backend

Starts to update the wayland backend to the new backend api.
Not yet updated to libinput branch (not yet compiling).

backend/CMakeLists.txt

@@ -5,10 +5,10 @@ include_directories(
 )
 
 add_library(wlr-backend
-    #wayland/backend.c
+    wayland/backend.c
-    #wayland/registry.c
+    wayland/registry.c
-    #wayland/wl_seat.c
+    wayland/wl_seat.c
-    #wayland/wl_output.c
+    wayland/wl_output.c
     drm/backend.c
     drm/drm.c
     udev.c

backend/wayland/backend.c

@@ -2,58 +2,84 @@
 #include <stdint.h>
 #include <wayland-server.h>
 #include <assert.h>
+#include <wlr/backend/interface.h>
 #include "backend/wayland.h"
 #include "common/log.h"
 
-void wlr_wl_backend_free(struct wlr_wl_backend *backend) {
+/*
-	if (!backend) {
+ * Initializes the wayland backend. Opens a connection to a remote wayland
+ * compositor and creates surfaces for each output, then registers globals on
+ * the specified display.
+ */
+static bool wlr_wl_backend_init(struct wlr_backend_state* state) {
+	state->remote_display = wl_display_connect(getenv("_WAYLAND_DISPLAY"));
+	if (!state->remote_display) {
+		wlr_log(L_ERROR, "Could not connect to remote display");
+		return false;
+	}
+
+	if (!(state->registry = wl_display_get_registry(state->remote_display))) {
+		wlr_log(L_ERROR, "Could not obtain reference to remote registry");
+		return false;
+	}
+
+	wlr_wlb_registry_poll(state);
+	return true;
+}
+
+static void wlr_wl_backend_destroy(struct wlr_backend_state *state) {
+	if (!state) {
 		return;
 	}
+
 	// TODO: Free surfaces
-	for (size_t i = 0; backend->outputs && i < backend->outputs->length; ++i) {
+	for (size_t i = 0; state->outputs && i < state->outputs->length; ++i) {
-		struct wlr_wl_output *output = backend->outputs->items[i];
+		struct wlr_wl_output *output = state->outputs->items[i];
 		wlr_wl_output_free(output);
 	}
-	list_free(backend->outputs);
+
-	if (backend->seat) wlr_wl_seat_free(backend->seat);
+	list_free(state->outputs);
-	if (backend->shm) wl_shm_destroy(backend->shm);
+	if (state->seat) wlr_wl_seat_free(state->seat);
-	if (backend->shell) wl_shell_destroy(backend->shell);
+	if (state->shm) wl_shm_destroy(state->shm);
-	if (backend->compositor) wl_compositor_destroy(backend->compositor);
+	if (state->shell) wl_shell_destroy(state->shell);
-	if (backend->registry) wl_registry_destroy(backend->registry);
+	if (state->compositor) wl_compositor_destroy(state->compositor);
-	if (backend->remote_display) wl_display_disconnect(backend->remote_display);
+	if (state->registry) wl_registry_destroy(state->registry);
-	free(backend);
+	if (state->remote_display) wl_display_disconnect(state->remote_display);
+	free(state);
 }
 
-/*
+static struct wlr_backend_impl backend_impl = {
- * Initializes the wayland backend. Opens a connection to a remote wayland
+	.init = wlr_wl_backend_init,
- * compositor and creates surfaces for each output, then registers globals on
+	.destroy = wlr_wl_backend_destroy
- * the specified display.
+};
- */
+
-struct wlr_wl_backend *wlr_wl_backend_init(
+
-		struct wl_display *display, size_t outputs) {
+struct wlr_backend *wlr_wl_backend_create(struct wl_display *display,
-	assert(display);
+		size_t outputs) {
-	struct wlr_wl_backend *backend;
+	wlr_log(L_INFO, "Initalizing wayland backend");
-	if (!(backend = calloc(sizeof(struct wlr_wl_backend), 1))) {
+
-		wlr_log(L_ERROR, "Could not allocate backend");
+	struct wlr_backend_state *state = calloc(1, sizeof(struct wlr_backend_state));
-		goto error;
+	if (!state) {
-	}
+		wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
-	if (!(backend->outputs = list_create())) {
+		return NULL;
-		wlr_log(L_ERROR, "Could not allocate output list");
-		goto error;
 	}
-	backend->local_display = display;
+
-	backend->remote_display = wl_display_connect(getenv("_WAYLAND_DISPLAY"));
+	struct wlr_backend *backend = wlr_backend_create(&backend_impl, state);
-	if (!backend->remote_display) {
+	if (!backend) {
-		wlr_log(L_ERROR, "Could not connect to remote display");
+		wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
-		goto error;
+		return NULL;
 	}
-	if (!(backend->registry = wl_display_get_registry(backend->remote_display))) {
+
-		wlr_log(L_ERROR, "Could not obtain reference to remote registry");
+	if (!(state->outputs = list_create())) {
+		wlr_log(L_ERROR, "Could not allocate output list");
 		goto error;
 	}
-	wlr_wlb_registry_poll(backend);
+	state->local_display = display;
+
 	return backend;
+
 error:
-	wlr_wl_backend_free(backend);
+	free(state);
+	free(backend);
 	return NULL;
 }

include/backend/wayland.h

@@ -5,8 +5,9 @@
 #include <wayland-server.h>
 #include <wlr/common/list.h>
 #include <wlr/wayland.h>
+#include <wlr/backend/wayland.h>
 
-struct wlr_wl_backend {
+struct wlr_backend_state {
 	/* local state */
 	struct wl_display *local_display;
 	/* remote state */
@@ -19,7 +20,7 @@ struct wlr_wl_backend {
 	list_t *outputs;
 };
 
-void wlr_wlb_registry_poll(struct wlr_wl_backend *backend);
+void wlr_wlb_registry_poll(struct wlr_backend_state *backend);
 
 extern const struct wl_seat_listener seat_listener;
 extern const struct wl_output_listener output_listener;

include/wlr/backend/wayland.h

@@ -1,14 +1,11 @@
-#ifndef _WLR_BACKEND_WAYLAND_INTERNAL_H
+#ifndef WLR_BACKEND_WAYLAND_H
-#define _WLR_BACKEND_WAYLAND_INTERNAL_H
+#define WLR_BACKEND_WAYLAND_H
 
 #include <wayland-client.h>
 #include <wayland-server.h>
-#include <wlr/wayland.h>
+#include <wlr/backend.h>
 
-struct wlr_wl_backend;
+struct wlr_backend *wlr_wl_backend_create(struct wl_display *display,
-
-void wlr_wl_backend_free(struct wlr_wl_backend *backend);
-struct wlr_wl_backend *wlr_wl_backend_init(struct wl_display *display,
 		size_t outputs);
 
 #endif